Pattern Matching

Destructure and branch with match, if let, and advanced patterns. Results appear in the same fence: same-line // comments when short, multiline // blocks below the sample when not.

match Arms

Exhaustive arms with | alternatives and _ catch-all.

match 2 {
    1 | 2 => "small",
    _ => "big",
}  // "small"

if let

Handle one pattern without a full match.

let v = Some(3);
if let Some(n) = v { n } else { 0 }  // 3

while let

Loop while a pattern matches.

let mut stack = vec![1, 2];
let mut sum = 0;
while let Some(n) = stack.pop() { sum += n; }
sum  // 3

Match Guards

Add if conditions after a pattern.

let n = 4;
match n {
    x if x % 2 == 0 => "even",
    _ => "odd",
}  // "even"

@ Bindings

Bind a name while testing a pattern.

match 5 {
    n @ 1..=10 => n,
    _ => 0,
}  // 5

Destructure Struct

Pull fields out in match or let.

struct P { x: i32, y: i32 }
let P { x, y } = P { x: 1, y: 2 };
x + y  // 3

Destructure Tuple

Nested tuple patterns.

let ((a, b), c) = ((1, 2), 3);
a + b + c  // 6

Ignore with _

Discard values you do not need.

let (x, _) = (1, 99);
x  // 1

Nested Enum

Match through Option and custom enums.

enum E { A(i32), B }
match Some(E::A(7)) {
    Some(E::A(n)) => n,
    _ => 0,
}  // 7

Slice Patterns

Match prefixes of slices (stable patterns).

match &[1, 2, 3][..] {
    [a, b, ..] => a + b,
    _ => 0,
}  // 3

or Patterns Nested

Combine patterns deeply.

match (true, 1) {
    (true, 1 | 2) => "ok",
    _ => "no",
}  // "ok"

matches Macro

Boolean test without binding.

matches!(Some(1), Some(_))  // true

let else

Diverge on failed pattern (let-else).

let Some(n) = Some(3) else { panic!("none") };
n  // 3

ref mut Pattern

Borrow mutably inside a match.

let mut s = Some(String::from("a"));
if let Some(ref mut v) = s { v.push('b'); }
s  // Some("ab")

Range Patterns

Inclusive and exclusive ranges in match.

match 5u8 {
    0..=9 => "digit",
    _ => "other",
}  // "digit"

Related

• Structs and Enums - data you match on
• Error Handling - match on Result
• Ownership and Borrowing - ref patterns

External Related Links

• The Rust Programming Language (The Book) - Canonical beginner-to-intermediate guide (ownership, borrowing, traits, etc.).
• Rust By Example - Runnable examples covering language features and standard library.
• The Rust Reference - Formal language reference (precise semantics).
• The Rust Programming Language, 2nd Edition (Amazon) - Steve Klabnik & Carol Nichols.
• Programming Rust, 2nd Edition (O'Reilly) - Same Programming Rust on O'Reilly.

Stack versions: Rust 1.97.0 · edition 2024 · Tokio 1.x · serde 1.0