> ## 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. # Rust Let Else The `let else` statement is a control flow construct that performs a refutable pattern match, binding extracted variables to the enclosing lexical scope on success, or executing a mandatory diverging block on failure. ```rust theme={"dark"} let PATTERN = EXPRESSION else { DIVERGING_CODE }; ``` ## Mechanics and Behavior **1. Scope Binding** Unlike `if let` or `match`, which restrict variable bindings to their respective inner blocks, `let else` flattens the scope. If the `EXPRESSION` successfully matches the `PATTERN`, any variables declared within the pattern are bound to the surrounding scope for the remainder of the block. **2. The Divergence Requirement** If the pattern match fails, the `else` block is executed. The Rust compiler strictly enforces that the `else` block must evaluate to the never type (`!`). It cannot provide a fallback value to the `let` binding, nor can it allow execution to continue to the next statement. It must permanently interrupt the current control flow using: * `return` * `break` * `continue` * `panic!` (or macros that expand to a panic, like `unreachable!`) **3. Refutability Constraint** The `PATTERN` used in a `let else` statement must be refutable (a pattern that can fail to match). Using an irrefutable pattern (such as a standard variable assignment `let x = 5 else {...}`) will result in a compiler warning or error, as the `else` block would be mathematically unreachable. ## Syntax Visualization ```rust theme={"dark"} fn extract_and_proceed(input: Option) { // The pattern `Some(inner_string)` is refutable. let Some(inner_string) = input else { // This block executes if `input` is `None`. // It must diverge. Returning satisfies the `!` type requirement. return; }; // `inner_string` is now bound to the outer function scope. // Execution only reaches here if the pattern match succeeded. println!("Extracted: {}", inner_string); } ``` ## Type System Interaction Because the `else` block is guaranteed to diverge, the compiler's borrow checker and type inference systems know that any code following the `let else` statement is only reachable if the pattern matched perfectly. This allows the compiler to safely strip away wrapper types (like `Option` or `Result`) and expose the inner types to the current scope without requiring nested indentation or unwrap operations.

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