Pattern Matching

Introduction

Rust is a statically typed language that emphasizes safety, speed, and concurrency. One of its powerful features is pattern matching, which allows you to match values against patterns and execute code based on those matches. This tutorial will cover the basics of pattern matching using match and if let statements.

Concept

Pattern matching in Rust is similar to switch-case statements found in other languages, but it's much more powerful and flexible. It can be used with any type that implements the PartialEq trait, which includes most standard types like integers, strings, enums, etc.

Match Statement

The match statement is a control flow construct that allows you to compare a value against a series of patterns and execute code based on the first pattern that matches. It's similar to a switch-case statement but more expressive.

Here's the basic syntax:

match value {
    pattern1 => expression1,
    pattern2 => expression2,
    // ...
    _ => default_expression, // Optional catch-all case
}

- **value**: The value to be matched.
- **pattern**: A pattern that describes a set of values.
- **expression**: Code to execute if the pattern matches.
- **_**: A wildcard pattern that matches any value.

### If Let Statement

The `if let` statement is a shorthand for matching against a single pattern. It's useful when you want to extract data from an enum or other complex type without writing a full `match` statement.

Here's the basic syntax:

```rust
if let Some(x) = some_option {
    // Code to execute if the pattern matches
} else {
    // Optional code to execute if the pattern doesn't match
}

- **Some(x)**: A pattern that matches values of type `Option<T>` when they are `Some(value)`.
- **x**: The variable bound to the matched value.
- **else**: Optional block of code to execute if the pattern doesn't match.

## Examples

### Basic Match Statement

Let's start with a simple example using integers:

```rust
fn main() {
    let number = 5;

    match number {
        1 => println!("One"),
        2 => println!("Two"),
        3 => println!("Three"),
        _ => println!("Other"), // Catch-all case
    }
}

In this example, the `match` statement compares the value of `number` against several patterns. If `number` is 1, it prints "One". If it's 2, it prints "Two", and so on. The `_` pattern matches any other value.

### Matching Ranges

You can also match ranges using the `..=` syntax:

```rust
fn main() {
    let number = 6;

    match number {
        1..=3 => println!("One to Three"),
        4..=6 => println!("Four to Six"),
        _ => println!("Other"),
    }
}

In this example, the match statement checks if number falls within a specific range. If it does, it prints the corresponding message.

Matching Enums

Enums are a common use case for pattern matching in Rust. Let's define an enum and match against its variants:

enum Direction {
    North,
    South,
    East,
    West,
}

fn main() {
    let direction = Direction::East;

    match direction {
        Direction::North => println!("Going north"),
        Direction::South => println!("Going south"),
        Direction::East => println!("Going east"),
        Direction::West => println!("Going west"),
    }
}

In this example, the match statement matches against each variant of the Direction enum and prints a corresponding message.

Using If Let

Now let's look at an example using if let to match against an Option<T>:

fn main() {
    let some_option = Some(5);

    if let Some(x) = some_option {
        println!("The value is {}", x);
    } else {
        println!("No value");
    }
}

In this example, the if let statement checks if some_option is Some(value). If it is, it binds the value to x and prints it. If not, it executes the else block.

Destructuring Structs

You can also use pattern matching to destructure structs:

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let point = Point { x: 10, y: 20 };

    match point {
        Point { x, y } => println!("Point at ({}, {})", x, y),
    }
}

In this example, the match statement deconstructs the point struct and binds its fields to variables x and y.

What's Next?

Now that you've learned about pattern matching in Rust using match and if let statements, you're ready to explore more advanced topics. In the next section, we'll dive into Macros, which allow you to write code that writes other code. Macros are a powerful feature of Rust that can help you automate repetitive tasks and make your code more concise.

Stay tuned for more tutorials on codingstuff.io!