Why pattern matching is needed in Rust - See It in Action

Why pattern matching is needed

📖 Scenario: Imagine you are building a simple program that checks the weather condition and suggests what to do. The weather can be sunny, rainy, or snowy. You want your program to respond differently for each case.

🎯 Goal: You will create a Rust program that uses pattern matching to handle different weather conditions and print the right suggestion. This will show why pattern matching is useful for making clear and simple decisions based on different values.

📋 What You'll Learn

Create an enum called Weather with variants Sunny, Rainy, and Snowy

Create a variable called today and set it to Weather::Rainy

Use a match expression on today with arms for each weather variant

Print a suggestion message for each weather condition inside the match arms

💡 Why This Matters

🌍 Real World

Pattern matching is used in many programs to make decisions based on different possible values, like handling user input, processing commands, or working with data that can be many types.

💼 Career

Understanding pattern matching is important for Rust developers and helps write safe, clear, and efficient code in real-world applications.

1

Create the Weather enum

Create an enum called Weather with three variants: Sunny, Rainy, and Snowy.

Rust

# Your code here

Hint

An enum groups related values under one name. Use enum Weather { Sunny, Rainy, Snowy }.

2

Create a variable for today's weather

Create a variable called today and set it to Weather::Rainy.

Rust

enum Weather {
    Sunny,
    Rainy,
    Snowy,
}

# Your code here

Hint

Use let today = Weather::Rainy; to create the variable.

3

Use match to handle weather cases

Use a match expression on today with arms for Weather::Sunny, Weather::Rainy, and Weather::Snowy. For each arm, write a comment describing what to do.

Rust

enum Weather {
    Sunny,
    Rainy,
    Snowy,
}

fn main() {
    let today = Weather::Rainy;

    match today {
        // Your code here
    }
}

Hint

Use match today { Weather::Sunny => {}, Weather::Rainy => {}, Weather::Snowy => {} }.

4

Print suggestions for each weather

Inside each match arm, use println! to print a suggestion: "It's sunny! Go outside.", "It's rainy! Take an umbrella.", and "It's snowy! Wear a coat.".

Rust

enum Weather {
    Sunny,
    Rainy,
    Snowy,
}

fn main() {
    let today = Weather::Rainy;

    match today {
        Weather::Sunny => {
            // Your code here
        }
        Weather::Rainy => {
            // Your code here
        }
        Weather::Snowy => {
            // Your code here
        }
    }
}

Hint

Use println!("message") inside each arm to show the suggestion.

Practice

1. Why is pattern matching important in Rust programming?

easy

A. It helps handle different data cases clearly and safely.

B. It makes the program run faster than loops.

C. It automatically fixes syntax errors.

D. It replaces all functions with simpler code.

Solution

1. Step 1: Understand pattern matching purpose

   Pattern matching lets you check different forms of data and handle each case clearly.

2. Step 2: Compare with other options

   The other options describe unrelated or incorrect benefits.

3. Final Answer:

   It helps handle different data cases clearly and safely. -> Option A

4. Quick Check:

   Pattern matching = clear, safe data handling [OK]

Hint: Pattern matching handles many cases clearly and safely [OK]

Common Mistakes:

• Thinking pattern matching speeds up code execution
• Believing it fixes syntax errors automatically
• Confusing pattern matching with function replacement

2. Which of the following is the correct syntax to start a pattern match in Rust?

easy

A. switch(value) { ... }

B. if value == { ... }

C. match value { ... }

D. case value: { ... }

Solution

1. Step 1: Identify Rust pattern matching syntax

   Rust uses the keyword match followed by the value and braces.

2. Step 2: Eliminate other language syntax

   The other options use syntax from other languages or incorrect forms.

3. Final Answer:

   match value { ... } -> Option C

4. Quick Check:

   Rust pattern match starts with 'match' [OK]

Hint: Rust uses 'match' keyword for pattern matching [OK]

Common Mistakes:

• Using 'switch' instead of 'match'
• Trying to use 'case' like in other languages
• Confusing 'if' statement with pattern matching

3. What will this Rust code print?

let number = Some(5);
match number {
    Some(x) if x > 3 => println!("Greater than 3"),
    Some(_) => println!("3 or less"),
    None => println!("No value"),
}

medium

A. 3 or less

B. Greater than 3

C. No value

D. Compilation error

Solution

1. Step 1: Analyze the matched value

   The variable number is Some(5), so it matches Some(x) with x=5.

2. Step 2: Check the guard condition

   The first arm has a condition if x > 3, which is true for 5, so it prints "Greater than 3".

3. Final Answer:

   Greater than 3 -> Option B

4. Quick Check:

   Some(5) with x>3 prints 'Greater than 3' [OK]

Hint: Check guard conditions in match arms carefully [OK]

Common Mistakes:

• Ignoring the if guard and picking second arm
• Thinking None matches Some(5)
• Assuming compilation error due to guard

4. Identify the error in this Rust code using pattern matching:

let value = 10;
match value {
    1 => println!("One"),
    2 => println!("Two"),
}

medium

A. Missing a catch-all pattern to cover other values

B. Incorrect use of println! macro

C. Variable 'value' should be mutable

D. Match arms must return a value

Solution

1. Step 1: Check match arms coverage

   The match only covers 1 and 2, but value is 10, so no arm matches.

2. Step 2: Understand Rust match exhaustiveness

   Rust requires all possible cases covered or a catch-all arm like _.

3. Final Answer:

   Missing a catch-all pattern to cover other values -> Option A

4. Quick Check:

   Match must cover all cases or use catch-all [OK]

Hint: Always include a catch-all (_) arm if not all cases covered [OK]

Common Mistakes:

• Forgetting match must be exhaustive
• Thinking println! usage is wrong
• Assuming variable must be mutable

5. You want to safely extract a number from an Option<i32> and print it, or print "No number" if None. Which pattern matching code correctly does this?

hard

A. match opt {
Some(n) if n > 0 => println!("Number: {}", n),
_ => println!("No number"),
}

B. if let Some(n) = opt {
println!("Number: {}", n);
} else {
println!("No number");
}

C. match opt {
Some => println!("Number: {}", opt),
None => println!("No number"),
}

D. match opt {
Some(n) => println!("Number: {}", n),
None => println!("No number"),
}

Solution

1. Step 1: Check correct pattern matching syntax

   match opt { Some(n) => println!("Number: {}", n), None => println!("No number"), } matches Some(n) and None correctly and prints accordingly.

2. Step 2: Evaluate other options

   The option with a guard condition if n > 0 incorrectly excludes non-positive numbers. The if let approach works but uses destructuring instead of a full match. The option with Some => lacks variable binding and would print the Option rather than the number.

3. Final Answer:

   match opt { Some(n) => println!("Number: {}", n), None => println!("No number"), } -> Option D

4. Quick Check:

   Correct pattern match covers Some and None [OK]

Hint: Match Some(n) and None explicitly for safe extraction [OK]

Common Mistakes:

• Using if let instead of match (not pattern matching)
• Missing variable in Some pattern
• Adding unnecessary conditions excluding valid values