Matching multiple patterns in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does matching multiple patterns with the | operator in Rust mean?

It means you can check if a value matches any one of several patterns in a single match arm, using the | symbol to separate patterns.

beginner

How do you write a match arm that matches the values 1, 2, or 3 in Rust?

You write:

1 | 2 | 3 => { /* code here */ }

This means if the value is 1, 2, or 3, the code runs.

intermediate

Can you bind variables when matching multiple patterns with | in Rust?

No, you cannot bind variables directly in multiple patterns combined with |. Each pattern must be independent without variable bindings.

intermediate

What happens if you try to use variable bindings in multiple patterns combined with | in Rust?

Rust will give a compile error because it cannot decide which pattern's variable to bind. You must separate those cases into different arms.

beginner

Why is matching multiple patterns useful in Rust?

It lets you write cleaner and shorter code by grouping cases that should do the same thing, avoiding repetition.

Which symbol is used to match multiple patterns in one match arm in Rust?

A |

B &

C &&

D ||

The | symbol is used to separate multiple patterns in a single match arm.

What will this Rust code print?

let x = 2;
match x {
  1 | 2 | 3 => println!("Matched 1, 2, or 3"),
  _ => println!("No match"),
}

A Nothing

B No match

C Compile error

D Matched 1, 2, or 3

Since x is 2, it matches the pattern 1 | 2 | 3 and prints the first message.

Can you write this in one match arm?

Some(x) => println!("Got {}", x),
None => println!("No value")

A Yes, using | between Some(x) and None

B Yes, by combining with &

C No, because Some(x) binds a variable and None does not

D No, because None is not a pattern

You cannot combine patterns with variable bindings and those without in one arm using |.

What error occurs if you try to bind variables in multiple patterns combined with |?

A Syntax error: unexpected token

B Cannot bind variable to multiple patterns

C Runtime panic

D No error

Rust forbids binding variables in multiple patterns combined with | because it cannot decide which binding to use.

Why use multiple patterns in one match arm?

A To handle several cases with the same code

B To improve runtime speed

C To bind variables to all patterns

D To avoid using match

It helps write cleaner code by grouping cases that share the same behavior.

Explain how to match multiple patterns in one match arm in Rust and when it is useful.

Think about grouping values that need the same action.

Describe the limitation of variable bindings when matching multiple patterns with | in Rust.

Consider why Rust cannot decide which variable to bind.

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