Defining enums in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is an enum in Rust?

An enum (short for enumeration) in Rust is a type that can be one of several different variants. It lets you define a type by listing possible values it can have.

beginner

How do you define a simple enum with three variants: Red, Green, Blue?

You write:

enum Color {
    Red,
    Green,
    Blue
}

intermediate

Can Rust enums hold data? Give an example.

Yes, Rust enums can hold data. For example:

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

This lets each variant carry different types and amounts of data.

beginner

What keyword do you use to define an enum in Rust?

You use the keyword enum followed by the name and variants inside curly braces.

beginner

Why are enums useful in Rust?

Enums let you group related values under one type. They help write clear, safe code by handling different cases explicitly, like states or commands.

Which keyword defines an enum in Rust?

A struct

B class

C type

D enum

The keyword enum is used to define enumerations in Rust.

What does this enum variant represent?

Move { x: i32, y: i32 }

A A variant with no data

B A variant holding two named integer values

C A variant holding a string

D A function

This variant holds two named fields, x and y, both integers.

Can Rust enums store different types of data in different variants?

A Yes

B No

C Only if all variants have the same data type

D Only with unsafe code

Rust enums can store different types and amounts of data in each variant.

Which of these is a valid enum variant name in Rust?

A FirstOption

B first-option

C first_option

D 1stOption

Enum variant names conventionally start with a capital letter and use CamelCase.

What is the main benefit of using enums in Rust?

A To store only numbers

B To replace functions

C To group related values and handle different cases safely

D To create global variables

Enums group related values and help handle different cases explicitly and safely.

Explain how to define an enum in Rust and give an example with at least three variants.

Start with the keyword enum, then list variants inside braces.

Describe how Rust enums can hold data and why this is useful.

Think about how each variant can carry its own information.

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