Match expression deep dive in Rust - Step-by-Step Execution

Concept Flow - Match expression deep dive

Start with a value

↓

Match expression begins

↓

Check first pattern

No→Check next pattern

↓

Execute matched arm

↓

Return arm result

↓

End match expression

The match expression checks a value against patterns one by one, executes the first matching arm, then returns its result.

Execution Sample

Rust

let x = 3;
let result = match x {
    1 => "one",
    2 | 3 => "two or three",
    _ => "other",
};

This code matches the value of x to patterns and assigns a string describing it to result.

Execution Table

Step	Value of x	Pattern Checked	Match?	Action	Result
1	3	1	No	Check next pattern	None
2	3	2 | 3	Yes	Execute arm: return "two or three"	"two or three"
3	3	_ (wildcard)	Skipped	Match already found	"two or three"

💡 Match found at step 2 with pattern '2 | 3', so match expression ends returning "two or three".

Variable Tracker

Variable	Start	After match
x	3	3
result	uninitialized	"two or three"

Key Moments - 3 Insights

Why does the match stop checking after the second pattern even though there is a wildcard pattern after?

Because match expressions stop at the first pattern that matches. In the execution_table row 2, pattern '2 | 3' matches x=3, so the wildcard pattern is skipped (row 3).

What does the underscore (_) pattern mean in a match?

The underscore is a wildcard that matches any value not matched before. It acts like a default case, as shown in execution_table row 3.

Can multiple patterns be combined in one arm?

Yes, using the | operator. In the example, '2 | 3' matches if x is 2 or 3, as seen in execution_table row 2.

Visual Quiz - 3 Questions

Look at the execution_table, what is the result after step 2?

A "one"

B "two or three"

C "other"

D None

💡 Hint

Check the 'Result' column at step 2 in the execution_table.

At which step does the match expression stop checking patterns?

A Step 1

B Step 3

C Step 2

D It checks all patterns

💡 Hint

Look at the 'Match?' column and see where 'Yes' appears first in execution_table.

If x was 4 instead of 3, which pattern would match?

A _ (wildcard)

B 2 | 3

C 1

D No pattern matches

💡 Hint

Refer to the wildcard pattern '_' in the execution_table and key_moments about default matching.

Concept Snapshot

match value {
  pattern1 => expr1,
  pattern2 | pattern3 => expr2,
  _ => default_expr,
}
- Checks patterns top to bottom
- Executes first matching arm
- '_' matches anything else
- Arms can combine patterns with '|'
- Returns the arm's expression value

Full Transcript

This visual execution traces a Rust match expression. We start with a value x=3. The match checks patterns in order: first '1' (no match), then '2 | 3' (matches), so it executes that arm returning "two or three". The wildcard '_' pattern is skipped because a match was found. Variables x and result are tracked: x stays 3, result becomes "two or three". Key points: match stops at first match, '_' is a catch-all, and multiple patterns can be combined with '|'. The quiz tests understanding of these steps and outcomes.

Practice

1. What does the match expression do in Rust?

easy

A. It loops over a range of numbers.

B. It creates a new variable with a fixed value.

C. It defines a function with multiple parameters.

D. It compares a value against multiple patterns and executes matching code.

Solution

1. Step 1: Understand the purpose of match

   The match expression is used to compare a value against several patterns.

2. Step 2: Identify what happens on a match

   When a pattern matches, the corresponding code block runs, making match a clear way to handle multiple cases.

3. Final Answer:

   It compares a value against multiple patterns and executes matching code. -> Option D

4. Quick Check:

   Match expression = pattern matching [OK]

Hint: Match compares values to patterns and runs matching code [OK]

Common Mistakes:

• Thinking match creates variables
• Confusing match with loops
• Assuming match defines functions

2. Which of the following is the correct syntax for a simple match expression in Rust?

easy

A. match value { 1 => println!("One") else println!("Other") }

B. match value { 1 => println!("One"), _ => println!("Other") }

C. match value { 1 -> println!("One"), _ -> println!("Other") }

D. match (value) { 1: println!("One"), _ : println!("Other") }

Solution

1. Step 1: Recall Rust match syntax

   Rust uses curly braces with patterns followed by => and the code to run.

2. Step 2: Check each option

   match value { 1 => println!("One"), _ => println!("Other") } uses correct syntax with => and a default case using _; others use invalid symbols like : or -> or else.

3. Final Answer:

   match value { 1 => println!("One"), _ => println!("Other") } -> Option B

4. Quick Check:

   Correct match syntax uses => and _ for default [OK]

Hint: Use => for patterns and _ for default case in match [OK]

Common Mistakes:

• Using : or -> instead of =>
• Omitting commas between arms
• Using else instead of _ for default

3. What is the output of this Rust code?

let x = Some(5);
match x {
  Some(n) if n > 3 => println!("Greater than 3: {}", n),
  Some(n) => println!("Less or equal to 3: {}", n),
  None => println!("No value"),
}

medium

A. Greater than 3: 5

B. Less or equal to 3: 5

C. No value

D. Compilation error

Solution

1. Step 1: Analyze the match arms and value

   The value is Some(5). The first arm matches Some(n) with a guard n > 3.

2. Step 2: Check the guard condition

   Since 5 > 3 is true, the first arm runs and prints "Greater than 3: 5".

3. Final Answer:

   Greater than 3: 5 -> Option A

4. Quick Check:

   Guard true triggers first arm output [OK]

Hint: Check if guards are true to pick correct match arm [OK]

Common Mistakes:

• Ignoring the if guard condition
• Choosing second arm without checking guard
• Thinking None matches Some value

4. Identify the error in this Rust match expression:

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

medium

A. Match arms must be in parentheses, not braces.

B. Using _ as default case is invalid.

C. Missing comma after the second arm (2 => ...).

D. Cannot match integer values directly.

Solution

1. Step 1: Check syntax of each match arm

   Each arm must end with a comma except possibly the last. The second arm lacks a comma after println!("Two").

2. Step 2: Validate other parts

   Using _ is valid for default, braces are correct, and matching integers is allowed.

3. Final Answer:

   Missing comma after the second arm (2 => ...). -> Option C

4. Quick Check:

   Commas separate match arms [OK]

Hint: Check commas after each match arm carefully [OK]

Common Mistakes:

• Forgetting commas between arms
• Misunderstanding _ as invalid
• Confusing braces with parentheses

5. Given a list of Option<i32> values, how can you use a match expression inside a loop to print only the positive numbers, ignoring None and non-positive values? Choose the correct code snippet.

hard

A. for val in list {
match val {
Some(n) if n > 0 => println!("Positive: {}", n),
_ => (),
}
}

B. for val in list {
match val {
Some(n) => println!("Positive: {}", n),
None => println!("No value"),
}
}

C. for val in list {
if let Some(n) = val {
if n > 0 {
println!("Positive: {}", n);
}
}
}

D. for val in list {
match val {
Some(n) if n <= 0 => println!("Positive: {}", n),
_ => (),
}
}

Solution

1. Step 1: Understand the requirement

   We want to print only positive numbers inside Some, ignoring None and non-positive.

2. Step 2: Analyze each option

   for val in list { match val { Some(n) if n > 0 => println!("Positive: {}", n), _ => (), } } matches Some(n) with guard n > 0 and prints; others ignore with _ => (). for val in list { match val { Some(n) => println!("Positive: {}", n), None => println!("No value"), } } prints all Some values regardless of positivity. for val in list { if let Some(n) = val { if n > 0 { println!("Positive: {}", n); } } } uses if let but is not a match expression. for val in list { match val { Some(n) if n <= 0 => println!("Positive: {}", n), _ => (), } } prints non-positive numbers, opposite of requirement.

3. Final Answer:

   for val in list { match val { Some(n) if n > 0 => println!("Positive: {}", n), _ => (), } } -> Option A

4. Quick Check:

   Match with guard filters positive Some values [OK]

Hint: Use if guards in match to filter values [OK]

Common Mistakes:

• Printing all Some values without checking positivity
• Using if let instead of match when asked
• Reversing guard condition