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.
matchtesta os braços em ordem e extrai os dados da variante.- O
matchprecisa cobrir todos os casos, e o compilador avisa o que faltou. _casa com qualquer coisa; use no fim e com moderação.if lettrata um caso só;let elsesai 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));
}
}