🦀 Rust – Match (Switch Equivalent): Pattern Matching with Power and Precision

🧲 Introduction – Why Learn match in Rust?

Rust doesn’t have a traditional switch statement like C or JavaScript. Instead, it provides match—a powerful, exhaustive, and expressive pattern matching construct. It’s not just a switch; it’s an essential feature for control flow, enum handling, and data destructuring.

🎯 In this guide, you’ll learn:

• How match works as a switch alternative
• Pattern matching with values, ranges, and enums
• Match expressions with return values
• Real output and line-by-line explanations

✅ Basic match Syntax

🔹 Code Example:

fn main() {
    let grade = 'A';

    match grade {
        'A' => println!("Excellent"),
        'B' => println!("Good"),
        'C' => println!("Average"),
        _   => println!("Needs Improvement"),
    }
}

🧠 Explanation:

• match grade checks the value of grade
• Each 'X' => arm matches a character and runs the corresponding block
• _ is the wildcard pattern (default case)

📤 Output:

Excellent

🔁 Match as an Expression (Value Returning)

🔹 Code Example:

fn main() {
    let code = 200;

    let status = match code {
        200 => "OK",
        404 => "Not Found",
        500 => "Server Error",
        _   => "Unknown",
    };

    println!("Status: {}", status);
}

🧠 Explanation:

• match returns a value (&str here)
• The status variable is assigned based on the pattern
• All branches must return the same type

📤 Output:

Status: OK

🔎 Match with Ranges

🔹 Code Example:

fn main() {
    let score = 78;

    let grade = match score {
        90..=100 => "A",
        80..=89  => "B",
        70..=79  => "C",
        60..=69  => "D",
        _        => "F",
    };

    println!("Grade: {}", grade);
}

🧠 Explanation:

• Rust supports 90..=100 to match inclusive ranges
• Each range is checked top-down
• score = 78 matches 70..=79, returning "C"

📤 Output:

Grade: C

🎭 Match with Multiple Patterns

🔹 Code Example:

fn main() {
    let day = 7;

    match day {
        1 | 7 => println!("Weekend"),
        2..=6 => println!("Weekday"),
        _     => println!("Invalid"),
    }
}

🧠 Explanation:

• 1 | 7 means either 1 or 7
• 2..=6 matches any weekday number
• _ handles invalid cases

📤 Output:

Weekend

🧩 Match with Enums

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

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

    match dir {
        Direction::North => println!("Up"),
        Direction::South => println!("Down"),
        Direction::East  => println!("Right"),
        Direction::West  => println!("Left"),
    }
}

🧠 Explanation:

• Direction is a custom enum
• match exhaustively checks each variant
• All variants are explicitly handled

📤 Output:

Right

⚠️ Common match Mistakes

📌 Summary – Recap & Next Steps

Rust’s match goes far beyond a basic switch. It supports pattern matching, expressions, ranges, enums, and destructuring, making it one of the most versatile tools in the language.

🔍 Key Takeaways:

• match is exhaustive and safe
• Can return values like if expressions
• Use ranges, multiple patterns, and wildcards effectively
• Essential for working with enums and control flow

⚙️ Up next: Learn about Rust – Decision Making, where you’ll combine if, match, and logical expressions.

❓FAQs

❓ Is match the same as switch in C/C++?
✅ Not exactly. match is more powerful—supports ranges, multiple patterns, and destructuring.

❓ Does Rust require all match arms to be handled?
✅ Yes. Rust enforces exhaustiveness. You must handle all possible cases or use _ as a catch-all.

❓ Can I return values from a match?
✅ Absolutely. match is an expression—just like if. All arms must return the same type.

❓ Can I use match with enums and custom types?
✅ Yes! match is perfect for enums. It’s also used for handling Option, Result, and custom patterns.