Logical AND

The && (Logical AND) operator is a binary infix operator that evaluates two Boolean expressions, returning true if and only if both operands evaluate to true. If either operand evaluates to false, the entire expression yields false.

lhs && rhs

Technical Characteristics

• Short-Circuit Evaluation: Swift employs short-circuiting for the && operator at runtime. The left-hand side (lhs) expression is evaluated first. If lhs evaluates to false, the overall expression is mathematically guaranteed to be false, and the runtime bypasses the evaluation of the right-hand side (rhs) expression entirely. The rhs is evaluated strictly if and only if lhs evaluates to true.
• Standard Library Implementation: Unlike many languages where short-circuiting is a hardcoded compiler primitive, Swift implements && as a standard library function. It achieves deferred execution by marking the rhs parameter with the @autoclosure attribute:

static func && (lhs: Bool, rhs: @autoclosure () throws -> Bool) rethrows -> Bool

This attribute instructs the compiler to automatically wrap the rhs expression in a closure. This delays the evaluation of the rhs expression, allowing the function’s internal logic to execute the closure only if the lhs evaluates to true.

• Type Constraints: Both the lhs and rhs operands must be strictly of type Bool. Swift is strongly typed and does not support implicit truthiness or type coercion (e.g., integers or non-nil objects cannot be directly evaluated by &&).
• Associativity: The operator is left-associative. Chained && operations are grouped and evaluated from left to right.

// Evaluated as: (expr1 && expr2) && expr3
expr1 && expr2 && expr3

• Precedence: The && operator belongs to the LogicalConjunctionPrecedence group. It has a lower precedence than comparison operators (such as ==, <, >) but a higher precedence than the Logical OR operator (||).

Truth Table

lhs	rhs	lhs && rhs
true	true	true
true	false	false
false	(not evaluated)	false

Master Swift with Deep Grasping Methodology!

Learn More