Deref y la coerción: por qué una ref a String vale donde se pide ref a str

Deref sobrecarga el operador *, pero reducirlo a eso es perderse lo importante. Su verdadera consecuencia es la coerción por deref: el compilador convierte en silencio un &String en &str, un &Vec<T> en &[T], un &Box<T> en &T, allí donde hace falta. Un puntero inteligente que implementa Deref deja de ser una caja opaca y se comporta como el valor que envuelve. Esa es la razón profunda de que String disponga de todos los métodos de str sin redefinir ni uno: no los hereda, los alcanza por deref.

Deref: el operador asterisco a tu medida

El trait tiene un tipo asociado Target —el valor apuntado— y un método que devuelve una referencia a él:

pub trait Deref {
    type Target: ?Sized;
    fn deref(&self) -> &Self::Target;
}

Cuando escribes *x sobre algo que no es una referencia ni un puntero crudo, el compilador lo expande a *(x.deref()). Construyamos nuestra propia caja para verlo:

use std::ops::Deref;

struct MiCaja<T>(T);

impl<T> MiCaja<T> {
    fn new(x: T) -> MiCaja<T> { MiCaja(x) }
}

impl<T> Deref for MiCaja<T> {
    type Target = T;
    fn deref(&self) -> &T { &self.0 }
}

fn main() {
    let c = MiCaja::new(5);
    assert_eq!(5, *c);   // *c es *(c.deref()), es decir *(&c.0)
}

La coerción por deref

Aquí empieza lo interesante. Cuando pasas un &T donde se espera un &U, y T implementa Deref<Target = U>, el compilador inserta la conversión por ti. Y lo hace de forma transitiva, encadenando tantos deref como haga falta:

fn hola(nombre: &str) {
    println!("Hola, {nombre}");
}

fn main() {
    let m = MiCaja::new(String::from("Ada"));
    hola(&m);   // &MiCaja<String> -> &String -> &str, dos coerciones seguidas
}

flowchart LR
A[ref a MiCaja de String] -->|Deref Target String| B[ref a String]
B -->|Deref Target str| C[ref a str]
C --> D[Encaja en el parametro ref a str]
style A fill:#89b4fa,color:#11111b
style C fill:#a6e3a1,color:#11111b
style D fill:#cba6f7,color:#11111b

Sin la coerción tendrías que escribir algo como hola(&(*m)[..]). Con ella, &m basta. Y es coste cero: todo se resuelve en compilación, sin indirección extra en tiempo de ejecución.

Resolución de métodos y la cadena de deref

La coerción no solo actúa en los argumentos: gobierna también la resolución de métodos. Cuando escribes x.metodo(), el compilador prueba x, luego &x, luego &mut x; si nada encaja, aplica un deref y repite, y así hasta el final de la cadena. Por eso un String responde a los métodos de str, y un Box<T> a los métodos de T:

fn main() {
    let s = String::from("hola mundo");
    // len() y split_whitespace() son metodos de str, no de String:
    let n = s.len();                             // String -> str por deref
    let palabras = s.split_whitespace().count();
    assert_eq!((n, palabras), (10, 2));
}

String no reimplementa len; el compilador desciende de String a str por su Deref y encuentra el método allí. La caja y el contenido comparten interfaz sin una sola línea de reenvío manual.

Deref es la interfaz del puntero inteligente

Deref existe para una cosa: hacer que un puntero inteligente —un tipo que envuelve y posee un valor con alguna lógica añadida— se use como si fuera el valor. Box<T>, Rc<T>, String sobre str, Vec<T> sobre [T]: todos lo implementan para volverse transparentes.