Does Rust require match expressions to be exhaustive?

Yes. Rust requires match expressions to be exhaustive, meaning all possible cases must be handled. You can use the underscore (_) wildcard to cover remaining cases.

Can match return a value in Rust?

Yes. In Rust, match is an expression and can return a value. All match arms must return values of the same type.

What is the underscore (_) in a Rust match statement?

The underscore (_) is a wildcard pattern in Rust that matches any value not previously matched. It acts as a default case.

When should I use match instead of if in Rust?

Use match when handling multiple specific values, working with enums, or performing pattern matching. Use if when evaluating Boolean expressions or complex logical conditions.

Can match be used with enums in Rust?

Yes. Match is commonly used with enums in Rust. It ensures all enum variants are handled, improving safety and preventing missing cases.

What are match guards in Rust?

Match guards are additional conditions added to match arms using the if keyword. They allow you to add extra logical checks to pattern matching.

Rust match Expression

Q: What is the match expression in Rust?

The match expression in Rust is a control flow construct that compares a value against multiple patterns and executes code based on which pattern matches. It is similar to a switch statement but more powerful and safer.

Rust `match` Expression – Complete Beginner Guide

The match expression is one of the most powerful and unique features of Rust.

It allows you to:

Compare values
Handle multiple conditions cleanly
Work with enums
Destructure data
Write safer, more readable code
Avoid complex if..else chains

If you want to write professional Rust code, mastering match is essential.

In this complete beginner guide, you’ll learn:

What the match expression is
Basic syntax
Matching values
Multiple patterns
Matching ranges
Using match with enums
Destructuring
Match guards
_ wildcard pattern
match vs if..else
Common mistakes
Best practices
Real-world examples

Let’s dive in

What is the `match` Expression in Rust?

The match expression allows you to compare a value against multiple patterns and execute code based on which pattern matches.

Think of it as a more powerful and safer version of switch in other languages.

Basic idea:

match value {
pattern1 => result1,
pattern2 => result2,
_ => default_result,
}

match value {

pattern1 => result1,

pattern2 => result2,

_ => default_result,

}

Basic `match` Syntax

Example:

fn main() {
let number = 2;

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

fn main() {

let number = 2;

match number {

1 => println!("One"),

2 => println!("Two"),

3 => println!("Three"),

_ => println!("Other number"),

}

Explanation:

Rust checks each pattern in order.
When it finds a match, it executes that arm.
_ is the default case (wildcard).

Important Rule: `match` Must Be Exhaustive

Rust requires you to handle all possible cases.

For example:

match number {
1 => println!("One"),
}

match number {

1 => println!("One"),

}

This is invalid.

Why?

Because Rust cannot guarantee that number will always be 1.

You must include _ or handle every possible value.

Using `_` (Wildcard Pattern)

The underscore _ matches anything.

Example:

match number {
1 => println!("One"),
_ => println!("Not one"),
}

match number {

1 => println!("One"),

_ => println!("Not one"),

}

It acts like the default case.

`match` as an Expression (Very Powerful)

Just like if, match is an expression and can return values.

Example:

fn main() {
let number = 3;

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

println!("{}", result);
}

fn main() {

let number = 3;

let result = match number {

1 => "One",

2 => "Two",

3 => "Three",

_ => "Other",

};

println!("{}", result);

}

Important rule:

All arms must return the same type.

Matching Multiple Values

You can match multiple patterns using |.

Example:

match number {
1 | 2 => println!("One or Two"),
3 => println!("Three"),
_ => println!("Other"),
}

match number {

1 | 2 => println!("One or Two"),

3 => println!("Three"),

_ => println!("Other"),

}

1 | 2 means either 1 or 2.

Matching Ranges

Rust allows matching ranges using ..=.

Example:

match score {
90..=100 => println!("Grade A"),
75..=89 => println!("Grade B"),
50..=74 => println!("Grade C"),
_ => println!("Fail"),
}

match score {

90..=100 => println!("Grade A"),

75..=89 => println!("Grade B"),

50..=74 => println!("Grade C"),

_ => println!("Fail"),

}

This makes grading logic clean and readable.

Using `match` with Enums (Most Common Use Case)

Enums are where match truly shines.

Example:

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

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

match move_direction {
Direction::North => println!("Going up"),
Direction::South => println!("Going down"),
Direction::East => println!("Going right"),
Direction::West => println!("Going left"),
}
}

enum Direction {

North,

South,

East,

West,

}

fn main() {

let move_direction = Direction::North;

match move_direction {

Direction::North => println!("Going up"),

Direction::South => println!("Going down"),

Direction::East => println!("Going right"),

Direction::West => println!("Going left"),

}

Notice:

No _ is required because all enum variants are covered.

Rust ensures safety at compile time.

Destructuring in `match`

match can extract values from data structures.

Example with tuple:

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

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

fn main() {

let point = (0, 5);

match point {

(0, y) => println!("On Y-axis at {}", y),

(x, 0) => println!("On X-axis at {}", x),

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

}

This is called pattern matching.

Match Guards (Advanced but Useful)

You can add conditions using if.

Example:

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

match number {

x if x % 2 == 0 => println!("Even"),

_ => println!("Odd"),

}

This is called a match guard.

`match` vs `if..else`

Use if..else when:

Checking Boolean conditions
Combining complex logical expressions

Use match when:

Matching specific values
Working with enums
Handling multiple patterns
Destructuring data

Example:

Long if-else chain:

if number == 1 {
}
else if number == 2 {
}
else if number == 3 {
}

if number == 1 {

}

else if number == 2 {

}

else if number == 3 {

}

Cleaner match:

match number {
1 => {},
2 => {},
3 => {},
_ => {},
}

match number {

1 => {},

2 => {},

3 => {},

_ => {},

}

Real-World Example: User Role System

enum Role {
Admin,
Moderator,
User,
Guest,
}

fn main() {
let current_role = Role::Admin;

match current_role {
Role::Admin => println!("Full access"),
Role::Moderator => println!("Limited management access"),
Role::User => println!("Standard access"),
Role::Guest => println!("Read-only access"),
}
}

enum Role {

Admin,

Moderator,

User,

Guest,

}

fn main() {

let current_role = Role::Admin;

match current_role {

Role::Admin => println!("Full access"),

Role::Moderator => println!("Limited management access"),

Role::User => println!("Standard access"),

Role::Guest => println!("Read-only access"),

}

This is how real applications handle permissions.

Match with Option (Very Common)

Example:

fn main() {
let value = Some(10);

match value {
Some(number) => println!("Value is {}", number),
None => println!("No value"),
}
}

fn main() {

let value = Some(10);

match value {

Some(number) => println!("Value is {}", number),

None => println!("No value"),

}

This avoids null pointer errors.

Rust forces you to handle None.

Common Beginner Mistakes

Forgetting _ wildcard
Returning different types in arms
Overusing match when if is better
Writing overly complex match arms
Forgetting commas between arms

Best Practices for Using `match`

Keep match arms simple
Use _ only when necessary
Prefer match for enums
Avoid deep nesting
Use descriptive variable names
Keep formatting clean

Practical Example: Traffic Light System

enum TrafficLight {
Red,
Yellow,
Green,
}

fn main() {
let signal = TrafficLight::Green;

let action = match signal {
TrafficLight::Red => "Stop",
TrafficLight::Yellow => "Slow down",
TrafficLight::Green => "Go",
};

println!("{}", action);
}

enum TrafficLight {

Red,

Yellow,

Green,

}

fn main() {

let signal = TrafficLight::Green;

let action = match signal {

TrafficLight::Red => "Stop",

TrafficLight::Yellow => "Slow down",

TrafficLight::Green => "Go",

};

println!("{}", action);

}

Clean, readable, and safe.

Why `match` Makes Rust Powerful

Ensures exhaustiveness
Prevents missing cases
Improves readability
Works perfectly with enums
Supports destructuring
Eliminates many runtime bugs

This is one of Rust’s most loved features.

Frequently Asked Questions (FAQs)

1. What is the match expression in Rust?

The match expression is a control flow structure that compares a value against multiple patterns and executes code based on the matched pattern.

2. Does match need to handle all cases?

Yes. Rust requires match expressions to be exhaustive.

3. Can match return a value?

Yes. Match is an expression and can return a value.

4. What is the underscore (_) in match?

It is a wildcard pattern that matches any remaining cases.

5. When should I use match instead of if?

Use match when handling multiple specific values, enums, or pattern matching.

Final Thoughts

Rust’s match expression is:

Safe
Expressive
Exhaustive
Powerful
Beginner-friendly once understood

It is one of the biggest reasons Rust is loved by developers.

Mastering match will significantly improve your Rust programming skills.

Rust match Expression

Rust `match` Expression – Complete Beginner Guide

What is the `match` Expression in Rust?

Basic `match` Syntax

Important Rule: `match` Must Be Exhaustive

Using `_` (Wildcard Pattern)

`match` as an Expression (Very Powerful)

Matching Multiple Values

Matching Ranges

Using `match` with Enums (Most Common Use Case)

Destructuring in `match`

Match Guards (Advanced but Useful)

`match` vs `if..else`

Real-World Example: User Role System

Match with Option (Very Common)

Common Beginner Mistakes

Best Practices for Using `match`

Practical Example: Traffic Light System

Why `match` Makes Rust Powerful

Frequently Asked Questions (FAQs)

1. What is the match expression in Rust?

2. Does match need to handle all cases?

3. Can match return a value?

4. What is the underscore (_) in match?

5. When should I use match instead of if?

Final Thoughts

You may also like...

Rust Tutorial

Rust Data Structures

Rust match Expression

Rust match Expression – Complete Beginner Guide

What is the match Expression in Rust?

Basic match Syntax

Important Rule: match Must Be Exhaustive

Using _ (Wildcard Pattern)

match as an Expression (Very Powerful)

Matching Multiple Values

Matching Ranges

Using match with Enums (Most Common Use Case)

Destructuring in match

Match Guards (Advanced but Useful)

match vs if..else

Real-World Example: User Role System

Match with Option (Very Common)

Common Beginner Mistakes

Best Practices for Using match

Practical Example: Traffic Light System

Why match Makes Rust Powerful

Frequently Asked Questions (FAQs)

1. What is the match expression in Rust?

2. Does match need to handle all cases?

3. Can match return a value?

4. What is the underscore (_) in match?

5. When should I use match instead of if?

Final Thoughts

You may also like...

Rust Variables

Rust while Loops

Rust Strings

Rust Tutorial

Rust Data Structures

Rust `match` Expression – Complete Beginner Guide

What is the `match` Expression in Rust?

Basic `match` Syntax

Important Rule: `match` Must Be Exhaustive

Using `_` (Wildcard Pattern)

`match` as an Expression (Very Powerful)

Using `match` with Enums (Most Common Use Case)

Destructuring in `match`

`match` vs `if..else`

Best Practices for Using `match`

Why `match` Makes Rust Powerful