Pular para o conteúdo
Rust em Português

Lição 15 de 18 · 35 min

Traits e genéricos

Defina comportamentos comuns com traits, escreva funções que servem para vários tipos com genéricos e dê os primeiros passos com closures e iteradores.

Ao terminar, você vai saber:

  • Definir uma trait e implementá-la para seus tipos
  • Escrever funções que aceitam qualquer tipo que implemente uma trait
  • Usar genéricos com trait bounds
  • Derivar Debug, Clone e PartialEq e implementar Display
  • Transformar listas com closures, map, filter e collect

Imagine uma loja que vende produtos e serviços. São coisas bem diferentes: um produto tem estoque, um serviço tem duração. Mas os dois têm um preço e aparecem na nota fiscal. Como escrever uma função imprimir_na_nota que aceite os dois?

A resposta do Rust é a trait: um conjunto de métodos que um tipo promete ter. Se você já viu “interface” em outra linguagem, a ideia é parecida.

Definindo e implementando uma trait

trait Cobravel {
    fn preco(&self) -> f64;
    fn descricao(&self) -> String;
}

struct Produto {
    nome: String,
    preco_unitario: f64,
    quantidade: u32,
}

struct Servico {
    nome: String,
    horas: f64,
    valor_hora: f64,
}

impl Cobravel for Produto {
    fn preco(&self) -> f64 {
        self.preco_unitario * self.quantidade as f64
    }

    fn descricao(&self) -> String {
        format!("{} x{}", self.nome, self.quantidade)
    }
}

impl Cobravel for Servico {
    fn preco(&self) -> f64 {
        self.horas * self.valor_hora
    }

    fn descricao(&self) -> String {
        format!("{} ({}h)", self.nome, self.horas)
    }
}

fn main() {
    let pao = Produto { nome: String::from("Pão de queijo"), preco_unitario: 4.0, quantidade: 3 };
    let corte = Servico { nome: String::from("Corte de cabelo"), horas: 0.5, valor_hora: 80.0 };

    println!("{}: R$ {:.2}", pao.descricao(), pao.preco());
    println!("{}: R$ {:.2}", corte.descricao(), corte.preco());
}

A trait só lista as assinaturas. Cada tipo escreve sua própria versão com impl Cobravel for Tipo. Se faltar algum método, o compilador reclama.

Método padrão

Uma trait pode trazer métodos já prontos. Quem implementa ganha esse método de graça e pode trocar se quiser.

trait Cobravel {
    fn preco(&self) -> f64;

    // Método padrão: usa o preco() de cada tipo
    fn linha_da_nota(&self) -> String {
        format!("R$ {:.2}", self.preco())
    }
}

struct Taxa(f64);

impl Cobravel for Taxa {
    fn preco(&self) -> f64 {
        self.0
    }
    // linha_da_nota veio de graça
}

fn main() {
    let entrega = Taxa(7.0);
    println!("Entrega: {}", entrega.linha_da_nota());
}

impl Trait em parâmetro

Agora a função da nota fiscal. O parâmetro item: &impl Cobravel quer dizer: “aceito uma referência para qualquer tipo que implemente Cobravel”.

trait Cobravel {
    fn preco(&self) -> f64;
}

struct Produto(f64);
struct Servico(f64);

impl Cobravel for Produto {
    fn preco(&self) -> f64 {
        self.0
    }
}

impl Cobravel for Servico {
    fn preco(&self) -> f64 {
        self.0 * 1.05 // 5% de imposto sobre serviço
    }
}

fn imprimir_na_nota(item: &impl Cobravel) {
    println!("Item: R$ {:.2}", item.preco());
}

fn main() {
    imprimir_na_nota(&Produto(10.0));
    imprimir_na_nota(&Servico(100.0));
}

A função não sabe se recebeu produto ou serviço, e nem precisa. Ela só usa o que a trait garante.

Genéricos com

Um genérico é um tipo que fica em aberto e é escolhido na hora do uso. Você já viu Vec<T> e Option<T>. Dá para escrever suas próprias funções assim:

fn primeiro<T>(lista: &[T]) -> Option<&T> {
    lista.first()
}

fn main() {
    let notas = [8.5, 7.0];
    let cidades = ["Recife", "Curitiba"];

    println!("{:?}", primeiro(&notas));
    println!("{:?}", primeiro(&cidades));
}

O <T> depois do nome declara o parâmetro de tipo. O compilador gera uma versão para cada tipo usado, então não há custo extra na execução.

Trait bounds: genérico com exigência

Agora tente achar o maior item de uma lista genérica:

fn maior<T>(lista: &[T]) -> &T {
    let mut maior = &lista[0];
    for item in lista {
        if item > maior {
            maior = item;
        }
    }
    maior
}
error[E0369]: binary operation `>` cannot be applied to type `&T`
  |         if item > maior {
  |            ---- ^ ----- &T
help: consider restricting type parameter `T` with trait `PartialOrd`
  | fn maior<T: std::cmp::PartialOrd>(lista: &[T]) -> &T {

T pode ser qualquer coisa, inclusive algo que não dá para comparar. A mensagem já sugere a correção: exigir que T implemente PartialOrd, a trait de “pode ser comparado com < e >”. Essa exigência se chama trait bound.

fn maior<T: PartialOrd>(lista: &[T]) -> &T {
    let mut maior = &lista[0];
    for item in lista {
        if item > maior {
            maior = item;
        }
    }
    maior
}

fn main() {
    println!("{}", maior(&[3, 9, 4]));
    println!("{}", maior(&[6.5, 9.5, 7.0]));
    println!("{}", maior(&["banana", "abacaxi", "caju"]));
}

Na verdade, item: &impl Cobravel é um atalho para fn f<T: Cobravel>(item: &T). São a mesma coisa. Com várias exigências, use + (T: PartialOrd + Clone) ou uma cláusula where no fim da assinatura.

Derive: traits de graça

Algumas traits são tão comuns que o compilador sabe escrevê-las sozinho. Você já usou #[derive(Debug)]. Outras que você vai ver toda hora:

#[derive(Debug, Clone, PartialEq)]
struct Endereco {
    rua: String,
    cep: String,
}

fn main() {
    let casa = Endereco { rua: String::from("Rua das Flores, 10"), cep: String::from("01001-000") };

    let copia = casa.clone(); // Clone: cópia completa, com Strings novas
    println!("Iguais? {}", casa == copia); // PartialEq: permite ==

    println!("{:?}", copia); // Debug: {:?}
}
  • Debug: imprime com {:?}, para depurar.
  • Clone: cria uma cópia com .clone().
  • PartialEq: permite comparar com == e !=.

Display: impressão bonita

Debug é para programador. Para mostrar ao usuário com {}, implemente Display à mão:

use std::fmt;

struct Reais(f64);

impl fmt::Display for Reais {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // Vírgula como separador decimal, do jeito brasileiro
        let texto = format!("{:.2}", self.0).replace('.', ",");
        write!(f, "R$ {texto}")
    }
}

fn main() {
    let total = Reais(1234.5);
    println!("Total: {total}");
}

Quem implementa Display ganha também o método .to_string().

Closures e iteradores: uma primeira olhada

Uma closure é uma função pequena, sem nome, escrita entre barras: |x| x * 2. Ela pode usar variáveis de onde foi criada.

Ela brilha junto com os iteradores: .iter() entrega os itens de uma coleção, um por vez, e métodos como map (transforma cada item), filter (deixa passar só alguns) e collect (junta o resultado numa coleção nova) encadeiam o trabalho.

fn main() {
    let precos = vec![12.0, 45.0, 8.5, 99.9, 30.0];
    let desconto = 0.10;

    // Só os itens acima de R$ 20, já com desconto
    let promocao: Vec<f64> = precos
        .iter()
        .filter(|p| **p > 20.0)
        .map(|p| p * (1.0 - desconto)) // usa a variável desconto de fora
        .collect();

    for p in &promocao {
        println!("R$ {p:.2}");
    }

    let total: f64 = promocao.iter().sum();
    println!("Total: R$ {total:.2}");
}

O **p no filtro aparece porque o filter recebe uma referência para um item que já era referência. Não se preocupe com isso agora. Leia a cadeia de cima para baixo: pegue os preços, filtre, transforme, junte.

Resumo

  • Trait é um conjunto de métodos que um tipo promete ter; impl Trait for Tipo cumpre a promessa.
  • Traits podem ter métodos padrão.
  • &impl Trait aceita qualquer tipo que implemente a trait.
  • Genéricos <T> servem para vários tipos; trait bounds (T: PartialOrd) dizem o que T precisa saber fazer.
  • derive gera Debug, Clone e PartialEq; Display se escreve à mão.
  • Closures |x| ... combinam com map, filter e collect.

Desafio

Crie uma trait Forma com os métodos area(&self) -> f64 e nome(&self) -> String, e um método padrão resumo(&self) -> String que devolve algo como "Círculo com área 12.57". Implemente para Circulo { raio } e Quadrado { lado }. Depois escreva fn maior_area<T: Forma>(formas: &[T]) -> f64.

Ver uma resposta
trait Forma {
    fn area(&self) -> f64;
    fn nome(&self) -> String;

    fn resumo(&self) -> String {
        format!("{} com área {:.2}", self.nome(), self.area())
    }
}

struct Circulo {
    raio: f64,
}

struct Quadrado {
    lado: f64,
}

impl Forma for Circulo {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.raio * self.raio
    }
    fn nome(&self) -> String {
        String::from("Círculo")
    }
}

impl Forma for Quadrado {
    fn area(&self) -> f64 {
        self.lado * self.lado
    }
    fn nome(&self) -> String {
        String::from("Quadrado")
    }
}

fn maior_area<T: Forma>(formas: &[T]) -> f64 {
    formas.iter().map(|f| f.area()).fold(0.0, f64::max)
}

fn main() {
    println!("{}", Circulo { raio: 2.0 }.resumo());
    println!("{}", Quadrado { lado: 3.0 }.resumo());

    let quadrados = [Quadrado { lado: 2.0 }, Quadrado { lado: 5.0 }];
    println!("Maior área: {}", maior_area(&quadrados));
}
Salvo só neste navegador.