Rust does not have a traditional switch statement like other programming languages (e.g., C, Java). Instead, Rust provides the match expression, which is a more powerful and flexible construct for branching logic. It is one of Rust's core features and is commonly used for pattern matching.

---

Key Features of match in Rust

1. Pattern Matching: Matches values against patterns (e.g., literals, ranges, enums, etc.).
2. Exhaustiveness: Requires all possible cases to be handled, ensuring safety.
3. Expression-Based: match can return values, making it more versatile than a typical switch.
4. Versatility: Supports more than just integer-based matching; it works with strings, ranges, enums, and more.

---

Basic Syntax of match

fn main() {
    let number = 3;

    match number {
        1 => println!("One"),
        2 => println!("Two"),
        3 => println!("Three"),
        _ => println!("Something else"), // Default case
    }
}

Explanation:

1. The value of number is compared against each pattern (1, 2, 3).
2. The _ is a wildcard pattern and acts as a default case, matching anything not explicitly handled.

---

Matching Ranges

Rust allows range-based matching with patterns:

fn main() {
    let age = 20;

    match age {
        0..=12 => println!("Child"),
        13..=19 => println!("Teenager"),
        20..=59 => println!("Adult"),
        _ => println!("Senior"),
    }
}

Explanation:

• 0..=12 matches any value from 0 to 12 (inclusive).
• ..= denotes an inclusive range.

---

Returning Values with match

Since match is an expression, it can return a value:

fn main() {
    let number = 2;

    let result = match number {
        1 => "One",
        2 => "Two",
        3 => "Three",
        _ => "Unknown",
    };

    println!("The result is: {}", result);
}

---

Matching Multiple Patterns

You can match multiple patterns using the | operator:

fn main() {
    let day = "Saturday";

    match day {
        "Saturday" | "Sunday" => println!("Weekend"),
        "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" => println!("Weekday"),
        _ => println!("Invalid day"),
    }
}

---

Destructuring with match

Rust's match can destructure complex types like tuples, structs, and enums.

Example: Tuples

fn main() {
    let point = (0, 5);

    match point {
        (0, y) => println!("Point is on the Y-axis at {}", y),
        (x, 0) => println!("Point is on the X-axis at {}", x),
        (x, y) => println!("Point is at ({}, {})", x, y),
    }
}

---

Example: Enums

Enums work seamlessly with match:

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

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

    match direction {
        Direction::North => println!("Heading North"),
        Direction::South => println!("Heading South"),
        Direction::East => println!("Heading East"),
        Direction::West => println!("Heading West"),
    }
}

---

match with Guards

You can add extra conditions using match guards:

fn main() {
    let number = 42;

    match number {
        n if n % 2 == 0 => println!("Even number"),
        _ => println!("Odd number"),
    }
}

---

Summary: Comparison of match and Traditional switch

Feature	match in Rust	switch in Other Languages
Exhaustiveness	Enforced by the compiler	Not required (default optional)
Pattern Matching	Supports advanced patterns	Typically matches constants
Return Values	Expression-based	Statement-based
Versatility	Works with enums, ranges, and destructuring	Limited to simple cases

---

Rust’s match is more powerful and expressive than a traditional switch, making it a key tool for handling branching logic safely and efficiently.