Implementaciones por defecto: métodos requeridos y provistos

Un trait no tiene por qué limitarse a pedir. También puede dar. Cuando una firma del trait trae su propio cuerpo, se convierte en una implementación por defecto: comportamiento que todo tipo que firme el contrato recibe gratis, sin escribir una línea. El tipo puede aceptarlo tal cual o sobreescribirlo. Esta capa de valores por defecto, construida sobre un núcleo mínimo de métodos requeridos, es el mecanismo que hace que un trait como Iterator te regale decenas de métodos a cambio de implementar uno solo.

Un método con cuerpo dentro del trait

Hasta ahora las firmas del trait terminaban en punto y coma. Si en su lugar les das un bloque, defines su comportamiento por defecto:

trait Saludo {
    fn nombre(&self) -> String;          // requerido: sin cuerpo

    fn saludar(&self) -> String {         // provisto: con cuerpo por defecto
        format!("Hola, {}", self.nombre())
    }
}

nombre es un método requerido: el trait lo declara pero no lo define, así que cada tipo debe aportarlo. saludar es un método provisto: el trait ya trae su cuerpo, y ese cuerpo se apoya en nombre. La consecuencia es notable: un tipo que implemente el trait solo tiene que dar nombre, y recibe saludar de regalo.

struct Persona { nombre: String }

impl Saludo for Persona {
    fn nombre(&self) -> String {
        self.nombre.clone()
    }
    // no implementamos saludar: heredamos el cuerpo por defecto
}

fn main() {
    let p = Persona { nombre: String::from("Ada") };
    println!("{}", p.saludar());   // Hola, Ada
}

El impl está casi vacío y aun así p.saludar() funciona. El trait escribió el algoritmo una vez; el tipo solo rellenó la pieza que el algoritmo no podía adivinar.

Sobreescribir el valor por defecto

Un método provisto es un punto de partida, no una sentencia. Cualquier impl puede reemplazarlo dando su propio cuerpo, sin ninguna palabra clave especial —nada de override—: basta con volver a declararlo.

struct Robot { serie: u32 }

impl Saludo for Robot {
    fn nombre(&self) -> String {
        format!("unidad-{}", self.serie)
    }

    fn saludar(&self) -> String {         // sobreescribe el default
        format!("BEEP. Identificador {}.", self.nombre())
    }
}

fn main() {
    let p = Persona { nombre: String::from("Ada") };
    let r = Robot { serie: 7 };
    println!("{}", p.saludar());   // Hola, Ada  (cuerpo por defecto)
    println!("{}", r.saludar());   // BEEP. Identificador unidad-7.  (sobreescrito)
}

Robot cambia el saludo; Persona conserva el genérico. Ambos cumplen el mismo contrato con comportamientos distintos. Sobreescribir un método provisto no afecta a los demás: si el trait ofreciera también despedir por defecto, Robot seguiría heredándolo aunque haya redefinido saludar.

flowchart TB
req[metodo requerido nombre sin cuerpo] --> d1[metodo provisto saludar apoya en nombre]
req --> d2[metodo provisto despedir apoya en nombre]
d1 --> tipo[un tipo solo implementa nombre]
d2 --> tipo
tipo --> gratis[recibe saludar y despedir gratis]
tipo --> over[y puede sobreescribir cualquiera de los dos]

El patrón: núcleo mínimo, biblioteca derivada

La verdadera potencia aparece cuando muchos métodos provistos se apoyan en un puñado de métodos requeridos. El trait autor escribe una capa de comportamiento derivado que depende solo de las operaciones abstractas del núcleo; el implementador aporta ese núcleo mínimo y hereda toda la capa.

trait Coleccion {
    fn longitud(&self) -> usize;          // único método requerido

    fn esta_vacia(&self) -> bool {        // derivado
        self.longitud() == 0
    }
    fn describir(&self) -> String {        // derivado
        if self.esta_vacia() {
            String::from("vacia")
        } else {
            format!("{} elementos", self.longitud())
        }
    }
}

Implementa longitud y obtienes esta_vacia y describir sin esfuerzo. Fíjate en que un método provisto puede apoyarse en otro provisto (describir llama a esta_vacia): el trait compone su propia lógica sobre el mismo núcleo abstracto.

struct Bolsa { articulos: Vec<String> }

impl Coleccion for Bolsa {
    fn longitud(&self) -> usize { self.articulos.len() }
    // esta_vacia y describir llegan gratis
}

fn main() {
    let b = Bolsa { articulos: vec![String::from("pan"), String::from("sal")] };
    println!("{}", b.describir());   // 2 elementos
    println!("{}", b.esta_vacia());  // false
}

Todo el comportamiento observable de Bolsa como colección se deduce de una sola línea de implementación. El resto lo escribió el trait, una vez, para cualquier tipo presente o futuro.