Why Match guards in Rust? - Purpose & Use Cases

The Big Idea

Discover how a simple extra check in patterns can save you from messy, buggy code!

The Scenario

Imagine you have a list of numbers and you want to do different things depending on their value, but only if they meet extra conditions, like being even or greater than 10.

Without match guards, you have to write many nested if-else checks inside each match arm, making your code long and confusing.

The Problem

Manually checking conditions inside each match arm leads to repeated code and mistakes.

It's easy to forget a condition or mix them up, causing bugs.

Also, the code becomes hard to read and maintain.

The Solution

Match guards let you add extra conditions directly to each match arm.

This keeps your code clean, readable, and easy to follow.

You write the condition once, right next to the pattern it applies to.

Before vs After

✗ Before

match num {
    _ => {
        if num % 2 == 0 {
            println!("Even number");
        } else if num > 10 {
            println!("Greater than 10");
        } else {
            println!("Other");
        }
    }
}

✓ After

match num {
    x if x % 2 == 0 => println!("Even number"),
    x if x > 10 => println!("Greater than 10"),
    _ => println!("Other")
}

What It Enables

You can write clear, concise code that handles complex conditions directly in pattern matching.

Real Life Example

When processing user input commands, you can match the command type and add guards to check if the user has the right permissions before running the command.

Key Takeaways

Match guards add extra conditions to match arms.

They make code easier to read and less error-prone.

They help handle complex logic cleanly in pattern matching.