Logic¶

18 nodes. Types ending in [] are lists. An input with a default is optional.

Nodes¶

And¶

Returns true only when both inputs are true.

Inputs

Input	Type	Default	What it does
`a` required	`boolean`	—	First operand.
`b` required	`boolean`	—	Second operand.

Outputs

Output	Type	What it gives
`result`	`boolean`	True when both operands are true.

Tags: && conjunction boolean Logic.And

Equals¶

Tests whether two values are equal, the same way as Logic.Compare with ==: numbers compare by value (2 equals 2.0), text ignores upper and lower case, text that reads as a number equals that number ("5" equals 5), text that reads as a date equals that date, and two lists are equal when they have the same items in the same order. A list is compared as ONE value; to test every element of a list set List Levels to @L1 on a (an empty element is equal only to another empty one). For a case-sensitive text test use Logic.Compare with ignoreCase off, and for numbers within a tolerance use Math.IsClose.

Inputs

Input	Type	Default	What it does
`a` required	`any`	—	First value. A list is compared as one value; set List Levels to @L1 to compare every element instead.
`b` required	`any`	—	Second value.

Outputs

Output	Type	What it gives
`result`	`boolean`	True when the values are considered equal.

Tags: == equal same compare Logic.Equals

GreaterThan¶

Returns true when the first number is greater than the second.

Inputs

Input	Type	Default	What it does
`a` required	`number`	—	First operand.
`b` required	`number`	—	Second operand.

Outputs

Output	Type	What it gives
`result`	`boolean`	True when a > b.

Tags: > compare larger Logic.GreaterThan

GreaterThanOrEqual¶

Returns true when the first number is greater than or equal to the second.

Inputs

Input	Type	Default	What it does
`a` required	`number`	—	First operand.
`b` required	`number`	—	Second operand.

Outputs

Output	Type	What it gives
`result`	`boolean`	True when a >= b.

Tags: >= compare atleast Logic.GreaterThanOrEqual

If¶

Returns one of two values depending on a boolean condition. Both branches are always computed, so a node wired into the unused branch still runs: to skip nodes (a modifying node, a slow search) use Flow.When instead. A list of booleans on test gives a list of choices.

Inputs

Input	Type	Default	What it does
`test` required	`boolean`	—	The condition to evaluate.
`trueValue` required	`any`	—	Value returned when the condition is true.
`falseValue` required	`any`	—	Value returned when the condition is false.

Outputs

Output	Type	What it gives
`result`	`any`	Either trueValue or falseValue.

Tags: condition branch ternary switch flow when Logic.If

IsNull¶

True when the value is null (nothing came out). Wired to a list it tests the LIST, which is never null; set the input's List Levels to @L1 to test every element instead, and each empty element gives true. That gives the bool mask for List.FilterByBoolMask (pair with Not to keep the non-nulls). Text that is empty or blank is not null: use IsNullOrEmpty or String.IsBlank for that.

Inputs

Input	Type	Default	What it does
`value` required	`any`	—	The value to test. A list is tested as a whole (a list is never null). To test each element of a list, set this input's List Levels to @L1: an empty element then gives true.

Outputs

Output	Type	What it gives
`isNull`	`boolean`	True when the value is null.

Tags: null is check missing empty mask test Logic.IsNull

IsNullOrEmpty¶

True when the value is null, an empty string, an empty list or an empty dictionary — the guard for "did anything come out?" checks before If branches. NOTE: wired to a list directly it tests the LIST (empty or not); set the input's List Levels to @L1 to test each element instead, and each empty element gives true. Text of only spaces is not empty here: String.IsBlank counts it as blank.

Inputs

Input	Type	Default	What it does
`value` required	`any`	—	The value to test: null, an empty string, an empty list and an empty dictionary all count as empty. To test each element of a list, set this input's List Levels to @L1: an empty element then gives true.

Outputs

Output	Type	What it gives
`isEmpty`	`boolean`	True when the value is null or empty.

Tags: null empty is check missing guard test Logic.IsNullOrEmpty

LessThan¶

Returns true when the first number is less than the second.

Inputs

Input	Type	Default	What it does
`a` required	`number`	—	First operand.
`b` required	`number`	—	Second operand.

Outputs

Output	Type	What it gives
`result`	`boolean`	True when a < b.

Tags: < compare smaller Logic.LessThan

LessThanOrEqual¶

Returns true when the first number is less than or equal to the second.

Inputs

Input	Type	Default	What it does
`a` required	`number`	—	First operand.
`b` required	`number`	—	Second operand.

Outputs

Output	Type	What it gives
`result`	`boolean`	True when a <= b.

Tags: <= compare atmost Logic.LessThanOrEqual

Logic.Choose¶

Picks one of several options by position (0 = first) — a multi-way If. All options are always computed, so a node wired into an option that is not picked still runs: to skip nodes use Flow.When.

Inputs

Input	Type	Default	What it does
`index` required	`integer`	—	Which option, counting from 0.
`options` any number of wires required	`any[]`	—	The options (wire several nodes into the one socket, or a list).

Outputs

Output	Type	What it gives
`value`	`any`	The option at that index.

Tags: select pick switch index option multiplexer flow when

Logic.Compare¶

Compares two values — numbers, text or dates — with a test chosen from a list (==, >, contains, matches, regex …). Text that reads as a number is compared as a number, and text that reads as a date (2026-10-01) is compared as a date when the other side is a date. Text ignores upper and lower case unless ignoreCase is off (the regex test is the same). A missing value (empty or blank) is never greater or less than anything, so it does not pass > >= < <=; use isNull or isEmpty to find it. Equals and Logic.NotEquals follow the same rules for == and !=. A list on a is tested as ONE value: to test every element set List Levels to @L1 on a (or use List.FilterByValue to split a list). For numbers within a tolerance use Math.IsClose.

Inputs

Input	Type	Default	What it does
`a` required	`any`	—	The value to test. A list is tested as one value; set List Levels to @L1 on this input to test every element instead.
`b`	`any`	`null`	What to test it against (unused by the isNull / notNull / isEmpty / notEmpty tests).
`test`	`string`	`"=="`	The test: ==, !=, >, >=, <, <=, contains, !contains, startsWith, endsWith, matches (wildcards * and ?), regex, isNull, notNull, isEmpty, notEmpty.
`ignoreCase`	`boolean`	`true`	True (default) ignores upper/lower case when comparing text.

Outputs

Output	Type	What it gives
`result`	`boolean`	True when the test passes.

Tags: compare greater less equal date text contains wildcard regex test tolerance

Logic.IsBetween¶

True when a number, text or date lies between a lower and an upper bound (bounds included by default). Text that reads as a number or, next to a date, as a date is compared as one. A list on value (or on a bound) gives a list of answers, one per element, so a whole column can be tested at once. A missing value, or text that is not a number next to numbers, is not between; an empty bound is an error. To test a number against a target within a tolerance use Math.IsClose.

Inputs

Input	Type	Default	What it does
`value` required	`any`	—	The value to test (number, text or date). A list tests every element and gives a list of results. A missing value (empty or blank) is never between.
`min` required	`any`	—	The lower bound. A list pairs with the values.
`max` required	`any`	—	The upper bound. A list pairs with the values.
`inclusive`	`boolean`	`true`	True (default) counts the bounds themselves as inside.

Outputs

Output	Type	What it gives
`result`	`boolean`	True when the value is within the range.

Tags: range within between inside interval tolerance

Logic.NotEquals¶

True when two values are different — the opposite of Equals, with the same rules: numbers compare by value, text ignores upper and lower case, text that reads as a number or a date is compared as one, and two lists are equal when they have the same items in the same order. A list is compared as ONE value; to test every element of a list set List Levels to @L1 on a.

Inputs

Input	Type	Default	What it does
`a` required	`any`	—	First value. A list is compared as one value; set List Levels to @L1 to compare every element instead.
`b` required	`any`	—	Second value.

Outputs

Output	Type	What it gives
`result`	`boolean`	True when the values are not equal.

Tags: != different not equal unequal

Logic.Switch¶

Gives the result that goes with the first case equal to the value, otherwise the fallback — a status-to-colour or code-to-name mapping. Matching follows Equals: text ignores upper and lower case and text that reads as a number matches that number. A list on value is looked up element by element and gives a list of results. All results are computed whether or not they are picked; to skip nodes use Flow.When.

Inputs

Input	Type	Default	What it does
`value` required	`any`	—	The value to look for. A list looks every element up and gives a list of results (a status column becomes a colour column).
`cases` required	`any[]`	—	The values it can be.
`results` required	`any[]`	—	What to give for each case (same length as the cases).
`fallback`	`any`	`null`	What to give when no case matches (nothing by default).

Outputs

Output	Type	What it gives
`value`	`any`	The result for the first matching case, or the fallback.

Tags: case match map lookup translate switch select flow when

Logic.TypeOf¶

Names the kind of a value — number, text, boolean, datetime, list, dictionary, null or the object's type — for debugging what a node really returns.

Inputs

Input	Type	Default	What it does
`value` required	`any`	—	Any value.

Outputs

Output	Type	What it gives
`type`	`string`	One of: null, number, text, boolean, datetime, list, dictionary, or the type's name.

Tags: type kind debug inspect what is this class

Logic.Xor¶

True when exactly one of the two inputs is true.

Inputs

Input	Type	Default	What it does
`a` required	`boolean`	—	First operand.
`b` required	`boolean`	—	Second operand.

Outputs

Output	Type	What it gives
`result`	`boolean`	True when the two inputs differ.

Tags: exclusive or either one of

Not¶

Inverts a boolean value.

Inputs

Input	Type	Default	What it does
`value` required	`boolean`	—	The value to negate.

Outputs

Output	Type	What it gives
`result`	`boolean`	True when the input is false.

Tags: ! negate invert boolean Logic.Not

Or¶

Returns true when at least one input is true.

Inputs

Input	Type	Default	What it does
`a` required	`boolean`	—	First operand.
`b` required	`boolean`	—	Second operand.

Outputs

Output	Type	What it gives
`result`	`boolean`	True when at least one operand is true.

Tags: || disjunction boolean Logic.Or