Basic match usage in Rust - Mini Project: Build & Apply

Basic match usage

📖 Scenario: Imagine you are building a simple program that checks the weather condition and gives a message based on it.

🎯 Goal: You will create a variable for the weather condition, then use a match statement to print a message depending on the weather.

📋 What You'll Learn

Create a variable called weather with the exact value "sunny".

Create a variable called temperature with the exact value 25.

Use a match statement on the weather variable with arms for "sunny", "rainy", and a catch-all _.

Print the message for the matched weather condition.

💡 Why This Matters

🌍 Real World

Using <code>match</code> is common in Rust programs to handle different cases clearly and safely, like responding to user input or different program states.

💼 Career

Understanding <code>match</code> helps you write clear and bug-free Rust code, a skill valued in systems programming, embedded devices, and backend development.

1

Create the weather and temperature variables

Create a variable called weather and set it to the string "sunny". Also create a variable called temperature and set it to the number 25.

Rust

# Create the variables 'weather' and 'temperature'
# Your code here

Hint

Use let to create variables. Strings use double quotes.

2

Add a match statement for weather

Add a match statement on the variable weather. Create arms for "sunny", "rainy", and a catch-all arm _. For now, just write empty blocks {} for each arm.

Rust

fn main() {
    let weather = "sunny";
    let temperature = 25;

    match weather {
        "sunny" => {},
        "rainy" => {},
        _ => {},
    }
    # Your code here
}

Hint

Use match weather { ... } with arms separated by commas.

3

Add messages inside match arms

Inside the match arms, add println! statements to print these exact messages:
For "sunny": "It's a bright sunny day!"
For "rainy": "Don't forget your umbrella."
For the catch-all _: "Weather unknown."

Rust

fn main() {
    let weather = "sunny";
    let temperature = 25;

    match weather {
        "sunny" => {
            // Print sunny message
        },
        "rainy" => {
            // Print rainy message
        },
        _ => {
            // Print unknown message
        },
    }
    # Your code here
}

Hint

Use println!("message") inside each arm's block.

4

Print the temperature after the match

After the match statement, add a println! statement to print the temperature in this exact format: "The temperature is 25 degrees." Use the variable temperature inside the message with an f-string style placeholder.

Rust

fn main() {
    let weather = "sunny";
    let temperature = 25;

    match weather {
        "sunny" => {
            println!("It's a bright sunny day!");
        },
        "rainy" => {
            println!("Don't forget your umbrella.");
        },
        _ => {
            println!("Weather unknown.");
        },
    }

    // Print the temperature here
    # Your code here
}

Hint

Use println!("The temperature is {} degrees.", temperature); to print the temperature.

Practice

1. What does the match expression do in Rust?

easy

A. It compares a value against multiple patterns and runs matching code.

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

C. It loops through a list of numbers.

D. It defines a function that returns a value.

Solution

1. Step 1: Understand the purpose of match

   The match expression compares a value against several patterns.

2. Step 2: Identify what happens on a match

   When a pattern matches, the corresponding code block runs.

3. Final Answer:

   It compares a value against multiple patterns and runs matching code. -> Option A

4. Quick Check:

   match checks patterns = C [OK]

Hint: Remember: match checks value patterns and runs matching code [OK]

Common Mistakes:

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

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

easy

A. match value { pattern : action, _ : default_action }

B. match (value) { pattern -> action, _ -> default_action }

C. match value { pattern => action, _ => default_action }

D. match value (pattern => action, _ => default_action)

Solution

1. Step 1: Recall Rust match syntax

   Rust uses curly braces with patterns and arrows: { pattern => action }.

2. Step 2: Check each option's syntax

   match value { pattern => action, _ => default_action } matches Rust syntax exactly; others use wrong symbols or parentheses.

3. Final Answer:

   match value { pattern => action, _ => default_action } -> Option C

4. Quick Check:

   Correct match syntax = A [OK]

Hint: Look for curly braces and => arrows in match syntax [OK]

Common Mistakes:

• Using parentheses instead of braces
• Using -> instead of =>
• Using colons instead of arrows

3. What is the output of this Rust code?

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

medium

A. One

B. Two

C. Other

D. Three

Solution

1. Step 1: Identify the matched value

   The variable number is 3.

2. Step 2: Find matching pattern in match arms

   The pattern 3 matches, so it prints "Three".

3. Final Answer:

   Three -> Option D

4. Quick Check:

   number=3 matches 3 => "Three" [OK]

Hint: Match value to pattern exactly to find output [OK]

Common Mistakes:

• Choosing default (_) arm instead of exact match
• Confusing numbers in patterns
• Ignoring the value of the variable

4. Find the error in this Rust code snippet:

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

medium

A. Missing semicolon after println! macros

B. Missing default (_) arm to cover other values

C. Incorrect variable name in match

D. Using parentheses instead of braces in match

Solution

1. Step 1: Check match arms coverage

   The match covers only 1, 2, and 3 but variable is 5.

2. Step 2: Identify missing default arm

   Without a _ arm, the code will not compile because not all values are covered.

3. Final Answer:

   Missing default (_) arm to cover other values -> Option B

4. Quick Check:

   All values must be matched or _ arm added [OK]

Hint: Always add _ arm to cover unmatched cases [OK]

Common Mistakes:

• Assuming semicolons are required after println!
• Ignoring missing default arm errors
• Confusing variable names

5. You want to write a match expression that returns a string describing a number: "small" for 1 or 2, "medium" for 3 or 4, and "large" for any other number. Which code correctly uses match to do this?

hard

A. match num {
1 | 2 => "small",
3 | 4 => "medium",
_ => "large",
}

B. match num {
1, 2 => "small",
3, 4 => "medium",
_ => "large",
}

C. match num {
1 || 2 => "small",
3 || 4 => "medium",
_ => "large",
}

D. match num {
[1, 2] => "small",
[3, 4] => "medium",
_ => "large",
}

Solution

1. Step 1: Understand pattern alternatives in match

   Rust uses | to match multiple patterns in one arm.

2. Step 2: Check each option's pattern syntax

   match num { 1 | 2 => "small", 3 | 4 => "medium", _ => "large", } correctly uses 1 | 2 and 3 | 4. Others use invalid syntax like commas, ||, or arrays.

3. Final Answer:

   match num { 1 | 2 => "small", 3 | 4 => "medium", _ => "large", } -> Option A

4. Quick Check:

   Use | for multiple patterns in match arms [OK]

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

Common Mistakes:

• Using commas instead of | in patterns
• Using || which is logical OR, not pattern OR
• Trying to match arrays instead of values