Why Basic match usage in Rust? - Purpose & Use Cases

The Big Idea

What if you could replace long, messy checks with one simple, clear tool that handles everything perfectly?

The Scenario

Imagine you have a list of different fruits, and you want to print a special message for each type. Without a tool like match, you might write many if and else checks for each fruit.

The Problem

Writing many if and else statements is slow and confusing. It's easy to forget a case or make mistakes, and the code becomes long and hard to read.

The Solution

The match statement lets you check a value against many patterns clearly and simply. It organizes your code so each case is easy to see and handle, making your program neat and less error-prone.

Before vs After

✗ Before

if fruit == "apple" {
    println!("This is an apple.");
} else if fruit == "banana" {
    println!("This is a banana.");
} else {
    println!("Unknown fruit.");
}

✓ After

match fruit {
    "apple" => println!("This is an apple."),
    "banana" => println!("This is a banana."),
    _ => println!("Unknown fruit."),
}

What It Enables

With match, you can easily handle many different cases in your program clearly and safely, making your code easier to write and understand.

Real Life Example

Think about a vending machine that gives different messages depending on the button pressed. Using match, you can quickly decide what to do for each button without messy code.

Key Takeaways

Match helps you check many conditions clearly.

It makes your code shorter and easier to read.

It reduces mistakes by forcing you to handle all cases.

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