Nivel 3 · Sistemas· Lección 4 de 11 · 30 min
Traits avanzados
Tipos asociados frente a genéricos, tipos asociados genéricos, restricciones de rango superior, coherencia, traits sellados y traits de extensión.
Tipos asociados frente a parámetros de tipo
use std::ops::Mul;
#[derive(Debug, Clone, Copy)]
struct Metres(f64);
#[derive(Debug, Clone, Copy)]
struct SquareMetres(f64);
// Un PARÁMETRO de tipo (Rhs): un tipo puede implementar Mul para muchos lados derechos.
impl Mul<f64> for Metres {
type Output = Metres; // un tipo ASOCIADO: determinado por (Self, Rhs)
fn mul(self, k: f64) -> Metres { Metres(self.0 * k) }
}
impl Mul<Metres> for Metres {
type Output = SquareMetres;
fn mul(self, o: Metres) -> SquareMetres { SquareMetres(self.0 * o.0) }
}
fn main() {
let side = Metres(3.0);
println!("{:?} {:?}", side * 2.0, side * side);
}
Regla práctica: las entradas de la elección de la implementación son parámetros de tipo; las salidas son tipos asociados. Con un tipo asociado la inferencia no es ambigua y los usuarios nunca tienen que nombrarlo.
Tipos asociados genéricos
Un tipo asociado puede ser a su vez genérico (GAT, generic associated type). El ejemplo que lo motiva es un iterador que presta (lending iterator), cuyos elementos toman prestado del propio iterador: algo que Iterator no puede expresar, porque Item no tiene forma de mencionar el lifetime del préstamo &mut self.
trait LendingIterator {
type Item<'a> where Self: 'a;
fn next(&mut self) -> Option<Self::Item<'_>>;
}
/// Produce ventanas mutables solapadas: imposible con el Iterator de std.
struct WindowsMut<'s, T> {
slice: &'s mut [T],
size: usize,
pos: usize,
}
impl<'s, T> LendingIterator for WindowsMut<'s, T> {
type Item<'a> = &'a mut [T] where Self: 'a;
fn next(&mut self) -> Option<&mut [T]> {
let window = self.slice.get_mut(self.pos..self.pos + self.size)?;
self.pos += 1;
Some(window)
}
}
fn main() {
let mut data = [1, 2, 3, 4, 5];
let mut it = WindowsMut { slice: &mut data, size: 2, pos: 0 };
while let Some(w) = it.next() {
w[1] += w[0]; // suma acumulada, en el sitio
}
println!("{data:?}");
}
Cada ventana debe soltarse antes de la siguiente llamada a next(): el borrow checker lo impone, y eso es exactamente lo que hace que las ventanas &mut solapadas sean correctas.
Restricciones de trait de rango superior
Normalmente los parámetros de lifetime los elige quien llama. A veces una función necesita una clausura que funcione para cualquier lifetime, porque es la propia función la que va a crear las referencias:
fn apply_to_local<F>(f: F) -> usize
where
F: for<'a> Fn(&'a str) -> &'a str,
{
let local = String::from(" padded ");
f(&local).len() // el préstamo de `local` tiene un lifetime que quien llama nunca podría nombrar
}
fn main() {
println!("{}", apply_to_local(|s| s.trim()));
}
for<'a> se lee «para todo 'a». Rara vez lo escribes entero: F: Fn(&str) -> &str es azúcar sintáctico para exactamente esto. Se hace visible en los mensajes de error («implementation of FnOnce is not general enough»), y ahora ya sabes qué significan.
Coherencia y la regla del huérfano
La coherencia es la propiedad de que para cualquier tipo y cualquier trait hay como máximo una implementación en todo el programa. El compilador la impone con dos comprobaciones:
- Solapamiento: dos impl del mismo crate no pueden aplicarse al mismo tipo.
impl<T: Display> Foo for Teimpl Foo for Stringse solapan. - Regla del huérfano: un impl solo se permite si el trait es local, o si un tipo local aparece en una posición suficientemente «descubierta» entre los argumentos de tipo del trait.
La regla del huérfano precisa te deja escribir impl From<MyType> for Vec<u8> (un tipo local es parámetro del trait ajeno) pero no impl<T> From<T> for Vec<u8>.
Como añadir un impl puede chocar con el de otra persona, un impl genérico (blanket) en una biblioteca es un compromiso serio: impide que los crates que dependen de ti —y tú mismo en el futuro— escriban otros más específicos. No existe una especialización estable.
Patrones construidos sobre traits
Traits de extensión
Añade métodos a tipos ajenos definiendo un trait e implementándolo para ellos:
trait StrExt {
fn word_count(&self) -> usize;
fn title_case(&self) -> String;
}
impl StrExt for str {
fn word_count(&self) -> usize {
self.split_whitespace().count()
}
fn title_case(&self) -> String {
self.split_whitespace()
.map(|w| {
let mut c = w.chars();
c.next().map(|f| f.to_uppercase().chain(c).collect::<String>()).unwrap_or_default()
})
.collect::<Vec<_>>()
.join(" ")
}
}
fn main() {
println!("{} {}", "the rust book".word_count(), "the rust book".title_case());
}
Traits sellados
mod sealed {
pub trait Sealed {}
}
/// Implementado para los tipos enteros que admite este crate. No se puede implementar fuera de él.
pub trait Word: sealed::Sealed {
const BITS: u32;
}
impl sealed::Sealed for u32 {}
impl sealed::Sealed for u64 {}
impl Word for u32 { const BITS: u32 = 32; }
impl Word for u64 { const BITS: u32 = 64; }
fn bits<W: Word>() -> u32 { W::BITS }
fn main() {
println!("{} {}", bits::<u32>(), bits::<u64>());
}
El código externo puede usar Word como restricción, pero no puede nombrar sealed::Sealed para implementarlo.
Traits marcadores y auto traits
Los traits sin métodos codifican propiedades: Copy, Send, Sync, Sized, Unpin. Los auto traits (Send, Sync, Unpin) se implementan automáticamente cuando todos los campos los implementan. Sized es una restricción implícita en todo parámetro de tipo; escribe T: ?Sized para aceptar tipos sin tamaño conocido, como str y dyn Trait.
Desambiguación
Cuando dos traits definen un método con el mismo nombre, usa la sintaxis completamente cualificada: <Type as Trait>::method(&value).
Ejercicios
- Define
trait Container { type Item; fn get(&self, i: usize) -> Option<&Self::Item>; fn first(&self) -> Option<&Self::Item> { self.get(0) } }e impleméntalo paraVec<T>y para tu propiostruct Repeat<T>(T). - Escribe un trait de extensión sobre
Iterator(trait IterExt: Iterator) que añadafn every_nth(self, n: usize) -> impl Iterator<Item = Self::Item>con un impl genérico. - Explica, haciendo referencia a la coherencia, por qué
impl<T> Display for Vec<T>se rechaza en tu crate, y muestra la solución con el patrón newtype. - Implementa
LendingIteratorpara un struct que lea líneas en un único búferStringreutilizado y preste&str.
Comprueba lo que has entendido
Elige una respuesta para ver la explicación.
1.¿Cuándo debe un trait usar un tipo asociado en lugar de un parámetro de tipo?
2.¿Qué expresa
for<'a> F: Fn(&'a str) -> &'a str?3.¿Qué es un trait sellado?