Enums

Enums define a type that is one of several variants. Variants can hold data, making enums ideal for state machines and error models.

Recipe

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
}
 
fn handle(msg: Message) {
    match msg {
        Message::Quit => println!("quit"),
        Message::Move { x, y } => println!("move {x},{y}"),
        Message::Write(text) => println!("{text}"),
    }
}
 
fn main() {
    handle(Message::Write("hi".into()));
}

When to reach for this: Modeling mutually exclusive states, errors, commands, and AST nodes.

Working Example

enum Traffic {
    Red,
    Yellow,
    Green,
}
 
impl Traffic {
    fn next(self) -> Self {
        match self {
            Traffic::Red => Traffic::Green,
            Traffic::Green => Traffic::Yellow,
            Traffic::Yellow => Traffic::Red,
        }
    }
}
 
fn main() {
    let t = Traffic::Red.next();
    println!("{:?}", std::mem::discriminant(&t));
}

What this demonstrates:

• Unit variants like C enums
• Methods on enums via impl
• Consuming self in next for state transition API
• match for exhaustive handling

Deep Dive

Variant Forms

enum E {
    Unit,
    Tuple(i32, String),
    Struct { id: u64 },
}

Memory Layout

Rust optimizes niche enums (e.g. Option<&T> same size as &T). Not all enums are same size as largest variant due to optimizations.

Option and Result

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

See dedicated page for idiomatic use.

Gotchas

• Non-exhaustive match - New variant breaks downstream. Fix: Treat as API semver event; use #[non_exhaustive] for extensibility.
• Large variant bloat - Enum size is at least largest variant (before optimization). Fix: Box large payload: Large(Box<Data>).
• Boolean enum smell - enum Flag { Yes, No } worse than bool unless more states coming. Fix: Use bool until variants multiply.
• Derive Eq on float payload - Not available. Fix: Use integer representation or avoid Eq.
• Public enum with internal invariants - Callers construct invalid combos. Fix: Private fields with constructors validating state.

Alternatives

FAQs

Related

• Pattern Matching with match - match depth
• Option & Result as Enums - core enums
• Enums for State Machines - transitions
• Deriving Traits - #[derive(...)]

Stack versions: This page was written for Rust 1.97.0 (edition 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, and Polars 0.46+.