Matching multiple patterns in Rust - Mini Project: Build & Apply

Matching Multiple Patterns in Rust

📖 Scenario: You are building a simple program that categorizes animals based on their names. Some animals belong to groups that share common traits. You want to use Rust's match statement to check if an animal belongs to one of these groups by matching multiple patterns.

🎯 Goal: Create a Rust program that uses match with multiple patterns to print the group an animal belongs to.

📋 What You'll Learn

Create a variable called animal with the exact value "dog".

Create a variable called domestic_animals with the exact value ["dog", "cat", "rabbit"].

Use a match statement on the variable animal with multiple patterns combined using | to match domestic animals.

Print the exact output "dog is a domestic animal" when animal is "dog".

💡 Why This Matters

🌍 Real World

Matching multiple patterns is useful when you want to check if a value belongs to a group of options, like categorizing animals, handling commands, or processing user input.

💼 Career

Understanding pattern matching in Rust is important for writing clear and efficient code in system programming, web backend development, and other Rust applications.

1

Create the animal variable

Create a variable called animal and set it to the string "dog".

Rust

// Create a variable called animal and set it to "dog"
// Your code here

Hint

Use let animal = "dog"; to create the variable.

2

Create the domestic_animals array

Add a variable called domestic_animals and set it to the array ["dog", "cat", "rabbit"].

Rust

fn main() {
    let animal = "dog";
    // Create a variable called domestic_animals with ["dog", "cat", "rabbit"]
    // Your code here
}

Hint

Use let domestic_animals = ["dog", "cat", "rabbit"]; to create the array.

3

Use match with multiple patterns

Use a match statement on animal with multiple patterns combined using | to match "dog", "cat", or "rabbit". For these cases, print "{} is a domestic animal" using animal in println!. For all other cases, print "{} is a wild animal" using animal in println!.

Rust

fn main() {
    let animal = "dog";
    let domestic_animals = ["dog", "cat", "rabbit"];

    // Use match on animal with multiple patterns "dog" | "cat" | "rabbit"
    // Print "{} is a domestic animal" for these cases using animal
    // Print "{} is a wild animal" for others using animal
    // Your code here
}

Hint

Use match animal { "dog" | "cat" | "rabbit" => ... , _ => ... } to match multiple patterns.

4

Print the result

Run the program and print the output. The output should be exactly "dog is a domestic animal".

Rust

fn main() {
    let animal = "dog";
    let domestic_animals = ["dog", "cat", "rabbit"];

    match animal {
        "dog" | "cat" | "rabbit" => println!("{} is a domestic animal", animal),
        _ => println!("{} is a wild animal", animal),
    }

    // Print the output
    // Your code here
}

Hint

Run the program to see the output.

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