Enums

Enums definem um tipo que é uma de várias variantes. As variantes podem conter dados, tornando os enums ideais para máquinas de estado e modelos de erro.

Receita

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()));
}

Quando usar isso: Modelar estados mutuamente exclusivos, erros, comandos e nós AST.

Exemplo em Funcionamento

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));
}

O que isso demonstra:

• Variantes de unidade como enums C
• Métodos em enums via impl
• Consumindo self em next para API de transição de estado
• match para tratamento exaustivo

Mergulho Profundo

Formas de Variantes

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

Layout de Memória

Rust otimiza enums de nicho (por exemplo, Option<&T> tem o mesmo tamanho que &T). Nem todos os enums têm o mesmo tamanho da maior variante devido a otimizações.

Option e Result

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

Veja a página dedicada para uso idiomático.

Armadilhas

• match não exaustivo - Nova variante quebra o código downstream. Correção: Trate como um evento de semântica de API; use #[non_exhaustive] para extensibilidade.
• Inchaço de variante grande - O tamanho do enum é pelo menos o da maior variante (antes da otimização). Correção: Use Box para payload grande: Large(Box<Data>).
• Cheiro de enum booleano - enum Flag { Yes, No } é pior que bool a menos que mais estados estejam por vir. Correção: Use bool até que as variantes se multipliquem.
• Derivar Eq em payload float - Não disponível. Correção: Use representação inteira ou evite Eq.
• Enum público com invariantes internas - Chamadores constroem combinações inválidas. Correção: Campos privados com construtores que validam o estado.

Alternativas

FAQs

Relacionados

• Pattern Matching com match - Profundidade do match
• Option & Result como Enums - enums principais
• Enums para Máquinas de Estado - transições
• Derivando Traits - #[derive(...)]

Versões da Pilha: Esta página foi escrita para Rust 1.97.0 (edição 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, e Polars 0.46+.