Match expression deep dive in Rust - Mini Project: Build & Apply

Match expression deep dive

📖 Scenario: You are building a simple program that categorizes numbers into groups using Rust's match expression. This helps you understand how to use match to check different conditions and handle multiple cases clearly.

🎯 Goal: Learn how to use Rust's match expression to categorize numbers into named groups and print the category.

📋 What You'll Learn

Create a variable called number with the value 7.

Create a variable called category that uses a match expression on number.

Use match arms to categorize number as "small" if it is 1, 2, or 3.

Use match arms to categorize number as "medium" if it is 4, 5, or 6.

Use a catch-all _ arm to categorize any other number as "large".

Print the category variable.

💡 Why This Matters

🌍 Real World

Using <code>match</code> expressions helps you write clear and safe code that handles many possible cases, like checking user input or categorizing data.

💼 Career

Understanding <code>match</code> is essential for Rust programming jobs, especially in systems programming, embedded devices, and safe code development.

1

Create the number variable

Create a variable called number and set it to 7.

Rust

# Create a variable called number and set it to 7
# Your code here

Hint

Use let number = 7; to create the variable.

2

Set up the match expression

Add a variable called category that uses a match expression on number.

Rust

fn main() {
    let number = 7;
    // Create a variable called category using match on number
    // Your code here
}

Hint

Start with let category = match number { _ => "unknown" }; to set up the match.

3

Add arms for small and medium numbers

In the match expression for category, add arms to return "small" if number is 1, 2, or 3, and "medium" if number is 4, 5, or 6.

Rust

fn main() {
    let number = 7;
    let category = match number {
        // Add arms for 1, 2, 3 returning "small"
        // Add arms for 4, 5, 6 returning "medium"
        _ => "unknown"
    };
}

Hint

Use the | symbol to match multiple values in one arm, like 1 | 2 | 3 => "small".

4

Add catch-all arm and print the category

Change the catch-all arm to return "large" for any other number. Then print the category variable using println!.

Rust

fn main() {
    let number = 7;
    let category = match number {
        1 | 2 | 3 => "small",
        4 | 5 | 6 => "medium",
        // Change catch-all arm to return "large"
    };
    // Print the category variable
    // Your code here
}

Hint

Use _ => "large" for the catch-all arm and println!("{}", category); to print.

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