Cuando envuelves un primitivo (o cualquier tipo) dentro de una estructura de tupla, por ejemplo:
<pre><code class="language-rust">
struct Foo(u64);
</code></pre>
– Normalmente se accede al u64 interno como foo.0. Pero esto no es muy ergonómico, especialmente si solo se desea que la mayoría de los usos de Foo se comporten como u64. Ahí es donde entra en juego Deref.
El rasgo Deref (en std::ops) te permite definir cómo se debe desreferenciar tu tipo. El compilador Rust también aplica coerciones Deref, por lo que si implementas Deref para Foo, se pueden usar muchos valores &Foo donde se espera &u64. doc.rust-lang.org+2rust-unofficial.github.io+2
Aqui hay un ejemplo:
<pre><code class="language-rust">
use std::ops::Deref;
struct Foo(u64);
impl Deref for Foo {
type Target = u64;
fn deref(&self) -> &Self::Target {
&self.0
}
}
fn take_u64(x: &u64) {
println!("Value = {}", x);
}
fn main() {
let f = Foo(42);
take_u64(&f); // &Foo → &u64 via Deref
let inner: u64 = *f; println!("Inner: {}", inner);
}
</code></pre>
Una vez hecho esto:
- Puedes llamar a funciones que esperan &u64 con &Foo.
- Puedes escribir *foo para obtener el valor u64.
- Muchos métodos en u64 que toman &self funcionarán cuando los llames directamente en Foo, gracias a la coerción de desreferenciación y la búsqueda de métodos.
Ventajas e inconvenientes y cuándo (no) utilizar Deref
El uso de Deref en una estructura contenedora ofrece ventajas ergonómicas, pero debe hacerse con cuidado:
La documentación de la biblioteca estándar advierte que Deref tiene un comportamiento implícito fuerte (el compilador inserta llamadas deref), por lo que no se debe sorprender a los usuarios. doc.rust-lang.org
- El propósito idiomático de Deref es para tipos similares a punteros (punteros inteligentes). Usarlo para envoltorios simples a veces puede confundir a los lectores o fusionar API de formas no deseadas. rustunofficial.github.io+1
- Si su envoltorio tiene sus propios métodos que entran en conflicto con los métodos de u64, la resolución de métodos podría ser ambigua.
- Si el contenedor impone invariantes más allá del valor sin procesar, exponer todo a través de Deref podría debilitar la encapsulación.
En muchos casos, usar AsRef, Into o simplemente proporcionar un método get/value inherente es suficiente y más explícito. Pero cuando tu envoltura es solo una capa delgada y transparente sobre un tipo, Deref puede hacer que el código del cliente sea mucho más limpio.