Exhaustive Pattern Matching with `match`

1. The match Control Flow Construct

At its core, match allows you to compare a value against a series of patterns and execute code based on which pattern matches. The Rust documentation uses a great analogy: a match expression is like a coin-sorting machine. A coin falls through the first hole it fits into; similarly, a value is checked against each pattern, and the code for the first matching pattern is executed.

Each "pattern + code" combination is called an arm.

match some_value {
pattern1 => { // code for when some_value matches pattern1 }
pattern2 => { // code for when some_value matches pattern2 }
_ => { // code for any other case }
}

Let's start with a video that introduces the match expression and shows how it's commonly used with enums.

A simple match expression might look like this:

2. Exhaustiveness: Rust's Compile-Time Safety

One of the most powerful features of match is that it is exhaustive. This means you must cover every single possible case for the value you are matching against. If you forget a case, your code won't compile. This prevents a whole class of bugs common in other languages where you might forget to handle a specific value or state.

This is a feature you'll come to appreciate, as the compiler becomes your partner in writing correct code.

So what do you do if you have many possibilities, but only care about a few? You use the special wildcard pattern: _. The _ pattern will match any value that hasn't been matched by a preceding arm, satisfying the exhaustiveness requirement without forcing you to list every single possibility.

3. Advanced Pattern Matching

match can do much more than just check for simple enum variants or literal values.

Binding to Values in Patterns

Often, you need to extract the data stored inside an enum variant. match makes this easy by allowing you to bind the inner value to a new variable right in the pattern.

This is a powerful feature we'll use later. For instance, when a pawn is promoted, we might have a Promotion(PieceKind) move variant, and we'd use match to extract which piece the pawn is being promoted to.

Matching on Different Types

match isn't limited to enums. It can work on almost any type, including integers, strings, and more. You can match against ranges of values or even add conditions, called "match guards."

This flexibility makes match a go-to tool for complex conditional logic in Rust.

4. Hands-On: Scaffolding Our Chess Move Logic

Now, let's apply this to our chess project. The core logic of a chess game involves checking if a move is valid. This depends almost entirely on what kind of piece is moving. A pawn moves differently from a rook, which moves differently from a knight. This is a perfect use case for match!

We will create a new method is_move_valid for our Piece struct. For now, it will just be a skeleton that uses match to differentiate between the piece kinds. In future lessons, we'll fill in the real logic for each piece.

Task: Create the is_move_valid method.

1. Open your rust_chess project in src/main.rs.
2. Add a new method is_move_valid to the impl Piece block.
3. Inside this method, use a match expression on self.kind.
4. For each PieceKind, just print a message and return true.

Here is the code to add. Try to understand how it fits with what we've learned.

// In your `impl Piece` block, add this new method.

// We've added placeholder parameters for the new position and a list of all pieces.
// We're not using them yet, but we will need them later.
// The `_` before the variable names tells Rust we know they are unused for now.
fn is_move_valid(&self, _new_position: (u8, u8), _pieces: &Vec<Piece>) -> bool {
    // Match against the 'kind' of the piece instance (`self`).
    match self.kind() {
        PieceKind::Pawn => {
            println!("Validating a Pawn move...");
            true
        }
        PieceKind::Rook => {
            println!("Validating a Rook move...");
            true
        }
        PieceKind::Knight => {
            println!("Validating a Knight move...");
            true
        }
        PieceKind::Bishop => {
            println!("Validating a Bishop move...");
            true
        }
        PieceKind::Queen => {
            println!("Validating a Queen move...");
            true
        }
        PieceKind::King => {
            println!("Validating a King move...");
            true
        }
    }
}


// In your `main` function, add these lines to test your new method.
fn main() {
    // ... (previous code)

    let white_queen = Piece::new(PieceKind::Queen, PieceColor::White);
    let all_pieces = vec![]; // An empty list of pieces for now.
    
    // Call our new method on the queen instance
    white_queen.is_move_valid((4, 4), &all_pieces);
}

When you run this with cargo run, you should see the message "Validating a Queen move..." printed to the console. You've successfully created the foundation for our entire move validation logic!

To see where we are headed, take a look at how a real chess tutorial implements this exact function.

The code in that tutorial is the blueprint for what we will build over the next few modules. Our simple match block will eventually contain the full set of rules for each piece.

Conclusion

You've now learned about one of Rust's most powerful and distinctive features. match allows for expressive, safe, and robust conditional logic that you'll use constantly.

Key Takeaways:

• match allows you to compare a value against a series of patterns, or arms.
• match expressions must be exhaustive, meaning all possible cases must be handled. The compiler will give you an error if you miss one.
• The _ wildcard pattern acts as a catch-all for any cases you don't want to handle explicitly.
• match arms can bind variables to the data inside enums or other patterns, letting you extract and use that data.
• This pattern is central to implementing the core logic of our chess game.

In several of today's examples, you saw match being used on a type called Option<T>. This is Rust's way of handling values that might be absent (like null in other languages). In our next lesson, we will focus entirely on Option<T> and see how we can use it to represent empty squares on our chessboard.