Pattern matching: match, if let and let else

Why match?

Enums are only useful if you can act on each variant and get its data out. match does this. It is like a switch statement in other languages, but much stronger: it can look inside data, and it is exhaustive, which means the compiler checks that every possible case is handled.

enum Payment {
    Upi(String),
    Card { last4: u16 },
    Cash,
}

fn describe(p: &Payment) -> String {
    match p {
        Payment::Upi(id) => format!("UPI from {id}"),
        Payment::Card { last4 } => format!("Card ending {last4}"),
        Payment::Cash => String::from("Cash"),
    }
}

A pattern describes the shape of a value. An arm is one pattern plus the code to run. The arms are tried from top to bottom, and the first matching arm runs. match is an expression, so all arms must produce the same type.

Exhaustiveness: the compiler remembers for you

match p {
    Payment::Upi(id) => println!("{id}"),
    Payment::Cash => println!("cash"),
}
// error[E0004]: non-exhaustive patterns: `&Payment::Card { .. }` not covered

More pattern tools

fn ticket_price(age: u32) -> u32 {
    match age {
        0..=4 => 0,                 // a range
        5..=11 => 60,
        60 | 61 | 62 => 70,         // several values with |
        a if a >= 63 => 50,         // a guard: an extra condition
        _ => 100,                   // the catch-all
    }
}

let point = (0, 7);
match point {
    (0, y) => println!("on the y axis at {y}"),
    (x, 0) => println!("on the x axis at {x}"),
    (x, y) => println!("at ({x}, {y})"),
}

if let: one interesting case

When you care about only one pattern, a full match with _ => () is long. if let is a shorter form. It runs the block only if the pattern matches. You can add else.

let coupon: Option<u32> = Some(150);
if let Some(off) = coupon {
    println!("Rs {off} off");
} else {
    println!("No coupon");
}

let else: get the value or leave

let else, stable since Rust 1.65, binds a value if the pattern matches; otherwise its else block runs, and that block must leave the current function or loop (return, break, continue or panic). It keeps the "happy path" un-indented.

fn parse_qty(text: &str) -> u32 {
    let Ok(n) = text.trim().parse::<u32>() else {
        return 0;
    };
    n
}

while let and matches!

let mut stack = vec![1, 2, 3];
while let Some(top) = stack.pop() {
    print!("{top} ");        // 3 2 1
}
println!();

let status = 'S';
let is_vowel = matches!(status, 'a' | 'e' | 'i' | 'o' | 'u');
println!("{is_vowel}");      // false

Binding modes in plain words

When you match on a reference, like &Payment, the bound variables are references too (id is a &String). This is why describe could take &Payment without moving anything out. If you match on an owned value, the data moves into the bound variables.

Common mistakes

• Putting _ first: every later arm is unreachable, and the compiler warns. Put specific arms first.
• Different types in different arms: match is an expression, so all arms must give the same type.
• Matching an owned value and then using it again: the data was moved into the pattern. Match on a reference (&value) instead.
• Using if let when two or more cases matter. Use a full match so the compiler can check them all.