Match expression deep dive in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a match expression in Rust?

A match expression lets you compare a value against many patterns and execute code based on which pattern matches. It's like a smart switch that checks all possibilities.

beginner

How does Rust handle unmatched patterns in a match expression?

Rust requires all possible cases to be covered in a match. If some cases are missing, the code won't compile. You can use a catch-all pattern _ to cover any leftover cases.

intermediate

What is the role of the @ operator in a match pattern?

The @ operator lets you name a value while also testing it against a pattern. For example, id @ 1..=5 means "match values from 1 to 5 and call it id".

beginner

Explain how to match multiple patterns in one arm of a match expression.

You can match multiple patterns separated by | in one arm. For example, 1 | 2 | 3 => println!("One to three") runs the same code for 1, 2, or 3.

beginner

What happens if you forget to handle a pattern in a match expression?

Rust will give a compile-time error saying the match is not exhaustive. This helps avoid bugs by forcing you to handle all possible cases.

What does the underscore _ pattern do in a match expression?

A Matches only negative numbers

B Matches any value not matched by previous patterns

C Matches only zero

D Causes a compile error

The underscore _ is a catch-all pattern that matches any value not matched before.

How do you bind a matched value to a variable inside a match arm?

A You cannot bind values in <code>match</code>

B Using <code>let</code> inside the arm

C Using <code>match</code> keyword again

D Using the <code>@</code> operator, like <code>id @ 1..=5</code>

The @ operator lets you name the matched value while testing it against a pattern.

Which of these is a valid way to match multiple values in one match arm?

A 1 | 2 | 3 => println!("Matched")

B 1 & 2 & 3 => println!("Matched")

C 1, 2, 3 => println!("Matched")

D 1 + 2 + 3 => println!("Matched")

The pipe | operator matches any one of the listed patterns.

What will happen if a match expression does not cover all possible cases?

A Compile-time error

B Runtime panic

C It will ignore missing cases

D It will print a warning but compile

Rust enforces exhaustive matching at compile time to prevent bugs.

In a match expression, what does this arm do? Some(x) => println!("Value: {}", x)

A Causes a syntax error

B Matches any value and ignores it

C Matches an Option with a value and binds it to x

D Matches None variant

This matches the Some variant of Option and binds the inner value to x.

Explain how Rust's match expression ensures all cases are handled and why this is helpful.

Think about what happens if you forget a case.

Describe how to use the @ operator in a match pattern and give an example.

It lets you name the value while matching it.