Match Expressions

🎯 Pattern Matching in Rust: The Ultimate Sorting Machine

Imagine you have a magical sorting machine. You put something in, and it automatically figures out what it is and does the right thing!

🎪 The Story: The Magic Sorting Hat

Remember the sorting hat from Harry Potter? It looks at a student and decides which house they belong to. Rust’s pattern matching works exactly like that!

You give Rust a value, and it looks at the pattern to decide what to do.

🎭 Match Expression: The Decision Machine

Think of match like a vending machine. You put in a coin, and based on what coin it is, you get different snacks!

let coin = "quarter";

match coin {
    "penny" => println!("1 cent"),
    "nickel" => println!("5 cents"),
    "dime" => println!("10 cents"),
    "quarter" => println!("25 cents"),
    _ => println!("Unknown coin"),
}

What happens here?

• Rust checks: Is it a penny? No.
• Is it a nickel? No.
• Is it a dime? No.
• Is it a quarter? YES! → Print “25 cents”

🍎 Real-Life Example

let fruit = "apple";

let color = match fruit {
    "apple" => "red",
    "banana" => "yellow",
    "grape" => "purple",
    _ => "unknown",
};

println!("The {} is {}", fruit, color);
// Output: The apple is red

✅ Exhaustive Matching: You Must Cover EVERYTHING!

Imagine a traffic light. It can be red, yellow, or green. What if you forgot to tell the car what to do on yellow?

Rust says: “NO WAY! You must handle ALL possibilities!”

enum TrafficLight {
    Red,
    Yellow,
    Green,
}

let light = TrafficLight::Red;

match light {
    TrafficLight::Red => println!("Stop!"),
    TrafficLight::Yellow => println!("Slow down!"),
    TrafficLight::Green => println!("Go!"),
    // If you remove any line above,
    // Rust will complain!
}

🧠 Why is this awesome?

• You can never forget a case
• Your code is safer
• No surprises at runtime!

🎣 Catch-All Patterns: The Safety Net

Sometimes you can’t list every possibility. That’s where the catch-all comes in!

The _ Pattern (Underscore)

The underscore is like saying: “I don’t care what it is, just do this!”

let number = 42;

match number {
    1 => println!("One!"),
    2 => println!("Two!"),
    3 => println!("Three!"),
    _ => println!("Some other number"),
}
// Output: Some other number

Named Catch-All

Sometimes you want to use the value you caught:

let number = 42;

match number {
    1 => println!("One!"),
    2 => println!("Two!"),
    other => println!("Got: {}", other),
}
// Output: Got: 42

Rule: The catch-all MUST be last!

🔍 The matches! Macro: Quick True/False Check

Sometimes you just want to ask: “Does this match that pattern?”

Think of it like asking: “Is this a dog?” → Yes or No!

let pet = "dog";

let is_dog = matches!(pet, "dog");
println!("Is it a dog? {}", is_dog);
// Output: Is it a dog? true

More Examples

let number = 5;

// Is it between 1 and 10?
let in_range = matches!(number, 1..=10);
println!("In range? {}", in_range);
// Output: In range? true

// Is it 1, 2, or 3?
let small = matches!(number, 1 | 2 | 3);
println!("Is small? {}", small);
// Output: Is small? false

When to use matches!?

• When you need a simple yes/no answer
• When you want clean, readable code
• Perfect for conditions in if statements

🎁 if let: Unwrap ONE Pattern Only

Sometimes you only care about one specific case. Writing a full match feels like overkill!

The Problem

let gift = Some("toy");

// Full match - feels too long!
match gift {
    Some(item) => println!("Got: {}", item),
    None => {} // We don't care about None!
}

The Solution: if let

let gift = Some("toy");

if let Some(item) = gift {
    println!("Got: {}", item);
}
// Output: Got: toy

Translation: “If gift matches Some(item), then print it!”

With else

let gift: Option<&str> = None;

if let Some(item) = gift {
    println!("Got: {}", item);
} else {
    println!("No gift today!");
}
// Output: No gift today!

🔄 while let: Keep Going While Pattern Matches

Imagine eating cookies from a jar. You keep eating while there are cookies!

let mut stack = vec![1, 2, 3];

while let Some(top) = stack.pop() {
    println!("Popped: {}", top);
}
// Output:
// Popped: 3
// Popped: 2
// Popped: 1

What happens?

1. Pop 3 → matches Some(3) → print it
2. Pop 2 → matches Some(2) → print it
3. Pop 1 → matches Some(1) → print it
4. Pop nothing → returns None → loop stops!

🎮 Real Use Case: Processing a Queue

let mut tasks = vec!["email", "code", "lunch"];

while let Some(task) = tasks.pop() {
    println!("Doing: {}", task);
}
println!("All done!");

🛡️ let else: Match or ESCAPE!

This is the newest pattern! It says: “Match this pattern, OR ELSE get out of here!”

fn get_name(input: Option<&str>) -> &str {
    let Some(name) = input else {
        return "Anonymous";
    };
    name
}

println!("{}", get_name(Some("Alice")));
// Output: Alice

println!("{}", get_name(None));
// Output: Anonymous

How it works

1. Try to match the pattern
2. If it matches: Keep going with the value
3. If it doesn’t: Run the else block (must exit!)

The else block MUST diverge!

The else block must do something that never returns normally:

• return - exit the function
• break - exit a loop
• continue - skip to next iteration
• panic!() - crash the program

fn process(value: Option<i32>) -> i32 {
    let Some(x) = value else {
        panic!("Value was None!");
    };
    x * 2
}

🗺️ The Pattern Matching Family

graph TD
    A["Pattern Matching"] --> B["match"]
    A --> C["if let"]
    A --> D["while let"]
    A --> E["let else"]
    A --> F["matches!"]

    B --> B1["Full control"]
    B --> B2["Must be exhaustive"]

    C --> C1["One pattern"]
    C --> C2["Optional else"]

    D --> D1["Loop while matches"]

    E --> E1["Match or exit"]

    F --> F1["Returns bool"]

🎯 Quick Comparison

🌟 Putting It All Together

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    Color(i32, i32, i32),
}

fn handle(msg: Message) {
    // Full match for complex handling
    match msg {
        Message::Quit => {
            println!("Goodbye!");
        }
        Message::Move { x, y } => {
            println!("Move to ({}, {})", x, y);
        }
        Message::Write(text) => {
            println!("Message: {}", text);
        }
        Message::Color(r, g, b) => {
            println!("Color: RGB({},{},{})", r, g, b);
        }
    }
}

🚀 You Did It!

You now understand Rust’s powerful pattern matching:

1. ✅ match - The full decision machine
2. ✅ Exhaustive matching - Cover all cases!
3. ✅ Catch-all _ - The safety net
4. ✅ matches! - Quick true/false
5. ✅ if let - Handle one case
6. ✅ while let - Loop until no match
7. ✅ let else - Match or escape!

Pattern matching is like having superpowers for handling data. You’ll never look at conditionals the same way again! 🦀✨