Ergonomía de Deref y wrappers
Haga que los wrappers se comporten como tipos nativos
Ergonomía de Deref y wrappers es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.
El problema de la ergonomía
Envolver un tipo en un newtype aporta seguridad, pero resta comodidad: de repente debe escribir wrapper.0.method() en todas partes y volver a implementar los métodos manualmente.
El trait Deref puede recuperar gran parte de esa comodidad al permitir que el wrapper se comporte como el valor que contiene.
Qué hace Deref
Deref define qué produce *value y permite el funcionamiento del operador .. Cuando llama a un método que el wrapper no tiene, el compilador vuelve a intentarlo sobre el destino de la desreferenciación.
Este paso automático se denomina coerción por desreferenciación.
use std::ops::Deref;
struct MyBox<T>(T);
impl<T> Deref for MyBox<T> {
type Target = T;
fn deref(&self) -> &T { &self.0 }
}La coerción por desreferenciación en acción
Una vez implementado Deref, basta con llamar a los métodos internos a través del wrapper. El compilador inserta .deref() por usted hasta encontrar el método.
use std::ops::Deref;
struct Name(String);
impl Deref for Name {
type Target = String;
fn deref(&self) -> &String { &self.0 }
}
fn main() {
let n = Name("rustacean".to_string());
println!("len = {}", n.len()); // String::len via deref
}DerefMut para el acceso mutable
Deref solo proporciona acceso compartido. Para llamar a métodos que necesitan &mut self a través del wrapper, implemente también DerefMut, que devuelve una referencia mutable al valor interno.
use std::ops::{Deref, DerefMut};
struct Stack(Vec<i32>);
impl Deref for Stack {
type Target = Vec<i32>;
fn deref(&self) -> &Vec<i32> { &self.0 }
}
impl DerefMut for Stack {
fn deref_mut(&mut self) -> &mut Vec<i32> { &mut self.0 }
}Coerción en los límites de las funciones
La coerción por desreferenciación también se aplica a los argumentos. Un &Name se convierte en &String, que a su vez se convierte en &str, por lo que puede pasar el wrapper directamente a funciones que esperan la referencia interna.
fn greet(who: &str) {
println!("hi {}", who);
}
// greet(&name) works: &Name -> &String -> &strUn ejemplo ejecutable de coerción
Este programa pasa una referencia a un wrapper donde se espera un segmento de cadena. Las coerciones encadenadas por desreferenciación se producen silenciosamente en el punto de la llamada.
use std::ops::Deref;
struct Tag(String);
impl Deref for Tag {
type Target = String;
fn deref(&self) -> &String { &self.0 }
}
fn shout(s: &str) { println!("{}!", s.to_uppercase()); }
fn main() {
let t = Tag("ship".to_string());
shout(&t);
}No abuse de Deref
Las directrices de la API de Rust desaconsejan implementar Deref para tipos que no sean punteros inteligentes genuinos. Usarlo en exceso hace impredecibles los métodos disponibles del wrapper y sorprende a quienes leen el código.
Si el newtype existe para restringir una API, un Deref indiscriminado puede exponer precisamente los métodos que pretendía ocultar.
AsRef como alternativa específica
Cuando solo necesite una conversión explícita en lugar de una coerción automática, implemente AsRef. Los llamadores escriben .as_ref() deliberadamente, lo que mantiene clara la propia interfaz del wrapper.
struct Path(String);
impl AsRef<str> for Path {
fn as_ref(&self) -> &str { &self.0 }
}Delegación de métodos seleccionados
Para un wrapper restrictivo, es preferible escribir manualmente solo los métodos que desea exponer. Así mantiene el control total de la API en lugar de filtrar todo mediante Deref.
struct Counter(Vec<u8>);
impl Counter {
fn len(&self) -> usize { self.0.len() }
fn push(&mut self, b: u8) { self.0.push(b); }
}Los punteros inteligentes usan Deref
Los punteros inteligentes estándar, como Box, Rc y Arc, implementan Deref. Por eso puede llamar a los métodos internos de forma transparente. Este es el uso legítimo y previsto del trait.
use std::rc::Rc;
fn main() {
let shared = Rc::new(String::from("data"));
// Deref lets us call String methods directly
println!("len = {}", shared.len());
}Elegir una estrategia ergonómica
Elija según la intención. Use Deref para wrappers que sean verdaderos punteros inteligentes, AsRef para conversiones explícitas a referencias prestadas y la delegación manual cuando un newtype deba restringir la API de su tipo interno.
Una elección incorrecta oculta demasiado o expone demasiado.
Comprobación rápida
Decida qué wrapper merece una implementación de Deref.
Resumen
Deref y la coerción por desreferenciación recuperan la ergonomía de los wrappers al permitir que el operador . y los argumentos de referencia lleguen hasta el valor interno; DerefMut añade acceso mutable.
Reserve Deref para los verdaderos punteros inteligentes. Para newtypes restrictivos, use AsRef para conversiones explícitas o delegue únicamente los métodos que decida exponer.
Aprende Rust con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 39
- Lecciones
- 144
Preguntas frecuentes
¿La lección «Ergonomía de Deref y wrappers» es gratis?
Sí — el texto completo de «Ergonomía de Deref y wrappers» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.
¿Qué aprenderé en «Ergonomía de Deref y wrappers»?
Haga que los wrappers se comporten como tipos nativos Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Learn Rust Coding?
No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Ergonomía de Deref y wrappers»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?
Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- El patrón Builder
- El patrón Newtype
- Builders con estado de tipos
- Ergonomía de Deref y wrappers