Boolean

The Boolean operation folds one or more Boolean inputs with a logical operator — AND, OR, XOR, NAND, NOR, or XNOR — and writes the Boolean result to a single output.

With a single input, AND / OR / XOR pass the value through and NAND / NOR / XNOR invert it. To render the Boolean result as an Integer (1/0) or a labelled String ("on"/"off", "Yes"/"No"), chain a Convert node downstream.

With AND, OR or XOR and exactly one Data input connected, the result is that input unchanged, and the Editor shows an info badge on the Node saying so; NAND, NOR and XNOR invert a single input and carry no such note. An unconnected Data port is the Task Compiler’s mandatory-input error instead.

Inputs

Port	Type	Required	Description
> (Gate)	Any	No	When connected, a false or Nil value stops the path. See Gate Inputs.
Data	Boolean	Yes (first port)	Boolean operand. Up to 20 Data ports total — the first is mandatory, the rest are added on demand in the Node’s Settings tab.

Outputs

Port	Type	Default	Description
Out	Boolean	Nil	Fold result.

Properties

Name	Type	Default	Description
Operation Type	Combo	AND	Logical operation: AND, OR, XOR, NAND, NOR, XNOR.

State on Reload

Output is preserved across restarts within the configured time window.

Boolean's own fold cannot fail

Boolean’s fold has no runtime error of its own — every Data port carries a strict Boolean type mask, and the fold always produces a valid result from values that pass it. The Node still carries an On Error verb, because a value that fails a port’s type mask fails the Node and is resolved by that verb; an Input whose Validation rule is not satisfied stops the Node instead, and consults no verb. Which values are waited for is set per-Port via the Per-Port Input Validation dropdown.

---

Fold Semantics (N ≥ 1 inputs)

All operations are commutative and defined uniformly over any number of connected Data ports:

Operation	N-ary meaning	Single-input result
AND	true iff every connected input is true	passes input through
OR	true iff any connected input is true	passes input through
XOR	true iff an odd number of connected inputs are true (parity)	passes input through
NAND	!AND	inverts the input (free NOT gate)
NOR	!OR	inverts the input
XNOR	!XOR — true iff an even number of connected inputs are true	inverts the input

Unconnected Data ports are skipped by the fold — you can declare up to 20 ports and connect only the ones you need.

Boolean → Integer / String conversion

Chain a Convert node after the Boolean Out port. Convert’s Output Format picker (Strict Integer, String with custom True / False text, etc.) handles the rendering; Boolean stays focused on the logical fold.

---

How It Works

1. Gate check — If a Gate input is connected, evaluate it. A false or Nil value stops the execution path; the output keeps its previous value.

2. Type-mask check (Runner) — Every connected Data input is checked against the Boolean type mask. A non-Boolean value fails the Node with a TypeMismatch reason before the operation runs; the Node’s On Error verb resolves the failure, and under the default verb the branch stops.

3. Fold — Collect the values of every connected Data input and apply the selected operation.

4. Emit — The Boolean result is written to Out.

---

Examples

Data format

All inputs and outputs use MessagePack internally. The examples below show values in JSON notation for readability.

AND (2 inputs)

Operation Type: AND

Input	Value
Data (1)	true
Data (2)	true

Output: true

OR (4 inputs)

Operation Type: OR

Input	Value
Data (1)	false
Data (2)	false
Data (3)	true
Data (4)	false

Output: true

XOR parity (3 inputs)

Operation Type: XOR

Input	Value
Data (1)	true
Data (2)	true
Data (3)	true

Output: true (three trues → odd parity)

NAND as NOT

Operation Type: NAND

Input	Value
Data (1)	true

Output: false — with a single input, NAND / NOR / XNOR invert the value.

Gate blocks

Operation Type: AND

Input	Value
Gate	false

The gate is closed. The operation does not run, the output keeps its previous value, and the execution path stops at this Node.

---

Use Cases

• Combining many boolean flags into a single decision with one node instead of a chain.
• Parity checks (XOR / XNOR across N signals).
• Inverting a boolean with a single-input NAND / NOR / XNOR.
• For numeric / labelled-String rendering of the fold result, chain a Convert node.

---

Limitations

• Every connected Data input must be Boolean. A non-Boolean value fails the Node at the runtime type check, and the Node’s On Error verb resolves the failure.
• XNOR is defined as !XOR (even-parity convention), not as “all inputs equal”. For N ≥ 3 the two definitions differ — for example XNOR(true, true, true) is false, not true.
• Maximum fan-in is 20 Data ports.