Enum variants in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is an enum variant in Rust?

An enum variant is one of the possible named values that an enum can have. Each variant represents a different option or state within the enum.

beginner

How do you define an enum with variants in Rust?

Use the enum keyword followed by the enum name and a list of variants inside curly braces. For example:

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

intermediate

Can enum variants hold data in Rust? Give an example.

Yes, enum variants can hold data. For example:

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

This allows variants to carry different types and amounts of data.

beginner

How do you create an instance of an enum variant with data?

You call the variant like a function with the required data. For example:<br><pre>let msg = Message::Move { x: 10, y: 20 };</pre>creates a <code>Move</code> variant with x and y values.

beginner

What is the benefit of using enum variants in Rust?

Enum variants let you group related but different types of data under one type. This helps write clear, safe code that handles different cases explicitly.

Which keyword is used to define an enum in Rust?

A enum

B struct

C variant

D type

The enum keyword defines an enum type in Rust.

How do you access the East variant of an enum named Direction?

A Direction[East]

B Direction.East

C Direction->East

D Direction::East

Rust uses double colons :: to access enum variants, like Direction::East.

Which of these enum variants holds data?

A North

B Quit

C Move { x: i32, y: i32 }

D West

The Move variant holds data fields x and y.

What is the correct way to create a Write variant holding a string "hello"?

A Message.Write("hello")

B Message::Write("hello")

C Message::Write { "hello" }

D Message.Write { "hello" }

You create data-holding variants by calling them like functions: Message::Write("hello").

Why use enum variants instead of separate structs?

A To group related types under one name

B To avoid using functions

C To make code slower

D To prevent any data from being stored

Enum variants group related but different data types under one type, making code clearer and safer.

Explain what enum variants are and how they can hold data in Rust.

Think about how an enum can represent different states or messages.

Describe how to create and use an enum variant instance with data in Rust.

Remember how you call a variant to create a value.

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