Nivel 2 · Practicante· Lección 2 de 8 · 30 min
Traits
Comportamiento compartido sin herencia — definir, implementar y derivar traits, y los traits estándar que todo programador de Rust conoce.
Definir e implementar un trait
Un trait es un conjunto de métodos que un tipo puede implementar. Es el mecanismo de Rust para el comportamiento compartido y para restringir los genéricos.
trait Describe {
// Obligatorio: quien implementa el trait debe proporcionarlo.
fn name(&self) -> String;
// Proporcionado: una implementación por defecto que se puede sobrescribir.
fn describe(&self) -> String {
format!("This is {}.", self.name())
}
}
struct Dog;
struct Robot { model: u32 }
impl Describe for Dog {
fn name(&self) -> String {
"a dog".to_string()
}
}
impl Describe for Robot {
fn name(&self) -> String {
format!("robot #{}", self.model)
}
fn describe(&self) -> String {
format!("BEEP. I AM {}.", self.name().to_uppercase())
}
}
fn introduce(thing: &impl Describe) {
println!("{}", thing.describe());
}
fn main() {
introduce(&Dog);
introduce(&Robot { model: 7 });
}
No hay herencia. Los tipos no forman jerarquías; implementan capacidades.
Los traits como restricciones
Estas tres firmas significan lo mismo:
use std::fmt::Display;
fn a(x: impl Display) { println!("{x}"); }
fn b<T: Display>(x: T) { println!("{x}"); }
fn c<T>(x: T) where T: Display { println!("{x}"); }
fn main() {
a(1); b("two"); c(3.0);
}
impl Trait en posición de retorno es distinto: dice «devuelvo un único tipo concreto que implementa este trait, y no te digo cuál».
fn evens(limit: u32) -> impl Iterator<Item = u32> {
(0..limit).filter(|n| n % 2 == 0)
}
fn main() {
println!("{:?}", evens(10).collect::<Vec<_>>());
}
El tipo real aquí es un anidamiento inmanejable de adaptadores, y las clausuras tienen tipos que directamente no se pueden escribir. impl Trait te permite devolverlos.
La regla del huérfano
Solo puedes implementar un trait para un tipo si tu crate define el trait o el tipo. Puedes implementar tu Describe para Vec<i32>, o Display para tu Robot, pero no Display para Vec<i32>. Sin esta regla (orphan rule), dos bibliotecas podrían implementar cada una el mismo trait para el mismo tipo y ningún programa podría usar ambas. La solución es el patrón newtype: envolver el tipo ajeno en un struct propio.
Sobrecarga de operadores y traits estándar
Los operadores son métodos de traits. a + b llama a Add::add(a, b).
use std::fmt;
use std::ops::Add;
#[derive(Debug, Clone, Copy, PartialEq, Default)]
struct Vec2 {
x: f64,
y: f64,
}
impl Add for Vec2 {
type Output = Vec2;
fn add(self, o: Vec2) -> Vec2 {
Vec2 { x: self.x + o.x, y: self.y + o.y }
}
}
impl fmt::Display for Vec2 {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "({}, {})", self.x, self.y)
}
}
impl From<(f64, f64)> for Vec2 {
fn from((x, y): (f64, f64)) -> Self {
Vec2 { x, y }
}
}
fn main() {
let a = Vec2 { x: 1.0, y: 2.0 };
let b: Vec2 = (0.5, 0.5).into(); // Into viene gratis con From
println!("{} {:?} {}", a + b, Vec2::default(), a == b);
}
Los traits que conviene saberse de memoria:
| Trait | Qué te da | Derivable |
|---|---|---|
Debug |
formato {:?} |
sí |
Display |
formato {} y .to_string() |
no |
Clone |
.clone() |
sí |
Copy |
copia implícita bit a bit en lugar de movimiento | sí |
PartialEq, Eq |
==; Eq añade «la igualdad es total» |
sí |
PartialOrd, Ord |
<, ordenación; Ord es un orden total |
sí |
Hash |
usarlo como clave de un HashMap |
sí |
Default |
T::default() |
sí |
From / Into |
conversión que no puede fallar | no |
TryFrom / TryInto |
conversión que puede fallar | no |
AsRef<T> |
préstamo barato como otro tipo | no |
Iterator |
bucles for y todos los adaptadores |
no |
Drop |
limpieza personalizada | no |
f64 es PartialEq pero no Eq, y PartialOrd pero no Ord, porque NaN != NaN. Por eso no puedes ordenar flotantes con un simple .sort() ni usarlos como claves de un mapa.
Tipos y constantes asociados
trait Shape {
const SIDES: u32;
type Unit;
fn perimeter(&self) -> Self::Unit;
}
struct Square(f64);
impl Shape for Square {
const SIDES: u32 = 4;
type Unit = f64;
fn perimeter(&self) -> f64 {
self.0 * Self::SIDES as f64
}
}
fn main() {
println!("{} sides, perimeter {}", Square::SIDES, Square(2.5).perimeter());
}
Un tipo asociado lo elige quien implementa el trait, una vez por implementación. Iterator::Item es el ejemplo canónico.
Supertraits e implementaciones genéricas
use std::fmt::Display;
// Todo lo que implemente Loud debe implementar también Display.
trait Loud: Display {
fn shout(&self) -> String {
self.to_string().to_uppercase() + "!"
}
}
// Implementación genérica (blanket): todo tipo Display es Loud.
impl<T: Display> Loud for T {}
fn main() {
println!("{} {}", "hello".shout(), 42.shout());
}
Las implementaciones genéricas (blanket implementations) son la razón de que ToString esté disponible en todo lo que implementa Display. Un trait de extensión como Loud es la forma idiomática de añadir métodos a tipos que no son tuyos.
Ejercicios
- Define un trait
Areae impleméntalo paraCircleyRect. Escribefn total_area(shapes: &[impl Area]) -> f64. ¿Por qué el slice no puede mezclar círculos y rectángulos? (El nivel 3 lo responde.) - Implementa
DisplayyFrom<&str>(analizando"3,4"; pánico si la entrada es incorrecta) paraVec2. - Deriva
PartialOrden un struct con dos campos y descubre experimentando cómo se define la comparación.
Respuesta del 3
El orden derivado es lexicográfico según el orden de declaración de los campos: se compara el primer campo y, solo si son iguales, el segundo. En los enums, las variantes declaradas antes son menores.
Comprueba lo que has entendido
Elige una respuesta para ver la explicación.
1.¿Qué exige la regla del huérfano para
impl Trait for Type?2.¿Qué significa
impl Traiten posición de argumento, como enfn f(x: impl Display)?3.¿Qué trait implementas para obtener
.into()gratis?