Basic match usage in Rust - Step-by-Step Execution

Concept Flow - Basic match usage

Start with a value

↓

match value with patterns

↓

Pattern 1?

Yes→Execute code 1

↓

Pattern 2?

Yes→Execute code 2

↓

Pattern 3?

Yes→Execute code 3

↓

Default pattern

→Execute default code

↓

End match

The match expression compares a value against patterns one by one and runs the code for the first matching pattern.

Execution Sample

Rust

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

This code checks the value of 'number' and prints a message depending on which pattern matches.

Execution Table

Step	Value matched	Pattern checked	Match?	Action executed	Output
1	2	1	No	None
2	2	2	Yes	println!("Two")	Two
3	-	Default (_)	Skipped	None

💡 Match stops after the first successful pattern match (pattern 2).

Variable Tracker

Variable	Start	After match
number	2	2

Key Moments - 2 Insights

Why does the match stop after checking pattern 2 and not continue to the default?

Because match stops at the first pattern that matches the value, as shown in execution_table row 2 where pattern 2 matches and the default is skipped.

What does the underscore (_) pattern mean in the match?

The underscore is a catch-all pattern that matches any value not matched by previous patterns, as seen in execution_table row 3.

Visual Quiz - 3 Questions

Look at the execution table, what pattern is checked first?

A Pattern 1

B Pattern 2

C Default (_)

D Pattern 3

💡 Hint

Check the 'Pattern checked' column in the first row of the execution_table.

At which step does the match find a successful pattern?

A Step 1

B Step 3

C Step 2

D No successful match

💡 Hint

Look at the 'Match?' column to find where it says 'Yes'.

If 'number' was 5, which pattern would match?

A Pattern 1

B Default (_)

C Pattern 2

D No pattern matches

💡 Hint

Refer to variable_tracker and the meaning of the underscore pattern in key_moments.

Concept Snapshot

match value {
    pattern1 => action1,
    pattern2 => action2,
    _ => default_action,
}

- Checks patterns top to bottom
- Runs code for first match
- '_' is catch-all default
- Stops after first match

Full Transcript

This example shows how Rust's match expression works. We start with a value 'number' set to 2. The match checks each pattern in order: first 1, then 2, then the default underscore. It finds that 2 matches pattern 2, so it runs the code to print "Two" and stops checking further patterns. The underscore pattern is a catch-all for any value not matched earlier. Variables keep their values unchanged during matching. This step-by-step trace helps understand how match chooses which code to run.

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