Pular para o conteúdo
Rust em Português

Lição 12 de 18 · 25 min

Enums e match

Modele valores que podem ser uma coisa ou outra, como formas de pagamento, e trate cada caso com match, if let e let else.

Ao terminar, você vai saber:

  • Definir um enum com variantes que carregam dados
  • Tratar todas as variantes com match e entender a exigência de cobrir tudo
  • Usar o curinga _ para agrupar os casos restantes
  • Simplificar casos únicos com if let e let else

Uma struct junta várias informações que existem ao mesmo tempo: nome e CPF e saldo. Um enum descreve um valor que é uma coisa ou outra: o pagamento foi por Pix ou cartão ou boleto. Nunca dois ao mesmo tempo.

O enum mais simples

#[derive(Debug)]
enum Turno {
    Manha,
    Tarde,
    Noite,
}

fn main() {
    let turno = Turno::Tarde;
    println!("Aula no turno: {:?}", turno);
}

Cada opção se chama variante. Você acessa com NomeDoEnum::Variante. Uma variável do tipo Turno só pode valer uma das três, e o compilador garante isso.

Variantes que carregam dados

O que faz o enum do Rust ser tão útil é que cada variante pode guardar dados próprios, de tipos diferentes. Veja um pagamento numa loja:

#[derive(Debug)]
enum Pagamento {
    Pix { chave: String },
    Cartao { parcelas: u8 },
    Boleto { vencimento: String },
    Dinheiro,
}

fn main() {
    let pagamentos = [
        Pagamento::Pix { chave: String::from("loja@exemplo.com.br") },
        Pagamento::Cartao { parcelas: 3 },
        Pagamento::Boleto { vencimento: String::from("25/11/2026") },
        Pagamento::Dinheiro,
    ];

    for p in &pagamentos {
        println!("{:?}", p);
    }
}

O Pix tem uma chave. O cartão tem o número de parcelas. O boleto tem um vencimento. O dinheiro não precisa de nada. Tudo isso é um tipo só: Pagamento. Por isso cabe no mesmo array.

As variantes também podem ter dados sem nome, no estilo tupla: Cartao(u8). Escolha o que deixar o código mais claro.

match: um braço para cada caso

Para saber qual variante você tem e pegar os dados dela, use match.

enum Pagamento {
    Pix { chave: String },
    Cartao { parcelas: u8 },
    Boleto { vencimento: String },
    Dinheiro,
}

fn descrever(pagamento: &Pagamento, valor: f64) -> String {
    match pagamento {
        Pagamento::Pix { chave } => {
            format!("Pix de R$ {valor:.2} para {chave}")
        }
        Pagamento::Cartao { parcelas } => {
            let parcela = valor / *parcelas as f64;
            format!("Cartão em {parcelas}x de R$ {parcela:.2}")
        }
        Pagamento::Boleto { vencimento } => {
            format!("Boleto de R$ {valor:.2}, vence em {vencimento}")
        }
        Pagamento::Dinheiro => format!("R$ {valor:.2} em dinheiro"),
    }
}

fn main() {
    let compra = Pagamento::Cartao { parcelas: 4 };
    println!("{}", descrever(&compra, 600.0));

    let outra = Pagamento::Pix { chave: String::from("123.456.789-09") };
    println!("{}", descrever(&outra, 89.90));
}

Cada linha do tipo padrão => código é um braço. O Rust testa os braços de cima para baixo e executa o primeiro que casar. Ao casar, os dados da variante viram variáveis: em Pagamento::Cartao { parcelas }, o nome parcelas passa a valer o número de parcelas daquela compra.

Como recebemos &Pagamento, os dados chegam como referência. Por isso aparece *parcelas na conta: o asterisco pega o número de dentro da referência.

E o match é uma expressão. Ele devolve um valor, e aqui esse valor é o retorno da função.

O match exige cobrir tudo

Esqueça um caso e veja:

enum Pagamento {
    Pix { chave: String },
    Cartao { parcelas: u8 },
    Boleto { vencimento: String },
    Dinheiro,
}

fn taxa(pagamento: &Pagamento) -> f64 {
    match pagamento {
        Pagamento::Pix { .. } => 0.0,
        Pagamento::Cartao { .. } => 0.035,
        Pagamento::Dinheiro => 0.0,
    }
}
error[E0004]: non-exhaustive patterns: `&Pagamento::Boleto { .. }` not covered
  |     match pagamento {
  |           ^^^^^^^^^ pattern `&Pagamento::Boleto { .. }` not covered
  = note: the matched value is of type `&Pagamento`

O compilador diz exatamente qual variante faltou. Isso vale ouro quando o sistema cresce. Se amanhã alguém criar Pagamento::Cripto, todo match que não trata esse caso vira erro de compilação. Você não esquece nenhum lugar.

O { .. } no padrão quer dizer “não me interessam os dados desta variante”.

O curinga _

Quando vários casos têm a mesma resposta, use _ no último braço. Ele casa com qualquer coisa.

enum Pagamento {
    Pix { chave: String },
    Cartao { parcelas: u8 },
    Boleto { vencimento: String },
    Dinheiro,
}

fn taxa(pagamento: &Pagamento) -> f64 {
    match pagamento {
        Pagamento::Cartao { parcelas: 1 } => 0.02,
        Pagamento::Cartao { .. } => 0.035,
        _ => 0.0, // Pix, boleto e dinheiro: sem taxa
    }
}

fn main() {
    let a_vista = Pagamento::Cartao { parcelas: 1 };
    let parcelado = Pagamento::Cartao { parcelas: 6 };
    println!("Taxa à vista: {}", taxa(&a_vista));
    println!("Taxa parcelado: {}", taxa(&parcelado));
    println!("Taxa no dinheiro: {}", taxa(&Pagamento::Dinheiro));
}

Repare no primeiro braço: parcelas: 1 casa só quando o valor é exatamente 1. Padrões podem testar valores, não só a variante.

Use o curinga com moderação. Ele também engole variantes novas, e aí o compilador não avisa mais.

match funciona com outros tipos também, como números:

fn conceito(nota: u8) -> &'static str {
    match nota {
        9 | 10 => "Ótimo",
        7..=8 => "Bom",
        5..=6 => "Regular",
        _ => "Precisa melhorar",
    }
}

fn main() {
    for nota in [10, 7, 5, 3] {
        println!("{nota}: {}", conceito(nota));
    }
}

O | quer dizer “ou”, e 7..=8 é um range que inclui o 8. O tipo de retorno &'static str indica um texto literal, que vive enquanto o programa rodar.

if let: quando só um caso interessa

Às vezes você só quer fazer algo se for Pix, e ignorar o resto. Um match com _ => {} funciona, mas é longo. O if let encurta:

enum Pagamento {
    Pix { chave: String },
    Dinheiro,
}

fn main() {
    let pagamentos = [
        Pagamento::Dinheiro,
        Pagamento::Pix { chave: String::from("(11) 98765-4321") },
    ];

    for p in &pagamentos {
        if let Pagamento::Pix { chave } = p {
            println!("Gerar QR Code para a chave {chave}");
        } else {
            println!("Não é Pix, nada a fazer");
        }
    }
}

Leia assim: “se p casar com o padrão Pix, pegue a chave e rode o bloco”. O else é opcional.

let else: sair cedo quando não casa

O let else é o contrário: você espera um caso específico e, se não vier, sai da função logo. O valor fica disponível no resto do código, sem mais um nível de chaves.

enum Pagamento {
    Boleto { vencimento: String },
    Dinheiro,
}

fn lembrete(pagamento: &Pagamento) -> String {
    let Pagamento::Boleto { vencimento } = pagamento else {
        return String::from("Sem boleto para lembrar");
    };

    // daqui para baixo, `vencimento` existe
    format!("Seu boleto vence em {vencimento}")
}

fn main() {
    println!("{}", lembrete(&Pagamento::Boleto { vencimento: String::from("10/12/2026") }));
    println!("{}", lembrete(&Pagamento::Dinheiro));
}

O bloco do else precisa sair dali: return, break, continue ou um panic!. O compilador confere.

Você vai ver muito if let e let else com o Option, assunto da próxima lição, Option e Result.

Resumo

  • Enum é um tipo que vale uma entre várias variantes.
  • Cada variante pode carregar dados próprios, com nome ou no estilo tupla.
  • match testa os braços em ordem e extrai os dados da variante.
  • O match precisa cobrir todos os casos, e o compilador avisa o que faltou.
  • _ casa com qualquer coisa; use no fim e com moderação.
  • if let trata um caso só; let else sai cedo quando o caso esperado não vem.

Desafio

Crie um enum StatusPedido com as variantes Recebido, EmPreparo { minutos_restantes: u32 }, SaiuParaEntrega { entregador: String } e Entregue. Escreva uma função mensagem(status: &StatusPedido) -> String usando match, e uma função tem_previsao(status: &StatusPedido) -> bool usando if let.

Ver uma resposta
enum StatusPedido {
    Recebido,
    EmPreparo { minutos_restantes: u32 },
    SaiuParaEntrega { entregador: String },
    Entregue,
}

fn mensagem(status: &StatusPedido) -> String {
    match status {
        StatusPedido::Recebido => String::from("Recebemos seu pedido"),
        StatusPedido::EmPreparo { minutos_restantes } => {
            format!("Em preparo, faltam {minutos_restantes} min")
        }
        StatusPedido::SaiuParaEntrega { entregador } => {
            format!("{entregador} está a caminho")
        }
        StatusPedido::Entregue => String::from("Pedido entregue. Bom apetite!"),
    }
}

fn tem_previsao(status: &StatusPedido) -> bool {
    if let StatusPedido::EmPreparo { .. } = status {
        true
    } else {
        false
    }
}

fn main() {
    let etapas = [
        StatusPedido::Recebido,
        StatusPedido::EmPreparo { minutos_restantes: 15 },
        StatusPedido::SaiuParaEntrega { entregador: String::from("Paulo") },
        StatusPedido::Entregue,
    ];

    for etapa in &etapas {
        println!("{} (previsão: {})", mensagem(etapa), tem_previsao(etapa));
    }
}
Salvo só neste navegador.