Match guards in Rust - Step-by-Step Execution

Concept Flow - Match guards

Start with value

↓

Match arm 1?

No→Match arm 2?

↓

Execute arm code

↓

End

The program checks each match arm in order. If the pattern matches and the guard condition is true, it runs that arm's code. Otherwise, it moves to the next arm.

Execution Sample

Rust

let x = 5;
match x {
  n if n < 3 => "small",
  n if n < 7 => "medium",
  _ => "large",
}

Match the value x with conditions using guards to decide if it's small, medium, or large.

Execution Table

Step	Match Arm Pattern	Guard Condition	Guard Result	Action Taken	Output
1	n if n < 3	5 < 3	false	Skip arm
2	n if n < 7	5 < 7	true	Execute arm	"medium"
3	_	N/A	N/A	Not reached

💡 Match arm 2 guard is true, so execution stops after returning "medium".

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
x	5	5	5	5
n	N/A	5	5	5

Key Moments - 2 Insights

Why does the first match arm get skipped even though the pattern matches?

Because the guard condition (5 < 3) is false, the arm is skipped as shown in execution_table step 1.

What happens if no guard condition is true?

The default arm (_) runs, as a fallback. Here, it is not reached because step 2's guard is true.

Visual Quiz - 3 Questions

Look at the execution table, what is the guard result at step 1?

A false

B true

C N/A

D error

💡 Hint

Check the 'Guard Result' column in execution_table row 1.

At which step does the match stop and return a value?

A Step 3

B Step 1

C Step 2

D Never stops

💡 Hint

Look at the 'Action Taken' and 'Output' columns in execution_table.

If x was 2, which arm would execute?

A Arm 3 (_)

B Arm 1 (n if n < 3)

C Arm 2 (n if n < 7)

D No arm executes

💡 Hint

Check the guard conditions and their results for x=2 in the variable_tracker and execution_table logic.

Concept Snapshot

Match guards add extra conditions to match arms.
Syntax: pattern if condition => expression
The arm runs only if pattern matches AND condition is true.
If guard is false, matching continues to next arm.
Useful for fine control in pattern matching.

Full Transcript

This example shows how Rust's match guards work. The value x is matched against patterns with extra conditions called guards. Each arm has a pattern and a guard condition. The program checks each arm in order. If the pattern matches and the guard condition is true, it executes that arm's code and stops. Otherwise, it moves to the next arm. In the example, x=5 does not satisfy the first guard (5 < 3 is false), so it skips that arm. The second arm's guard (5 < 7) is true, so it runs that arm and returns "medium". The default arm is not reached. Variables x and n keep their values throughout. This helps control matching with extra checks beyond just the pattern.