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

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.

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.

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<Element> and mutates the array, ensuring the loop eventually terminates.

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

Master Swift with Deep Grasping Methodology!

Learn More