Basic match usage in Rust

Introduction

The match statement helps you check a value against many possibilities and run code based on which one matches. It makes your code clear and easy to read.

You want to do different things based on a number or word.

You have a small set of options and want to handle each one clearly.

You want to replace many <code>if-else</code> checks with cleaner code.

You want to handle errors or special cases in a clear way.

You want to check the type or value of something and act accordingly.

Syntax

Rust

match value {
    pattern1 => expression1,
    pattern2 => expression2,
    _ => default_expression,
}

The value is what you want to check.

Each pattern is a possible match. The underscore _ means "anything else" (default case).

Examples

Checks the number and prints the matching word.

Rust

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

Matches if the letter is a vowel or not.

Rust

let letter = 'a';
match letter {
    'a' | 'e' | 'i' | 'o' | 'u' => println!("Vowel"),
    _ => println!("Consonant"),
}

Uses a range pattern to check if x is between 1 and 5.

Rust

let x = 5;
match x {
    1..=5 => println!("Between 1 and 5"),
    _ => println!("Outside range"),
}

Sample Program

This program checks the number in day and prints the matching weekday name. If the number is not 1 to 7, it prints "Invalid day".

Rust

fn main() {
    let day = 3;
    match day {
        1 => println!("Monday"),
        2 => println!("Tuesday"),
        3 => println!("Wednesday"),
        4 => println!("Thursday"),
        5 => println!("Friday"),
        6 => println!("Saturday"),
        7 => println!("Sunday"),
        _ => println!("Invalid day"),
    };
}

Important Notes

Every possible value should be covered by patterns or the default _ case, or the code will not compile.

You can match many patterns in one line using | (OR) operator.

Match arms can run any code, not just print statements.

Summary

match checks a value against many patterns.

Use _ to catch all other cases.

It makes your code easier to read and safer.

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