> ## 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 While Let The `while let` construct is a control flow statement that combines a `while` loop with optional binding. It repeatedly evaluates an expression returning an `Optional`, unwraps the underlying value if it exists, binds it to a newly declared local constant or variable, and executes the loop body. The loop terminates immediately when the evaluated expression returns `nil`. ## Syntax ```swift theme={"dark"} while let boundConstant = optionalExpression { // Loop body // boundConstant is available here as a non-optional type } ``` ## Execution Mechanics 1. **Evaluation:** The `optionalExpression` is evaluated at the start of every iteration. 2. **Pattern Matching:** * If the expression evaluates to `.some(Wrapped)`, the payload is unwrapped and bound to `boundConstant`. Control flow enters the loop body. * If the expression evaluates to `.none` (`nil`), the binding fails, the loop terminates, and control flow transfers to the first statement following the loop's closing brace. 3. **Scoping:** The lexical scope of `boundConstant` is strictly limited to the body of the `while` loop. It cannot be accessed outside of the loop. 4. **Re-evaluation:** After the loop body finishes executing, control jumps back to step 1. The `optionalExpression` must eventually evaluate to `nil` (typically through mutation or state advancement during the evaluation itself), otherwise the construct results in an infinite loop. ## Structural Variations **Mutable Binding** You can substitute `let` with `var` if you need to mutate the unwrapped value locally within the loop body. This mutation does not affect the original optional. ```swift theme={"dark"} while var mutableBoundValue = optionalExpression { mutableBoundValue += 1 // mutableBoundValue is modified locally } ``` **Compound Conditions** A `while let` statement can evaluate multiple optional bindings and boolean conditions sequentially in a single line, separated by commas. Evaluation short-circuits from left to right; if any optional binding evaluates to `nil` or any boolean condition evaluates to `false`, the loop terminates immediately. ```swift theme={"dark"} while let firstValue = firstOptional, let secondValue = secondOptional, firstValue < secondValue { // Executes only if both optionals are non-nil AND the boolean condition is true } ``` ## Mechanical Example The following demonstrates the mechanics of `while let` using an array's `popLast()` method, which returns an `Optional` and mutates the array, ensuring the loop eventually terminates. ```swift theme={"dark"} var stack = [10, 20, 30] // popLast() returns Int? while let topElement = stack.popLast() { print(topElement) } // Iteration 1: stack becomes [10, 20], topElement is 30 // Iteration 2: stack becomes [10], topElement is 20 // Iteration 3: stack becomes [], topElement is 10 // Iteration 4: popLast() returns nil, loop terminates ```

Tired of Poor Swift Skills? Fix That With Deep Grasping! Learn More