> ## 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 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`.
```swift theme={"dark"}
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:
```swift theme={"dark"}
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.
```swift theme={"dark"}
// 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` |
Tired of Poor Swift Skills? Fix That With Deep Grasping!
Learn More
