> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Swift 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`.
```swift theme={"dark"}
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 `||`.
```swift theme={"dark"}
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
```
Tired of Poor Swift Skills? Fix That With Deep Grasping!
Learn More
