Defining enums in Rust - Mini Project: Build & Apply

Defining enums

📖 Scenario: You are creating a simple program to represent different types of fruits using Rust enums. This helps organize related values under one type.

🎯 Goal: Build a Rust program that defines an enum called Fruit with specific fruit variants, then use it in a variable and print a message based on the fruit.

📋 What You'll Learn

Define an enum named Fruit with variants Apple, Banana, and Cherry

Create a variable named my_fruit and assign it the Fruit::Banana variant

Use a match expression on my_fruit to print a message for each fruit variant

💡 Why This Matters

🌍 Real World

Enums are used in many programs to represent fixed sets of options, like states, commands, or categories.

💼 Career

Understanding enums is important for Rust programming jobs, especially in system programming, game development, and backend services.

1

Define the enum Fruit

Write a Rust enum named Fruit with variants Apple, Banana, and Cherry.

Rust

# Your code here

Hint

An enum groups related values. Use enum Fruit { Apple, Banana, Cherry }.

2

Create a variable with a Fruit variant

Create a variable named my_fruit and assign it the Fruit::Banana variant.

Rust

enum Fruit {
    Apple,
    Banana,
    Cherry,
}

# Your code here

Hint

Use let my_fruit = Fruit::Banana; to create the variable.

3

Use match to handle the Fruit variants

Write a match expression on my_fruit that prints "It's an apple!" for Fruit::Apple, "It's a banana!" for Fruit::Banana, and "It's a cherry!" for Fruit::Cherry.

Rust

enum Fruit {
    Apple,
    Banana,
    Cherry,
}

let my_fruit = Fruit::Banana;

# Your code here

Hint

Use match my_fruit { Fruit::Apple => println!("It's an apple!"), ... }.

4

Print the message for the selected fruit

Run the program so it prints the message for my_fruit. Use println! inside the match as before.

Rust

enum Fruit {
    Apple,
    Banana,
    Cherry,
}

let my_fruit = Fruit::Banana;

match my_fruit {
    Fruit::Apple => println!("It's an apple!"),
    Fruit::Banana => println!("It's a banana!"),
    Fruit::Cherry => println!("It's a cherry!"),
}

# Run the program to see the output

Hint

Wrap your code in fn main() { ... } and run it to see the message.

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