Enum variants in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define an enum variant named Red.

Rust

enum Color {
    [1],
    Green,
    Blue,
}

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

ARED

BcolorRed

Cred

DRed

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase or all uppercase names for variants.

Adding prefixes like 'color' to variant names.

Enum variants in Rust are usually written in PascalCase. Here, Red is the correct variant name.

2fill in blank

medium

Complete the code to create a variable c with the enum variant Color::Green.

Rust

enum Color {
    Red,
    Green,
    Blue,
}

let c = [1];

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

AColor::Green

Bgreen

CColor.Green

DGreen

Attempts:

3 left

💡 Hint

Common Mistakes

Using dot notation instead of double colon.

Using lowercase variant names.

To create a variable with an enum variant, use the syntax EnumName::Variant. Here, Color::Green is correct.

3fill in blank

hard

Fix the error in the match expression to correctly match the Color enum variants.

Rust

enum Color {
    Red,
    Green,
    Blue,
}

let c = Color::Blue;

match c {
    [1] => println!("It's red!"),
    Color::Green => println!("It's green!"),
    Color::Blue => println!("It's blue!"),
}

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

ARed

BColor.Red

CColor::Red

Dcolor::Red

Attempts:

3 left

💡 Hint

Common Mistakes

Using dot notation instead of double colon in match arms.

Using lowercase variant names.

In match arms, enum variants can be matched with the full path using double colons, like Color::Red.

4fill in blank

hard

Fill both blanks to define an enum variant Rgb with three u8 values and create a variable color with that variant.

Rust

enum Color {
    [1](u8, u8, u8),
    Cmyk,
}

let color = Color::[2](255, 0, 0);

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

ARgb

Brgb

CRgbColor

DCMYK

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names or cases between definition and usage.

Using lowercase variant names.

The variant name must be the same in both definition and usage. Rgb is the correct PascalCase variant name.

5fill in blank

hard

Fill all three blanks to create a match expression that prints the RGB values from the Color::Rgb variant.

Rust

enum Color {
    Rgb(u8, u8, u8),
    Cmyk,
}

let color = Color::Rgb(10, 20, 30);

match color {
    Color::Rgb([1], [2], [3]) => {
        println!("Red: {}, Green: {}, Blue: {}", r, g, b);
    },
    _ => println!("Not an RGB color"),
}

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

Ar

Bg

Cb

Dx

Attempts:

3 left

💡 Hint

Common Mistakes

Using variable names that don't match the print statement.

Using a single variable for all three values.

The variables r, g, and b are used to capture the RGB values in the match pattern.

Practice

1. What is an enum variant in Rust?

easy

A. A function inside a struct

B. A named option inside an enum representing a possible value

C. A variable declared with let

D. A type of loop in Rust

Solution

1. Step 1: Understand enum structure

   An enum groups related named options called variants.

2. Step 2: Define variant role

   Each variant represents a possible value the enum can hold.

3. Final Answer:

   A named option inside an enum representing a possible value -> Option B

4. Quick Check:

   Enum variant = named option [OK]

Hint: Enum variants are named choices inside enums [OK]

Common Mistakes:

• Confusing variants with functions
• Thinking variants are variables
• Mixing variants with loops

2. Which of the following is the correct syntax to define an enum variant named Red inside an enum Color?

easy

A. enum Color { Red }

B. enum Color = Red;

C. struct Color { Red }

D. let Color = Red;

Solution

1. Step 1: Recall enum syntax

   Enums use the syntax enum Name { Variant1, Variant2 }.

2. Step 2: Match correct syntax

   enum Color { Red } correctly defines enum Color with variant Red.

3. Final Answer:

   enum Color { Red } -> Option A

4. Quick Check:

   Enum variant syntax = enum Name { Variant } [OK]

Hint: Enum variants go inside braces after enum name [OK]

Common Mistakes:

• Using '=' instead of braces
• Defining variants inside struct
• Using let instead of enum

3. What will be the output of this Rust code?

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

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

medium

A. Going North

B. Going South

C. Going East

D. Going West

Solution

1. Step 1: Identify enum variant assigned

   The variable dir is set to Direction::East.

2. Step 2: Match statement output

   The match arm for Direction::East prints "Going East".

3. Final Answer:

   Going East -> Option C

4. Quick Check:

   Match on Direction::East prints "Going East" [OK]

Hint: Match prints message for assigned enum variant [OK]

Common Mistakes:

• Confusing variant names
• Ignoring match arms
• Assuming default output

4. Identify the error in this enum variant usage:

enum Status {
    Active,
    Inactive,
}

fn main() {
    let s = Status::active;
}

medium

A. Enum variants must have data inside parentheses

B. Missing semicolon after enum definition

C. Cannot assign enum variant to variable

D. Enum variant names are case-sensitive; should be 'Active'

Solution

1. Step 1: Check variant usage

   The code uses Status::active but enum defines Active with uppercase A.

2. Step 2: Understand Rust case sensitivity

   Rust enum variants are case-sensitive; active is undefined.

3. Final Answer:

   Enum variant names are case-sensitive; should be 'Active' -> Option D

4. Quick Check:

   Variant names must match case exactly [OK]

Hint: Enum variant names are case-sensitive [OK]

Common Mistakes:

• Using wrong case for variants
• Forgetting semicolons (not error here)
• Thinking variants need data always

5. Given this enum with data:

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, y),
        Message::Write(text) => println!("Write: {}", text),
    }
}

What will this program print?

hard

A. Move to (10, 20)

B. Quit message

C. Write: Move to (10, 20)

D. Compilation error due to missing variant

Solution

1. Step 1: Identify enum variant with data

   The variable msg is Message::Move { x: 10, y: 20 }.

2. Step 2: Match arms handle each variant

   The match arm for Message::Move { x, y } prints coordinates.

3. Final Answer:

   Move to (10, 20) -> Option A

4. Quick Check:

   Match prints coordinates for Move variant [OK]

Hint: Match extracts data from enum variant fields [OK]

Common Mistakes:

• Confusing variant names
• Ignoring data inside variants
• Expecting compilation error incorrectly