If Let

if let is a control flow construct in Rust that provides syntactic sugar for a match expression designed to handle a single pattern while implicitly ignoring all other variants. It combines pattern matching, destructuring, and conditional execution into a single expression.

Syntax

if let PATTERN = EXPRESSION {
    // Executes if EXPRESSION matches PATTERN
    // Variables bound in PATTERN are scoped to this block
} else if let OTHER_PATTERN = EXPRESSION {
    // Optional: Chained pattern matching
} else {
    // Optional: Executes if the pattern match fails
}

Mechanics

1. Evaluation: The compiler evaluates the EXPRESSION on the right side of the = operator.
2. Pattern Matching: The evaluated result is compared against the PATTERN on the left side.
3. Binding: If the pattern matches, any variables declared within the PATTERN are bound to the corresponding inner values of the EXPRESSION.
4. Execution: The code block executes. The newly bound variables are strictly scoped to the lexical block of the if let statement.
5. Fall-through: If the pattern does not match, the binding fails, and control flow bypasses the block, proceeding to an else block if one is defined.

Equivalence to match

Under the hood, if let is structurally identical to a match statement with a specific pattern arm and a catch-all _ arm. If no else block is provided, the catch-all arm evaluates to the unit type (). If an else block is present, the catch-all arm evaluates to the contents of the else block.

// The if let construct:
if let Some(inner_value) = expression {
    // block
} else {
    // fallback block
}

// Is strictly equivalent to:
match expression {
    Some(inner_value) => {
        // block
    }
    _ => {
        // fallback block
    }
}

Technical Characteristics

• Refutability: The pattern used in an if let statement is designed for refutable patterns (patterns that can fail to match, such as Some(x) or Ok(v)). If an irrefutable pattern is provided (e.g., if let x = 5), the compiler will emit a warning, as the condition will always evaluate to true, rendering the if redundant compared to a standard let binding.
• Exhaustiveness Checking: Unlike a standard match expression, if let bypasses Rust’s strict exhaustiveness checking. The compiler does not require explicit handling of every possible variant of the underlying enum or type.
• Variable Shadowing: Variables bound inside the PATTERN will shadow variables of the same name in the outer scope. This shadowing persists only until the end of the if let block.
• Expression Context: Like most constructs in Rust, if let is an expression. It can evaluate to a value, provided both the if let block and the else block evaluate to the exact same type. If no else block is provided, the if let block must evaluate to the unit type ().

Master Rust with Deep Grasping Methodology!

Learn More