Logical OR

The || (Logical OR) operator is a binary infix operator that evaluates two Boolean expressions, returning true if at least one of the operands evaluates to true, and false only if both operands evaluate to false.

let lhsExpression = false
let rhsExpression = true
let result = lhsExpression || rhsExpression // true

Evaluation Mechanics

Short-Circuit Evaluation and @autoclosure Swift employs short-circuit evaluation for the || operator to optimize execution and prevent unnecessary computation. This is implemented at the language level by wrapping the right-hand side operand in an @autoclosure. The evaluation strictly follows a left-to-right order:

1. The left-hand side is evaluated first.
2. If the left-hand side evaluates to true, the overall expression immediately resolves to true. Because the right-hand side is an @autoclosure, its execution is deferred and ultimately bypassed.
3. If the left-hand side evaluates to false, the right-hand side closure is executed to determine the final Boolean result.

Truth Table

LHS	RHS	Result	RHS Evaluated?
true	true	true	No
true	false	true	No
false	true	true	Yes
false	false	false	Yes

Operator Characteristics

• Type Requirement: The left-hand operand must evaluate to a Bool, while the right-hand operand is defined in the standard library as an @autoclosure () throws -> Bool. Swift is strictly typed and does not support implicit truthiness or type coercion (e.g., non-zero integers or non-nil objects cannot be evaluated using ||).
• Associativity: Left-associative. Chained operations are grouped and evaluated from left to right. An expression like a || b || c is parsed as (a || b) || c.
• Precedence: The || operator belongs to the LogicalDisjunctionPrecedence group. It has a lower precedence than the && (Logical AND) operator, which belongs to the LogicalConjunctionPrecedence group. In mixed expressions without explicit parentheses, && is evaluated before ||.

let exprA = false
let exprB = true
let exprC = false

// Precedence visualization: && evaluates before ||
let mixedResult = exprA || exprB && exprC // false

// The compiler parses the above as:
let explicitResult = exprA || (exprB && exprC) // false

Master Swift with Deep Grasping Methodology!

Learn More