Rust Pattern Matching Practice: match, if let, Destructuring

The most common pattern matching error. Your match doesn't cover every variant:

// WRONG: missing None arm
fn describe(optional: Option<i32>) -> &'static str {
    match optional {
        Some(x) if x > 0 => "positive",
        Some(_) => "non-positive",
        // error[E0004]: non-exhaustive patterns: `None` not covered
    }
}

// RIGHT: handle all cases
fn describe(optional: Option<i32>) -> &'static str {
    match optional {
        Some(x) if x > 0 => "positive",
        Some(_) => "non-positive",
        None => "nothing",
    }
}

The compiler enforces exhaustiveness because unhandled cases are runtime bugs in other languages. In Rust, they're compile-time errors. If you add a variant to an enum, the compiler flags every match that needs updating. See structs and enums for how enum variants carry data that you destructure in match arms.

let bindings require irrefutable patterns — patterns that always match:

// WRONG: Some(x) might not match
// let Some(x) = some_option;
// error[E0005]: refutable pattern in local binding

// RIGHT Option 1: if let for "do something if it matches"
if let Some(x) = some_option {
    println!("{x}");
}

// RIGHT Option 2: let else for "bind or return early"
let Some(x) = some_option else {
    return;  // must diverge: return, break, continue, or panic!
};
println!("{x}");  // x is in scope here

let else is the "bind-or-return" pattern — it unwraps or exits the current block. The else branch must diverge (it cannot fall through).

With | patterns, every alternative must bind the same names:

// WRONG: x is bound on the left but not the right
// match pair {
//     (x, 0) | (0, _) => println!("{x}"),  // error[E0408]
//     _ => {}
// }

// RIGHT: bind x on both sides
match pair {
    (x, 0) | (0, x) => println!("{x}"),
    (a, b) => println!("({a}, {b})"),
}

Matching by value on borrowed data tries to move, which the borrow checker rejects:

// WRONG: matching by value moves out of the reference
// fn first_name(name: &Option<String>) -> String {
//     match name {
//         Some(s) => s.clone(),  // error[E0507]: cannot move out of *name
//         None => String::new(),
//     }
// }

// RIGHT: match on the reference — bind by reference
fn first_name(name: &Option<String>) -> String {
    match name {
        Some(s) => s.clone(),   // s is &String here (match ergonomics)
        None => String::new(),
    }
}
// Or be explicit:
fn first_name_explicit(name: &Option<String>) -> String {
    match *name {
        Some(ref s) => s.clone(),  // ref avoids the move
        None => String::new(),
    }
}

When matching on a reference, Rust automatically adjusts binding modes so Some(s) binds s as a reference. This is called match ergonomics. For a copy-ready reference of all pattern syntax, see the pattern matching cheat sheet.

Pull values out of structs, tuples, and enums directly in the pattern:

// Struct destructuring
let Point { x, y } = point;

// Tuple destructuring (use _ to ignore)
let (first, second, _) = tuple;

// Enum destructuring in match
match msg {
    Message::Move { x, y } => println!("move to ({x}, {y})"),
    Message::Write(text) => println!("{text}"),
    Message::Quit => println!("quit"),
}

// Nested destructuring
let ((a, b), Point { x, .. }) = (pair, point);

Patterns are not limited to match:

// if let: handle one pattern, skip the rest
if let Some(value) = optional {
    println!("{value}");
}

// while let: loop until the pattern stops matching
while let Some(value) = stack.pop() {
    println!("{value}");
}

// let else: bind or return early (must diverge)
let Ok(port) = env::var("PORT")
    .map(|v| v.parse::<u16>())
    .unwrap_or(Ok(8080)) else {
    eprintln!("invalid PORT");
    std::process::exit(1);
};

Patterns appear in more places than just match and if let:

// let bindings
let (x, y) = (1, 2);

// Function parameters
fn print_point(&Point { x, y }: &Point) {
    println!("({x}, {y})");
}

// for loops
for (i, value) in vec.iter().enumerate() {
    println!("{i}: {value}");
}

// Closure parameters
let sum = |(a, b): (i32, i32)| a + b;

Guards

Add conditions after a pattern with if. Guards don't affect exhaustiveness checking — the compiler still requires the patterns themselves to cover all possibilities:

match temperature {
    t if t > 100 => "boiling",
    t if t < 0 => "freezing",
    _ => "normal",  // required: guards don't count as exhaustive
}

Precedence gotcha: a guard applies to the entire | pattern, not just the last alternative:

match x {
    // guard applies to BOTH 4 and 5, not just 5
    4 | 5 if condition => "matched",
    _ => "other",
}

@ Bindings

Bind a value to a name while simultaneously testing it against a pattern:

match msg {
    Message::Hello { id: id @ 3..=7 } => println!("id in range: {id}"),
    Message::Hello { id } => println!("other id: {id}"),
    _ => (),
}

// @ with ranges
match age {
    n @ 0..=12 => println!("child aged {n}"),
    n @ 13..=19 => println!("teenager aged {n}"),
    n => println!("adult aged {n}"),
}

Match multiple patterns in a single arm:

match x {
    1 | 2 | 3 => println!("small"),
    _ => println!("big"),
}

Every alternative in a | pattern must bind the same variable names (E0408).

Match on slices with [] patterns. Use .. for the rest (only once per pattern):

match slice {
    [] => println!("empty"),
    [one] => println!("single: {one}"),
    [first, .., last] => println!("first: {first}, last: {last}"),
}

// Bind the tail with @
match slice {
    [head, tail @ ..] => println!("head: {head}, tail has {} elements", tail.len()),
    [] => println!("empty"),
}

// Bind the whole slice and destructure
match slice {
    whole @ [.., last] => println!("last of {}: {last}", whole.len()),
    [] => println!("empty"),
}

Only one .. is allowed per pattern — two would be ambiguous about which elements to skip. Exhaustive pattern matching on Result and Option is central to Rust's error handling approach, where the ? operator provides a concise alternative to match for propagating errors. Pattern matching also enables the Strategy design pattern, where different match arms dispatch to different behaviors.

• The Rust Book: Patterns and Matching — exhaustive treatment of all pattern types
• The Rust Book: Pattern Syntax — guards, @, |, .., and nested patterns
• Rust Reference: Patterns — formal grammar, all pattern kinds
• Rust By Example: match — practical examples with destructuring