Match with enums in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to match the enum variant and print a message.

Rust

enum Direction {
    North,
    South,
    East,
    West,
}

fn main() {
    let dir = Direction::North;
    match dir {
        Direction::North => println!("You are heading [1]."),
        _ => println!("Other direction."),
    }
}

Drag options to blanks, or click blank then click option'

A"right"

B"up"

C"left"

D"north"

Attempts:

3 left

💡 Hint

Common Mistakes

Using a direction word that doesn't match the variant.

Forgetting to put quotes around the string.

The match arm for Direction::North prints "You are heading north." so the blank should be filled with "north".

2fill in blank

medium

Complete the match expression to handle the Color enum and print the color name.

Rust

enum Color {
    Red,
    Green,
    Blue,
}

fn main() {
    let c = Color::Green;
    match c {
        Color::Red => println!("Color is Red"),
        Color::Green => println!("Color is [1]"),
        Color::Blue => println!("Color is Blue"),
    }
}

Drag options to blanks, or click blank then click option'

A"green"

B"Green"

Cgreen

DGreen

Attempts:

3 left

💡 Hint

Common Mistakes

Using the enum variant name without quotes.

Using lowercase without quotes.

The message prints a string, so the color name must be a string literal with quotes. "green" is correct.

3fill in blank

hard

Fix the error in the match expression by completing the blank.

Rust

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

fn main() {
    let msg = Message::Move { x: 10, y: 20 };
    match msg {
        Message::Quit => println!("Quit message"),
        Message::Move {{ x, y }} => println!("Move to x: [1], y: {}", y),
        Message::Write(text) => println!("Write message: {}", text),
    }
}

Drag options to blanks, or click blank then click option'

Ax

B"x"

Cy

D"y"

Attempts:

3 left

💡 Hint

Common Mistakes

Putting quotes around x which would print the letter instead of the value.

Using y instead of x for the first placeholder.

The placeholder in the format string expects a variable for x coordinate. The variable is x extracted from the Move variant.

4fill in blank

hard

Fill both blanks to complete the match arms for the enum Result with Ok and Err variants.

Rust

enum Result<T, E> {
    Ok(T),
    Err(E),
}

fn main() {
    let res: Result<i32, &str> = Result::Ok(42);
    match res {
        Result::Ok(value) => println!("Success with value: [1]"),
        Result::Err(error) => println!("Error: [2]"),
    }
}

Drag options to blanks, or click blank then click option'

Avalue

Berror

C"error"

D"value"

Attempts:

3 left

💡 Hint

Common Mistakes

Using quoted strings instead of variables.

Mixing up the variable names.

The placeholders should be replaced with the variable names value and error extracted from the enum variants.

5fill in blank

hard

Fill all three blanks to complete the match expression for the enum Shape with different variants.

Rust

enum Shape {
    Circle(f64),
    Rectangle { width: f64, height: f64 },
    Square(f64),
}

fn area(shape: Shape) -> f64 {
    match shape {
        Shape::Circle(radius) => 3.14 * [1] * [2],
        Shape::Rectangle { width, height } => [3] * height,
        Shape::Square(size) => size * size,
    }
}

Drag options to blanks, or click blank then click option'

Aradius

Cwidth

Dsize

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong variable names or missing one radius in circle area.

Using size instead of width for rectangle.

For Circle, area is π * radius * radius, so both blanks are radius. For Rectangle, area is width * height, so the blank is width.

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