Pattern Matching Fundamentals

In this lesson, you will learn how to deconstruct complex data structures using match expressions to create readable, safe logic branches.

In Rust, a match expression is much more than a simple "if-else" statement; it is a powerful tool that forces you to inspect every possible shape of your data. When you have a custom enum or a struct, the compiler ensures that your code handles every variant explicitly. If you forget a possibility, the code won't compile, acting as a safeguard against logical oversights.

Deconstructing with Patterns

You can use patterns to "reach inside" a data structure and bind its internal values to new variables. Imagine you have an enum representing a UI action:

enum UserAction {
    Click(i32, i32), // X and Y coordinates
    KeyPress(char),
    Quit,
}

fn process_action(action: UserAction) {
    match action {
        UserAction::Click(x, y) => println!("Clicked at {}, {}", x, y),
        UserAction::KeyPress(c) => println!("Pressed key: {}", c),
        UserAction::Quit => println!("Quitting application"),
    }
}

In this example, the match expression does two things: it identifies the variant (like Click) and simultaneously "destructures" it, pulling the two i32 values out of the Click variant and assigning them to the variables x and y.

Why this is safer

Because Rust knows the exact layout of your enum, it ensures that your logic covers every branch. If you added a new variant to UserAction (like Scroll), the compiler would immediately flag the match block as an error until you added a case for Scroll. This makes your code extremely resilient as your data structures evolve over time, as you are alerted to every place that needs an update to handle the new "shape" of your data.

By using pattern matching, you turn complex branching logic into a clean, exhaustive, and declarative flow that is easy for both you and the compiler to verify.

Key Takeaway: Pattern matching allows you to simultaneously check the variant of a data structure and deconstruct its internal values, with the compiler enforcing exhaustive coverage to prevent missed edge cases.