Enums with Data

Part of the Object Oriented Programming section of Coddy's Rust journey — lesson 14 of 61.

Basic enums in Rust let you define a type with a fixed set of variants—like Direction::North or Status::Active. But Rust enums are far more powerful than that. Each variant can carry its own data, making enums incredibly flexible for modeling real-world scenarios.

Consider a messaging system where different message types carry different information. A text message has content, a move command has coordinates, and a quit signal has nothing at all. In Rust, you can represent all of these with a single enum:

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

Each variant has a different shape. Quit holds no data—it's just a signal.

Move uses struct-like syntax with named fields. Write holds a single String using tuple syntax. ChangeColor holds three values representing RGB components.

Creating instances of these variants looks like this:

let m1 = Message::Quit;
let m2 = Message::Move { x: 10, y: 20 };
let m3 = Message::Write(String::from("Hello"));
let m4 = Message::ChangeColor(255, 128, 0);

The beauty of this approach is that m1, m2, m3, and m4 are all the same type: Message. You can store them in the same collection, pass them to the same function, or return any variant from a single function. The enum unifies different data shapes under one type while preserving the specific information each variant needs.

Challenge

Easy

Let's build a notification system that uses enums with data to represent different types of alerts. Each notification type carries different information—some have messages, some have numeric values, and some are simple signals.

You'll create two files to organize your code:

notification.rs: Define a public Notification enum with three variants:
- Alert — holds a single String message (tuple syntax)
- Reminder — holds named fields: title (String) and minutes (u32)
- Dismiss — holds no data, just a signal
main.rs: Bring in your notification module and create one instance of each variant. Then print information about each notification to demonstrate that all three variants are the same type but carry different data.

When printing, use debug formatting ({:?}) to display each notification. You'll need to derive the Debug trait on your enum so it can be printed this way.

Your output should show all three notifications, each on its own line:

Alert("{message}")
Reminder { title: "{title}", minutes: {minutes} }
Dismiss

For example, with an alert message of "Server down", a reminder with title "Meeting" and 30 minutes, the output would be:

Alert("Server down")
Reminder { title: "Meeting", minutes: 30 }
Dismiss

You will receive three inputs: the alert message, the reminder title, and the reminder minutes.

Cheat sheet

Enum variants in Rust can carry different types of data, making them powerful for modeling diverse scenarios under a single type.

Defining Enums with Data

Each variant can have its own data structure:

enum Message {
    Quit,                          // No data
    Move { x: i32, y: i32 },      // Named fields (struct-like)
    Write(String),                 // Single value (tuple syntax)
    ChangeColor(u8, u8, u8),      // Multiple values (tuple syntax)
}

Creating Enum Instances

let m1 = Message::Quit;
let m2 = Message::Move { x: 10, y: 20 };
let m3 = Message::Write(String::from("Hello"));
let m4 = Message::ChangeColor(255, 128, 0);

All instances are the same type (Message) despite carrying different data, allowing them to be stored in collections, passed to functions, or returned from functions uniformly.

Debug Trait

To print enums using {:?} formatting, derive the Debug trait:

#[derive(Debug)]
enum Message {
    // variants...
}

Try it yourself

mod notification;

use notification::Notification;

fn main() {
    // Read inputs
    let mut alert_message = String::new();
    std::io::stdin().read_line(&mut alert_message).expect("Failed to read line");
    let alert_message = alert_message.trim().to_string();

    let mut reminder_title = String::new();
    std::io::stdin().read_line(&mut reminder_title).expect("Failed to read line");
    let reminder_title = reminder_title.trim().to_string();

    let mut minutes_input = String::new();
    std::io::stdin().read_line(&mut minutes_input).expect("Failed to read line");
    let reminder_minutes: u32 = minutes_input.trim().parse().expect("Failed to parse minutes");

    // TODO: Create an Alert notification using the alert_message

    // TODO: Create a Reminder notification using reminder_title and reminder_minutes

    // TODO: Create a Dismiss notification

    // TODO: Print each notification using debug formatting {:?}
    // Each notification should be printed on its own line
}