Matching multiple patterns in Rust - Step-by-Step Execution

Concept Flow - Matching multiple patterns

Start match expression

↓

Check first pattern

Yes↓

Execute first arm

↓

End

↓

Check second pattern

Yes↓

Execute second arm

↓

End

↓

Check next patterns...

↓

Default arm or error

The program checks each pattern in order. If the value matches any pattern in an arm, it runs that arm and stops matching.

Execution Sample

Rust

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

This code matches x against multiple patterns in one arm using | to combine them.

Execution Table

Step	Value of x	Pattern Checked	Match Result	Action Taken	Output
1	2	1 | 2	Match	Execute arm	One or Two
2	2	3	Not checked	No action
3	2	_	Not checked	No action

💡 Match found at first pattern (1 | 2), so matching stops.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
x	2	2	2	2

Key Moments - 2 Insights

Why does the program not check the second pattern when the first matches?

Because Rust stops matching once it finds a matching pattern, as shown in execution_table step 1 where the first pattern matches and later patterns are not checked.

How do we match multiple values in one arm?

By using the | symbol between patterns, like 1 | 2, which means match if value is 1 or 2, as seen in execution_table step 1.

Visual Quiz - 3 Questions

Look at the execution table, what is the output at step 1?

A "One or Two"

B "Three"

C "Other"

D No output

💡 Hint

Check the 'Output' column in execution_table row 1.

At which step does the program stop checking patterns?

A Step 3

B Step 2

C Step 1

D It checks all steps

💡 Hint

See 'Match Result' and 'Action Taken' in execution_table; matching stops at first match.

If x was 3, which pattern would match according to the table?

A 1 | 2

B 3

C _

D No pattern matches

💡 Hint

Look at the patterns and think which matches value 3.

Concept Snapshot

match value {
  pattern1 | pattern2 => action,
  pattern3 => action,
  _ => default_action,
}
- Use | to match multiple patterns in one arm.
- Matching stops at first successful pattern.
- _ matches anything else.

Full Transcript

This example shows how Rust matches a value against multiple patterns using the | symbol. The program checks each pattern in order. If the value matches any pattern in an arm, it runs that arm and stops matching further. For example, when x is 2, it matches the first arm with patterns 1 or 2, prints "One or Two", and stops. This prevents checking other patterns unnecessarily. Using | lets you combine multiple values in one match arm for cleaner code.

Practice

1. In Rust, which symbol is used to match multiple patterns in a single match arm?

easy

A. |

B. &

C. +

D. &&

Solution

1. Step 1: Recall the syntax for matching multiple patterns

   Rust uses the vertical bar | to separate multiple patterns in one match arm.

2. Step 2: Identify the correct symbol

   The symbol | means "or" in pattern matching, allowing multiple cases to be handled together.

3. Final Answer:

   | -> Option A

4. Quick Check:

   Multiple patterns use | in match arms [OK]

Hint: Use | to combine patterns in one match arm [OK]

Common Mistakes:

• Using & instead of |
• Confusing + with pattern separator
• Using && which is logical AND, not pattern OR

2. Which of the following Rust match arms correctly matches the values 1, 2, or 3 using multiple patterns?

easy

A. 1 & 2 & 3 => println!("Matched 1, 2, or 3"),

B. 1 | 2 | 3 => println!("Matched 1, 2, or 3"),

C. 1 + 2 + 3 => println!("Matched 1, 2, or 3"),

D. 1, 2, 3 => println!("Matched 1, 2, or 3"),

Solution

1. Step 1: Check the syntax for multiple patterns

   Rust uses | to separate multiple patterns in a match arm, so 1 | 2 | 3 is correct.

2. Step 2: Identify incorrect options

   & is not used for matching multiple patterns, + is arithmetic, and commas are invalid here.

3. Final Answer:

   1 | 2 | 3 => println!("Matched 1, 2, or 3"), -> Option B

4. Quick Check:

   Multiple patterns use | separator [OK]

Hint: Separate patterns with | inside match arms [OK]

Common Mistakes:

• Using & instead of | for multiple patterns
• Trying to separate patterns with commas
• Using + which is arithmetic, not pattern matching

3. What will be the output of this Rust code?

let x = 2;
match x {
    1 | 2 | 3 => println!("Small number"),
    4 | 5 | 6 => println!("Medium number"),
    _ => println!("Other number"),
}

medium

A. Compilation error

B. Medium number

C. Small number

D. Other number

Solution

1. Step 1: Identify which pattern matches x=2

   The first arm matches 1, 2, or 3. Since x is 2, it matches this arm.

2. Step 2: Determine the output

   The matched arm prints "Small number" to the console.

3. Final Answer:

   Small number -> Option C

4. Quick Check:

   2 matches 1|2|3 arm [OK]

Hint: Check which pattern includes the value [OK]

Common Mistakes:

• Choosing Medium number for 2
• Thinking _ arm matches first
• Assuming syntax error due to multiple patterns

4. Find the error in this Rust code snippet that tries to match multiple patterns:

let ch = 'a';
match ch {
    'a' | 'e' | 'i' | 'o' | 'u' => println!("Vowel"),
    'a' | 'b' => println!("Letter a or b"),
    _ => println!("Other"),
}

medium

A. Missing semicolon after println! macros

B. Match expression missing a default arm

C. Incorrect use of | operator for multiple patterns

D. Duplicate pattern 'a' in multiple arms causes unreachable code

Solution

1. Step 1: Identify duplicate patterns in match arms

   The character 'a' appears in both the first and second arms, causing the second arm's 'a' pattern to be unreachable.

2. Step 2: Understand Rust's pattern matching rules

   Rust does not allow unreachable patterns; the compiler will warn or error about the duplicate 'a'.

3. Final Answer:

   Duplicate pattern 'a' in multiple arms causes unreachable code -> Option D

4. Quick Check:

   Duplicate patterns cause unreachable code errors [OK]

Hint: Avoid repeating same pattern in multiple match arms [OK]

Common Mistakes:

• Ignoring unreachable pattern warnings
• Thinking | is invalid for multiple patterns
• Missing default arm (actually present here)

5. You want to write a Rust function that returns "Weekend" for Saturday or Sunday, "Weekday" for Monday to Friday, and "Invalid" otherwise. Which match arm correctly uses multiple patterns to do this?

fn day_type(day: &str) -> &str {
    match day {
        ? => "Weekend",
        ? => "Weekday",
        _ => "Invalid",
    }
}

hard

A. "Saturday" | "Sunday",
"Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday"

B. "Saturday", "Sunday",
"Monday", "Tuesday", "Wednesday", "Thursday", "Friday"

C. "Saturday" & "Sunday",
"Monday" & "Tuesday" & "Wednesday" & "Thursday" & "Friday"

D. "Saturday" + "Sunday",
"Monday" + "Tuesday" + "Wednesday" + "Thursday" + "Friday"

Solution

1. Step 1: Use | to match multiple string patterns in one arm

   Rust allows multiple patterns separated by | to group cases like "Saturday" | "Sunday".

2. Step 2: Check other options for invalid syntax

   Commas separate arms, not patterns; & and + are invalid for pattern matching.

3. Final Answer:

   "Saturday" | "Sunday", "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" -> Option A

4. Quick Check:

   Use | to combine multiple string patterns [OK]

Hint: Use | to combine multiple string patterns in match arms [OK]

Common Mistakes:

• Using commas instead of | inside match arms
• Using & or + which are invalid for patterns
• Forgetting to cover all weekdays or weekend days