Match with enums in Rust - Step-by-Step Execution

Concept Flow - Match with enums

Start with enum value

↓

Match expression begins

↓

Check each enum variant

↓

Variant1

↓

Run code

↓

Match ends

The program takes an enum value and checks it against each variant using match. It runs the code for the matching variant and then ends.

Execution Sample

Rust

enum Color {
    Red,
    Green,
    Blue,
}

fn main() {
    let color = Color::Green;

    match color {
        Color::Red => println!("Red color"),
        Color::Green => println!("Green color"),
        Color::Blue => println!("Blue color"),
    }
}

This code matches the enum value 'color' and prints a message depending on which color it is.

Execution Table

Step	Match Expression	Checked Variant	Match Result	Action Taken	Output
1	color = Color::Green	Color::Red	No match	Skip
2	color = Color::Green	Color::Green	Match	Execute println!("Green color")	Green color
3	color = Color::Green	Color::Blue	Not checked (match found)	Skip
4	Match ends	-	-	-	-

💡 Match ends after finding Color::Green variant matches.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
color	Color::Green	Color::Green	Color::Green	Color::Green	Color::Green

Key Moments - 2 Insights

Why does the match stop checking after Color::Green variant?

Because match stops at the first variant that matches the value, as shown in execution_table row 3 where Color::Blue is not checked.

What happens if no variant matches the enum value?

Rust requires all variants to be covered or a catch-all _ pattern; otherwise, it causes a compile error. Here, all variants are matched.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output at step 2?

A Blue color

B Red color

C Green color

D No output

💡 Hint

Check the 'Output' column in row 2 of execution_table.

At which step does the match expression find a matching variant?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Look at the 'Match Result' column to see where 'Match' occurs.

If color was Color::Blue, which step would produce output?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Refer to execution_table rows and imagine color = Color::Blue instead.

Concept Snapshot

Match with enums in Rust:
- Use match to check enum variants.
- Each variant has a code block.
- Match stops at first matching variant.
- All variants must be covered.
- Prints or returns based on matched variant.

Full Transcript

This example shows how Rust's match expression works with enums. We start with an enum value 'color' set to Color::Green. The match expression checks each variant in order: Red, Green, Blue. It skips Red because it doesn't match. When it reaches Green, it matches and runs the code to print 'Green color'. It then stops checking further variants. The variable 'color' remains unchanged throughout. This behavior ensures only one matching branch runs. If no variant matched, Rust would require a catch-all pattern or cause a compile error. This trace helps beginners see how match compares enum values step-by-step and executes the matching code.

Practice

1.

What does the match statement do when used with enums in Rust?

easy

A. It checks the enum variant and runs the matching code block.

B. It converts the enum into a string automatically.

C. It creates a new enum variant.

D. It deletes the enum variant from memory.

Solution

1. Step 1: Understand the purpose of match with enums

   The match statement compares the enum value against each variant.

2. Step 2: Identify what happens on a match

   When a variant matches, the corresponding code block runs.

3. Final Answer:

   It checks the enum variant and runs the matching code block. -> Option A

4. Quick Check:

   Match runs code by enum variant [OK]

Hint: Match arms correspond to enum variants directly [OK]

Common Mistakes:

• Thinking match converts enums to strings
• Assuming match creates or deletes variants
• Confusing match with if-else statements

2.

Which of the following is the correct syntax to match an enum Color with variants Red, Green, and Blue?

enum Color { Red, Green, Blue }

easy

A. match color { Color.Red => {}, Color.Green => {}, Color.Blue => {} }

B. match color { Red => {}, Green => {}, Blue => {} }

C. match color { Color::Red => {}, Color::Green => {}, Color::Blue => {} }

D. match color { 'Red' => {}, 'Green' => {}, 'Blue' => {} }

Solution

1. Step 1: Recall enum variant syntax in match

   Enum variants must be prefixed with the enum name and double colon, like Color::Red.

2. Step 2: Check each option's syntax

   Only match color { Color::Red => {}, Color::Green => {}, Color::Blue => {} } uses the correct Color::Variant syntax.

3. Final Answer:

   match color { Color::Red => {}, Color::Green => {}, Color::Blue => {} } -> Option C

4. Quick Check:

   Enum variants use EnumName::Variant [OK]

Hint: Use EnumName::Variant in match arms [OK]

Common Mistakes:

• Omitting enum name prefix
• Using dot instead of double colon
• Using strings instead of variants

3.

What will be the output of this Rust code?

enum Direction { North, South, East, West }

fn main() {
    let dir = Direction::East;
    let message = match dir {
        Direction::North => "Going up",
        Direction::South => "Going down",
        Direction::East => "Going right",
        Direction::West => "Going left",
    };
    println!("{}", message);
}

medium

A. Going right

B. Going up

C. Going left

D. Going down

Solution

1. Step 1: Identify the enum variant assigned

   The variable dir is set to Direction::East.

2. Step 2: Match dir to the correct message

   The match arm for Direction::East returns "Going right".

3. Final Answer:

   Going right -> Option A

4. Quick Check:

   Direction::East matches "Going right" [OK]

Hint: Match returns value for the exact enum variant [OK]

Common Mistakes:

• Mixing up enum variants and their messages
• Forgetting to use EnumName::Variant in match
• Assuming default or fallback arm runs

4.

Find the error in this Rust code snippet using match with enums:

enum Status { Success, Failure }

fn check(status: Status) {
    match status {
        Status::Success => println!("Success"),
        // Missing Failure arm
    }
}

medium

A. Missing semicolon after println! macro

B. Function check should return a value

C. Incorrect enum variant syntax

D. Missing match arm for Status::Failure

Solution

1. Step 1: Check completeness of match arms

   The match statement covers Status::Success but misses Status::Failure.

2. Step 2: Understand Rust's exhaustiveness requirement

   Rust requires all enum variants to be matched or a catch-all arm (_) to avoid compile errors.

3. Final Answer:

   Missing match arm for Status::Failure -> Option D

4. Quick Check:

   All enum variants must be matched [OK]

Hint: Match must cover all enum variants or use _ arm [OK]

Common Mistakes:

• Leaving out enum variants in match arms
• Assuming partial match compiles
• Confusing semicolon placement with match completeness

5.

Given this enum with data:

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

Which match arm correctly extracts the x and y values from Message::Move?

hard

A. Message::Move(x, y) => println!("x: {}, y: {}", x, y),

B. Message::Move { x, y } => println!("x: {}, y: {}", x, y),

C. Message::Move(x: x, y: y) => println!("x: {}, y: {}", x, y),

D. Message::Move(x: x, y) => println!("x: {}, y: {}", x, y),

Solution

1. Step 1: Identify the enum variant with named fields

   Move uses named fields { x: i32, y: i32 }.

2. Step 2: Match syntax for named fields

   Use Message::Move { x, y } to destructure named fields directly.

3. Final Answer:

   Message::Move { x, y } => println!("x: {}, y: {}", x, y), -> Option B

4. Quick Check:

   Named fields use braces and field names [OK]

Hint: Use braces and field names to destructure named fields [OK]

Common Mistakes:

• Using tuple pattern for struct-like variant
• Mixing colon syntax incorrectly
• Omitting braces for named fields