Defining enums in Rust

Introduction

Enums let you group related values under one name. They help organize choices or states clearly.

When you want to list a few fixed options, like days of the week.

When you need to represent different states, like a traffic light color.

When you want to handle different types of messages in a program.

When you want to make your code easier to read and less error-prone.

Syntax

Rust

enum Name {
    Variant1,
    Variant2,
    Variant3
}

Each variant is a possible value of the enum.

Variants are written in CamelCase by convention.

Examples

This enum lists four directions you can use in your program.

Rust

enum Direction {
    North,
    East,
    South,
    West
}

This enum represents the colors of a traffic light.

Rust

enum TrafficLight {
    Red,
    Yellow,
    Green
}

This enum shows how variants can hold extra data.

Rust

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

Sample Program

This program defines an enum for directions and prints a message based on the chosen direction.

Rust

enum Direction {
    North,
    East,
    South,
    West
}

fn print_direction(dir: Direction) {
    match dir {
        Direction::North => println!("Going North"),
        Direction::East => println!("Going East"),
        Direction::South => println!("Going South"),
        Direction::West => println!("Going West"),
    }
}

fn main() {
    let dir = Direction::East;
    print_direction(dir);
}

Important Notes

You use :: to access enum variants.

Enums can have variants with or without extra data.

Using match helps handle all enum variants safely.

Summary

Enums group related values under one name.

Variants can be simple or hold extra data.

Use match to work with enum values clearly.

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