Enums e Option

Um enum define um tipo que pode ser uma entre várias variantes. É muito usado junto com match para tratar cada caso.

Definir um enum

enum Direcao {
    Norte,
    Sul,
    Leste,
    Oeste,
}

fn main() {
    let d = Direcao::Norte;
    mover(d);
}

fn mover(d: Direcao) {
    match d {
        Direcao::Norte => println!("Subindo"),
        Direcao::Sul => println!("Descendo"),
        Direcao::Leste => println!("Direita"),
        Direcao::Oeste => println!("Esquerda"),
    }
}

Variantes com dados

Cada variante pode carregar dados.

enum Mensagem {
    Sair,
    Mover { x: i32, y: i32 },
    Escrever(String),
}

fn processar(m: Mensagem) {
    match m {
        Mensagem::Sair => println!("Saindo"),
        Mensagem::Mover { x, y } => println!("Mover ({}, {})", x, y),
        Mensagem::Escrever(texto) => println!("{}", texto),
    }
}

fn main() {
    processar(Mensagem::Escrever(String::from("oi")));
}

Option

Rust não tem null. Para representar “pode existir ou não” usa-se Option, que é Some(valor) ou None.

fn main() {
    let nota: Option<i32> = Some(8);
    let vazio: Option<i32> = None;

    match nota {
        Some(n) => println!("Nota: {}", n),
        None => println!("Sem nota"),
    }

    // valor padrão se for None
    println!("{}", vazio.unwrap_or(0));
}

O compilador obriga você a tratar o caso None, evitando erros de valor nulo.