Enum variants in Rust - Mini Project: Build & Apply

Working with Enum Variants in Rust

📖 Scenario: Imagine you are building a simple program to represent different types of messages in a chat app. Each message can be a text, an image, or a video.

🎯 Goal: You will create an enum called Message with variants for Text, Image, and Video. Then you will write code to create a message and print its type.

📋 What You'll Learn

Create an enum called Message with variants Text, Image, and Video

Create a variable called msg and assign it the Text variant with the value "Hello!"

Use a match expression on msg to print the type of message

Print the message type exactly as "This is a text message.", "This is an image message.", or "This is a video message."

💡 Why This Matters

🌍 Real World

Enums are used to represent different types of data that belong to one category, like different message types in chat apps.

💼 Career

Understanding enums and pattern matching is essential for Rust programming jobs, especially in system programming, web backend, and game development.

1

Create the enum Message with variants

Create an enum called Message with three variants: Text, Image, and Video. Each variant should hold a String value.

Rust

# Your code here

Hint

Use enum Message { Text(String), Image(String), Video(String) } to define the enum.

2

Create a variable msg with the Text variant

Create a variable called msg and assign it the Text variant of Message with the value "Hello!".

Rust

enum Message {
    Text(String),
    Image(String),
    Video(String),
}

# Your code here

Hint

Use let msg = Message::Text(String::from("Hello!")); to create the variable.

3

Use match to check the variant of msg

Use a match expression on msg with variable m to match each variant: Text, Image, and Video. For each case, print the message type as a string (do not print the inner string).

Rust

enum Message {
    Text(String),
    Image(String),
    Video(String),
}

let msg = Message::Text(String::from("Hello!"));

# Your code here

Hint

Use match msg { Message::Text(m) => ..., Message::Image(m) => ..., Message::Video(m) => ... }.

4

Print the message type

Run the program to print the message type for the msg variable. The output should be exactly This is a text message.

Rust

enum Message {
    Text(String),
    Image(String),
    Video(String),
}

let msg = Message::Text(String::from("Hello!"));

match msg {
    Message::Text(m) => println!("This is a text message."),
    Message::Image(m) => println!("This is an image message."),
    Message::Video(m) => println!("This is a video message."),
}

# Your code here

Hint

Make sure you run the program inside a fn main() function.

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