Enums Exercises

Overview

These exercises introduce Rust’s powerful enum type — far more capable than enums in most languages.

enums1 - Basic Enum Definition

Concept: Defining an enum with variants

#[derive(Debug)]
enum Message {
    Resize,
    Move,
    Echo,
    ChangeColor,
    Quit,
}
 
fn main() {
    println!("{:?}", Message::Resize);
    println!("{:?}", Message::Move);
}

Key Takeaways:

Enums define a type by enumerating its possible variants
Access variants with EnumName::VariantName
#[derive(Debug)] allows printing with {:?}

enums2 - Enums with Data

Concept: Variants can hold different types of data

#[derive(Debug)]
struct Point { x: u64, y: u64 }
 
#[derive(Debug)]
enum Message {
    Resize { width: u64, height: u64 },  // Struct-like variant
    Move(Point),                          // Tuple-like with struct
    Echo(String),                         // Tuple-like with String
    ChangeColor(u8, u8, u8),              // Tuple-like with multiple values
    Quit,                                 // Unit variant (no data)
}
 
impl Message {
    fn call(&self) {
        println!("{self:?}");
    }
}

Variant Types:

Syntax	Name	Example
`Variant { field: Type }`	Struct-like	`Resize { width: 10, height: 30 }`
`Variant(Type)`	Tuple-like	`Move(Point { x: 10, y: 15 })`
`Variant(T1, T2)`	Multi-value tuple	`ChangeColor(200, 255, 255)`
`Variant`	Unit	`Quit`

Usage example:

let messages = [
    Message::Resize { width: 10, height: 30 },
    Message::Move(Point { x: 10, y: 15 }),
    Message::Echo(String::from("hello world")),
    Message::ChangeColor(200, 255, 255),
    Message::Quit,
];
 
for message in &messages {
    message.call();
}

Why Enums Are Powerful

Unlike C enums (just integers), Rust enums can:

Hold different data in each variant
Implement methods
Be used with pattern matching (coming soon!)

🔮 Preview: match expressions let you handle each variant differently. You’ll learn this in the next set of exercises!

Common Standard Library Enums

enum Option<T> {
    Some(T),
    None,
}
 
enum Result<T, E> {
    Ok(T),
    Err(E),
}

These are everywhere in Rust!

enums3 - Pattern Matching with `match`

Concept: Using match to handle enum variants and destructure their data

The Full Code

struct Point {
    x: u64,
    y: u64,
}
 
enum Message {
    Resize { width: u64, height: u64 },
    Move(Point),
    Echo(String),
    ChangeColor(u8, u8, u8),
    Quit,
}
 
struct State {
    width: u64,
    height: u64,
    position: Point,
    message: String,
    color: (u8, u8, u8),
    quit: bool,
}
 
impl State {
    fn resize(&mut self, width: u64, height: u64) {
        self.width = width;
        self.height = height;
    }
 
    fn move_position(&mut self, point: Point) {
        self.position = point;
    }
 
    fn echo(&mut self, s: String) {
        self.message = s;
    }
 
    fn change_color(&mut self, red: u8, green: u8, blue: u8) {
        self.color = (red, green, blue);
    }
 
    fn quit(&mut self) {
        self.quit = true;
    }
 
    fn process(&mut self, message: Message) {
        match message {
            Message::Resize { width, height } => self.resize(width, height),
            Message::Move(point) => self.move_position(point),
            Message::Echo(string) => self.echo(string),
            Message::ChangeColor(red, green, blue) => self.change_color(red, green, blue),
            Message::Quit => self.quit(),
        }
    }
}

Where is Destructuring Happening?

Destructuring happens in the match arm patterns (the left side of =>):

match message {
    Message::Resize { width, height } => ...
    //              ^^^^^^^^^^^^^^^^
    //              DESTRUCTURING! Extracts `width` and `height` from the variant
    
    Message::Move(point) => ...
    //           ^^^^^^^
    //           DESTRUCTURING! Extracts the Point into `point`
    
    Message::ChangeColor(red, green, blue) => ...
    //                  ^^^^^^^^^^^^^^^^^
    //                  DESTRUCTURING! Extracts all 3 u8 values
    
    Message::Quit => ...
    //            No data to destructure (unit variant)
}

Destructuring = extracting inner values from a data structure into named variables.

Step-by-Step Code Walkthrough

Step 1: Create Initial State

let mut state = State {
    width: 0,
    height: 0,
    position: Point { x: 0, y: 0 },
    message: String::from("hello world"),
    color: (0, 0, 0),
    quit: false,
};

State starts with default values. It’s mut because process() will modify it.