Why pattern matching is needed in Rust - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use pattern matching instead of if-else chains?

In Rust, pattern matching is often preferred over long if-else chains. Why is this the case?

A Pattern matching allows checking multiple conditions in a clear, concise way and ensures all cases are handled.

B Pattern matching is slower but easier to write than if-else chains.

C If-else chains can only check one condition at a time, pattern matching can check none.

D Pattern matching is only used for error handling, not for general conditions.

💡 Hint

Think about how pattern matching helps with clarity and completeness.

Pattern matching lets you write clear code that handles all possible cases explicitly. It is more readable and helps avoid missing cases compared to if-else chains.

❓ Predict Output

intermediate

What is the output of this Rust code using pattern matching?

Consider this Rust code snippet:

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

What will it print?

A Other

B Two

C One

D Three

💡 Hint

Look at the value of number and which arm matches it.

The value 3 matches the third arm, so it prints "Three".

🔧 Debug

advanced

What error does this Rust pattern matching code produce?

Look at this Rust code:

let value = Some(5);
match value {
    Some(x) => println!("Value is {}", x),
}

What error will the compiler show?

A Error: match arms have different types

B Error: non-exhaustive patterns, missing None case

C Error: variable x not found

D No error, code compiles fine

💡 Hint

Think about whether all possible cases of Option are covered.

The match is missing the None case, so the compiler complains about non-exhaustive patterns.

📝 Syntax

advanced

Which option correctly uses pattern matching with guards in Rust?

Which of these Rust code snippets correctly uses a pattern guard in a match arm?

A

match x {
    n > 0 => println!("Positive"),
    _ => println!("Non-positive"),
}

B

match x {
    n if n > 0: println!("Positive"),
    _ => println!("Non-positive"),
}

C

match x {
    n if n > 0 => println!("Positive"),
    _ => println!("Non-positive"),
}

D

match x {
    n if (n > 0) => println!("Positive"),
    _ => println!("Non-positive"),
}

💡 Hint

Remember the syntax for pattern guards uses if after the pattern.

Option C correctly uses n if n > 0 as a pattern guard. Option C is invalid syntax. Option C uses a colon instead of =>. Option C has extra parentheses but is still valid syntax in Rust, but the question is about the correct standard style, so B is preferred.

🚀 Application

expert

How many arms are needed to exhaustively match this enum?

Given this Rust enum:

enum TrafficLight {
    Red,
    Yellow,
    Green,
}

How many arms are needed in a match statement to cover all cases without using a wildcard arm?

A 3

B 2

C 1

D 4

💡 Hint

Count the number of variants in the enum.

There are three variants: Red, Yellow, and Green. To cover all without a wildcard, you need three arms.