FerrousPath

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

  1. Define un trait Area e impleméntalo para Circle y Rect. Escribe fn total_area(shapes: &[impl Area]) -> f64. ¿Por qué el slice no puede mezclar círculos y rectángulos? (El nivel 3 lo responde.)
  2. Implementa Display y From<&str> (analizando "3,4"; pánico si la entrada es incorrecta) para Vec2.
  3. Deriva PartialOrd en 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. 1.¿Qué exige la regla del huérfano para impl Trait for Type?

  2. 2.¿Qué significa impl Trait en posición de argumento, como en fn f(x: impl Display)?

  3. 3.¿Qué trait implementas para obtener .into() gratis?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?