if let, let else & while let

These constructs match one pattern when a full match is heavy. let else provides early return on mismatch.

Recipe

fn main() {
    let v = Some(10);
    if let Some(n) = v {
        println!("{n}");
    }
 
    let Some(n) = v else {
        panic!("expected Some");
    };
    println!("forced {n}");
}

When to reach for this: Optional unwrapping, loop until None, and guard clauses with let else.

Working Example

use std::collections::VecDeque;
 
fn drain_even(q: &mut VecDeque<i32>) -> Vec<i32> {
    let mut out = Vec::new();
    while let Some(&front) = q.front() {
        if front % 2 == 0 {
            out.push(q.pop_front().unwrap());
        } else {
            break;
        }
    }
    out
}
 
fn main() {
    let mut q = VecDeque::from([2, 4, 5, 6]);
    println!("{:?}", drain_even(&mut q));
}

What this demonstrates:

• while let loops while pattern matches
• Combines with break when condition changes
• if let for single-case branch
• let else for required pattern (Rust 1.65+)

Deep Dive

if let

if let Err(e) = result {
    eprintln!("{e}");
}

let else

fn head(s: &str) -> &str {
    let Some((h, _)) = s.split_once(' ') else {
        return s;
    };
    h
}

else block must diverge (return, break, panic).

while let

Ideal for consuming iterators of Option or Result until None/Err break pattern.

Gotchas

• let else else block must diverge - Cannot fall through. Fix: return/break/panic!.
• Moving in if let - Binds move unless ref. Fix: if let Some(ref x).
• while let infinite if pattern always matches - Logic bug. Fix: Ensure iterator advances or state changes.
• Chaining many if let - Hard to read. Fix: Use match or combinator methods.
• if let + else not full replacement for match - Only one positive arm ergonomic. Fix: match for many arms.

Alternatives

FAQs

Related

• Pattern Matching with match
• Option & Result as Enums
• Option Combinators
• Control Flow

Stack versions: This page was written for Rust 1.97.0 (edition 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, and Polars 0.46+.