Basic match usage in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the match statement in Rust?

The match statement lets you compare a value against many patterns and execute code based on which pattern matches. It's like a more powerful switch in other languages.

beginner

How do you write a simple match expression to check if a number is 1, 2, or something else?

Example:

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

The underscore _ means "anything else".

beginner

What does the underscore _ pattern mean in a match?

It means "match anything else". It's a catch-all pattern used when you don't want to specify all possible cases.

intermediate

Can match return a value in Rust? How?

Yes! <code>match</code> is an expression, so it returns the value of the matched arm. For example:<br><pre>let result = match x {
    1 => "one",
    _ => "other",
};</pre>

beginner

What happens if you don't cover all possible cases in a match?

Rust will give a compile error because match must be exhaustive. You must cover all cases or use _ to catch the rest.

What does the _ pattern do in a Rust match?

A Causes a compile error

B Matches only zero

C Matches any value not matched before

D Matches only negative numbers

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

Which of these is a valid match arm syntax?

A if 1 { println!("One") }

B case 1: println!("One")

C when 1 => println!("One")

D 1 => println!("One")

Rust uses the syntax pattern => expression in match arms.

What will this code print?

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

A Other

B One

C Two

D Compile error

Since 3 matches no specific arm, the _ arm runs, printing "Other".

Can match be used to assign a value to a variable?

A Yes, because <code>match</code> is an expression

B No, <code>match</code> only controls flow

C Only if you use <code>if</code> inside <code>match</code>

D Only with <code>return</code>

match returns the value of the matched arm, so you can assign it to variables.

What happens if you forget to cover all cases in a match?

A Rust compiles silently

B Rust gives a compile error

C Rust compiles but warns

D Rust runs but panics at runtime

Rust requires match to be exhaustive and will not compile if some cases are missing.

Explain how the match statement works in Rust and why it is useful.

Think about how <code>match</code> compares values and handles all possibilities.

Write a simple Rust match expression that prints "small" for 1 or 2, "medium" for 3 or 4, and "large" for anything else.

Use | to combine patterns for the same arm.

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