Defining enums in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a simple enum named Color.

Rust

enum [1] {
    Red,
    Green,
    Blue
}

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

AColor

Bcolor

CColors

DcolorEnum

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase names for enums.

Adding spaces or invalid characters in the enum name.

The enum name should be Color starting with a capital letter as per Rust naming conventions.

2fill in blank

medium

Complete the code to add a variant Yellow to the Color enum.

Rust

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

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

Ayellow

ByellowColor

CYELLOW

DYellow

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase variant names.

Using snake_case or camelCase instead of PascalCase.

Enum variants in Rust start with a capital letter, so Yellow is correct.

3fill in blank

hard

Fix the error in the enum definition by completing the code.

Rust

enum Shape {
    Circle(f64),
    Rectangle[1](f64, f64),
}

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

AWidthHeight

Bwidth_height

Cradius

DwidthHeight

Attempts:

3 left

💡 Hint

Common Mistakes

Using snake_case for variant names.

Using lowercase letters at the start of variant names.

Enum variants must be named with PascalCase, so WidthHeight is correct.

4fill in blank

hard

Fill both blanks to define an enum Message with variants Quit and Move that holds two i32 values.

Rust

enum [1] {
    Quit,
    [2](i32, i32),
}

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

AMessage

Bmove

CMove

Dmessage

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase names for enum or variants.

Forgetting parentheses for variants holding data.

The enum name is Message and the variant is Move with capital letters.

5fill in blank

hard

Fill all three blanks to define an enum Result with variants Ok holding a T and Error holding a E.

Rust

enum [1]<T, E> {
    [2](T),
    [3](E)
}

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

AResult

BOk

CError

Dresult

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase names for enum or variants.

Missing generic parameters in enum definition.

The enum is Result with variants Ok and Error, all using PascalCase.

Practice

1. What is the main purpose of defining an enum in Rust?

easy

A. To create a function that returns multiple values

B. To write a loop that iterates over numbers

C. To define a variable that can only hold integers

D. To group related values under one type name

Solution

1. Step 1: Understand what enums represent

   Enums group related values under a single type name, making code clearer and safer.

2. Step 2: Compare options with enum purpose

   Only To group related values under one type name correctly describes grouping related values under one type name.

3. Final Answer:

   To group related values under one type name -> Option D

4. Quick Check:

   Enums = Group related values [OK]

Hint: Enums group related values under one name [OK]

Common Mistakes:

• Thinking enums are for loops or functions
• Confusing enums with variables or constants
• Believing enums only hold integers

2. Which of the following is the correct syntax to define a simple enum named Color with variants Red, Green, and Blue?

easy

A. enum Color { Red, Green, Blue }

B. enum Color = { Red, Green, Blue }

C. enum Color: Red, Green, Blue;

D. enum Color { Red; Green; Blue; }

Solution

1. Step 1: Recall Rust enum syntax

   Rust enums use curly braces with comma-separated variants, no equals or semicolons.

2. Step 2: Check each option

   enum Color { Red, Green, Blue } matches correct syntax: enum Color { Red, Green, Blue }.

3. Final Answer:

   enum Color { Red, Green, Blue } -> Option A

4. Quick Check:

   Enum syntax = curly braces with commas [OK]

Hint: Use curly braces and commas for enum variants [OK]

Common Mistakes:

• Using '=' instead of braces
• Separating variants with semicolons
• Using colon ':' after enum name

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 South

B. Going North

C. Going East

D. Going West

Solution

1. Step 1: Identify the 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 enum variant to print correct message [OK]

Common Mistakes:

• Confusing variant names in match arms
• Forgetting to use enum name with variants
• Assuming default output without match

4. Identify the error in this enum definition:

enum Status {
    Active,
    Inactive,
    Pending()
}

medium

A. Enum variants must all have parentheses

B. The variant 'Pending' should not have parentheses unless it holds data

C. Enum name cannot be 'Status'

D. Missing semicolon after enum definition

Solution

1. Step 1: Check variant syntax

   Variants without data should not have parentheses; 'Pending()' is incorrect here.

2. Step 2: Confirm correct enum variant style

   Only variants holding data use parentheses; others are simple names.

3. Final Answer:

   The variant 'Pending' should not have parentheses unless it holds data -> Option B

4. Quick Check:

   Simple variants = no parentheses [OK]

Hint: Only use parentheses for variants holding data [OK]

Common Mistakes:

• Adding empty parentheses to simple variants
• Thinking all variants need parentheses
• Confusing enum name rules

5. Given this enum with data:

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

Which code correctly creates a Message variant to move to coordinates (10, 20)?

hard

A. let msg = Message::Move { x: 10, y: 20 };

B. let msg = Message::Move(10, 20);

C. let msg = Message::Move(10, y: 20);

D. let msg = Message::Move { 10, 20 };

Solution

1. Step 1: Understand the variant type

   The variant Move uses named fields inside braces: { x: i32, y: i32 }.

2. Step 2: Match correct syntax for named fields

   let msg = Message::Move { x: 10, y: 20 }; uses correct syntax with field names and values: Move { x: 10, y: 20 }.

3. Final Answer:

   let msg = Message::Move { x: 10, y: 20 }; -> Option A

4. Quick Check:

   Named fields need braces and field names [OK]

Hint: Use braces and field names for struct-like enum variants [OK]

Common Mistakes:

• Using tuple syntax for struct-like variants
• Omitting field names inside braces
• Mixing tuple and struct variant syntax