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(¬as));
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 Tipocumpre a promessa. - Traits podem ter métodos padrão.
&impl Traitaceita qualquer tipo que implemente a trait.- Genéricos
<T>servem para vários tipos; trait bounds (T: PartialOrd) dizem o queTprecisa saber fazer. derivegeraDebug,CloneePartialEq;Displayse escreve à mão.- Closures
|x| ...combinam commap,filterecollect.
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));
}