Understanding Pattern Matching in Rust

Hello, fellow Rustaceans! I'm excited to share my findings and would warmly welcome your insights, corrections, or additional tips on this subject. Let's learn together!
Rust provides a rich set of tools for Pattern Matching - match, matches!, and if let being the notable ones. If you're coming from languages like JavaScript, Python, or C++, these might seem strange at first. But fear not! In this post, I'll aim to simplify these concepts and provide relatable examples to help you get comfortable with them.
What is Pattern Matching?

In essence, pattern matching is a way to check if some data fits a particular form or, well, 'pattern'. For example, in a list of numbers, you might want to know if a number is odd or even - this is a pattern you're looking for.

Rust provides a variety of ways to handle pattern matching, depending on your needs. We'll go through three of them: match, matches!, and if let

The match Keyword

match is Rust's most straightforward pattern-matching tool. Think of it as a more powerful switch statement found in other languages like JavaScript or C++. You provide match with a value and a series of patterns, each with associated code to run if the pattern matches the given value.

Here's a real-world example. Let's say we're creating a weather app. For different weather conditions, we want to display different messages.

In Rust, we might represent our weather conditions as an enum:

enum Weather {
    Sunny,
    Cloudy,
    Rainy,
    Snowy,
}

Now, we want to match the current weather to an appropriate message:

let today = Weather::Rainy;

match today {
    Weather::Sunny => println!("It's a sunny day! Don't forget your sunglasses."),
    Weather::Cloudy => println!("It's a bit grey outside."),
    Weather::Rainy => println!("Don't forget your umbrella!"),
    Weather::Snowy => println!("Wrap up warm, it's snowing."),
}

With match, we ensure that all possible cases are handled, making our code safer and more robust.

The matches! Macro

Now, let's look at matches!, a macro used to check if a value matches a pattern. The key point here is that matches! returns a boolean. It's useful when you care about whether a pattern is matched, but you don't need the specific value that matched.

Let's stick with our weather app example. Suppose we have a function that suggests taking an umbrella if it's rainy or snowy. We could use matches! to achieve this:

let today = Weather::Rainy;

if matches!(today, Weather::Rainy | Weather::Snowy) {
    println!("You might want to take an umbrella.");
} else {
    println!("An umbrella is not necessary.");
}

Here, matches! checks if the value of today matches either Weather::Rainy or Weather::Snowy, and gives advice accordingly.

The if let Expression

Finally, if let is a less verbose way to handle values that match one specific pattern while ignoring all other cases.

Imagine in our weather app, we have a premium feature that offers advice for snowy days. We only want to show this feature when it's snowing:

let today = Weather::Snowy;

if let Weather::Snowy = today {
    println!("Don't forget to layer up and wear boots!");
}

In this case, the message is only printed if today is Weather::Snowy. For all other weather conditions, nothing happens.

As we wrap up, let's reflect on the key takeaways:

1. match is a powerful tool that ensures exhaustive pattern matching. It's like a souped-up version of switch statements from other languages but with an extra layer of safety and versatility.

2. matches! allows us to determine whether a certain pattern matches a given value, returning a boolean. It's particularly handy when the focus is more on 'if' a pattern is met rather than 'what' the specific matching value is.

3. if let is your go-to when you want to match a single variant while conveniently ignoring others. It's a less verbose way of handling pattern matching for specific cases.

   Until next time, happy coding!