Else

The else keyword in Rust defines the fallback execution path for conditional control flow constructs, specifically if, if let, and let else. Because Rust is an expression-oriented language, else blocks often evaluate to a value, requiring strict type compatibility with their corresponding primary blocks.

fn main() {
    let condition = false;
    
    if condition {
        println!("Primary block executed");
    } else {
        println!("Fallback block executed");
    }
}

Expression Evaluation and Type Rules

Unlike statement-based languages, an if-else construct in Rust evaluates to the value of the final expression in the executed block (the tail expression). The Rust compiler enforces strict type checking across all branches.

Generally, the type yielded by the else block must be identical to the type yielded by the if block.

fn main() {
    let condition = true;
    
    // Valid: Both branches evaluate to i32
    let numeric_value: i32 = if condition {
        5
    } else {
        10
    };
    
    println!("Value: {numeric_value}");
}

The Never Type (!) Exception

If one of the branches diverges—meaning it evaluates to the never type ! by using panic!, return, break, or continue—it automatically coerces to the type of the other branch. This allows an else block to halt execution without violating the type uniformity rule.

fn main() {
    let condition = true;
    
    // Valid: The else branch diverges (!), coercing to the i32 type of the if branch
    let x: i32 = if condition { 
        5 
    } else { 
        panic!("Execution halted") 
    };
    
    println!("x is {x}");
}

The Implicit Unit Type ()

If an if expression does not have an else block, it implicitly evaluates to the unit type (). Consequently, if an if block evaluates to any type other than (), an else block is strictly required by the compiler to ensure the variable binding always receives a valid value of the expected type.

Branch Chaining (else if)

The else keyword can be immediately followed by another if expression to evaluate multiple mutually exclusive conditions sequentially. The type uniformity rule applies to the entire chain; every block in the if-else if-else sequence must evaluate to the same type or diverge.

fn main() {
    let code = 1;
    
    let state: &str = if code == 0 {
        "ok"
    } else if code == 1 {
        "warning"
    } else {
        "error"
    };
    
    println!("State: {state}");
}

if let and else

The else keyword is heavily utilized alongside the if let construct. While if let attempts to match a value against a specific pattern and bind variables, the else block provides the execution path for when the pattern match fails (refutable patterns).

fn main() {
    let my_var: Option<i32> = None;
    
    if let Some(x) = my_var {
        println!("Pattern matched, extracted: {x}");
    } else {
        println!("Pattern did not match, executing else block");
    }
}

let else Statements

Introduced in Rust 1.65, the else keyword is used in let else statements to handle refutable pattern matching without introducing rightward drift (nested scopes). This construct attempts to match a pattern and bind variables into the surrounding scope.

A strict compiler requirement for let else is that the else block must diverge. It cannot evaluate to a value and continue execution; it must transfer control flow out of the current scope.

fn main() {
    let optional_variable: Option<i32> = None;
    
    let Some(inner_value) = optional_variable else {
        println!("Match failed, diverging...");
        return; // This block must evaluate to the never type (!)
    };
    
    // inner_value is now bound and accessible in the outer scope
    println!("Value is: {inner_value}");
}

Master Rust with Deep Grasping Methodology!

Learn More