Fácil Rust

Identificando variantes com match

Enunciado

Crie um enum Cor com as variantes Vermelho, Verde e Azul. Depois, escreva uma função descrever(cor: &Cor) -> &str que retorne uma string descrevendo a cor. Use match para tratar todas as variantes.

Requisitos

  • Definir o enum Cor com exatamente três variantes.
  • A função descrever deve usar match e retornar &str.
  • O match deve cobrir todas as variantes (exaustivo).
  • A saída deve mostrar as descrições corretas para cada cor.

Código inicial

enum Cor {
    Vermelho,
    Verde,
    Azul,
}

fn descrever(cor: &Cor) -> &str {
    // Complete com match
    todo!()
}

fn main() {
    let c1 = Cor::Vermelho;
    let c2 = Cor::Verde;
    let c3 = Cor::Azul;
    println!("{}", descrever(&c1));
    println!("{}", descrever(&c2));
    println!("{}", descrever(&c3));
}

Saída esperada

Vermelho
Verde
Azul
Ver dica

Dentro do match, cada braço pode retornar diretamente uma string literal. Lembre-se de que &Cor precisa ser desestruturado com & nos padrões ou usar *cor.

Mostrar solução 
enum Cor {
    Vermelho,
    Verde,
    Azul,
}

fn descrever(cor: &Cor) -> &str {
    match cor {
        Cor::Vermelho => "Vermelho",
        Cor::Verde => "Verde",
        Cor::Azul => "Azul",
    }
}

fn main() {
    let c1 = Cor::Vermelho;
    let c2 = Cor::Verde;
    let c3 = Cor::Azul;
    println!("{}", descrever(&c1));
    println!("{}", descrever(&c2));
    println!("{}", descrever(&c3));
}

Passo a passo

  1. Definimos o enum Cor com três variantes sem dados associados.
  2. A função descrever recebe uma referência &Cor e usa match para comparar o valor.
  3. Cada braço do match corresponde a uma variante e retorna uma string estática (&str).
  4. Como o enum tem apenas três variantes, o match é exaustivo sem precisar de _.
  5. No main, criamos instâncias de cada variante e chamamos descrever passando referências.
  6. A saída imprime a descrição de cada cor.

Por que funciona

O match verifica qual variante está ativa e executa o braço correspondente. Como todas as variantes são cobertas, o compilador não reclama de exaustividade. O retorno &str é possível porque as strings literais têm tempo de vida estático.

Erros comuns

  • Esquecer uma variante: o compilador emitirá erro non-exhaustive patterns. Solução: adicionar o braço faltante ou usar _.
  • Tentar usar cor diretamente no match sem referência: se a função recebe &Cor, os padrões devem ser Cor::Variante (o Rust faz auto-deref) ou &Cor::Variante. O código acima funciona porque o match em &Cor aceita padrões sem & devido ao match ergonomics.
  • Retornar String em vez de &str: se retornar String, o tipo de retorno deve ser String, mas o enunciado pede &str.

Outra forma de resolver

Usar if let encadeado, mas seria menos idiomático e não exaustivo. O match é a escolha natural.

Saída esperada

Vermelho
Verde
Azul