Traits de conversión y Deref básico en Rust — Capítulo 14

Por /

Facilitando la Ergonomía en Tipos Prestados

La comprensión de los traits de conversión y préstamo resulta esencial en Rust para manejar referencias y tipos de manera ergonómica, especialmente en contextos donde se requiere flexibilidad sin comprometer la seguridad de tipos. Este capítulo explora los traits AsRef, Borrow, AsMut y Deref a un nivel básico, destacando sus diferencias prácticas y su impacto en escenarios comunes como el manejo de &String versus &str. Estos mecanismos permiten escribir código más genérico y reutilizable, integrándose con el sistema de ownership y borrowing de Rust para evitar conversiones explícitas innecesarias.

El Trait AsRef

El trait AsRef proporciona un mecanismo para convertir un tipo en una referencia a otro tipo de manera genérica, enfatizando la ergonomía en funciones que aceptan argumentos prestados. Definido en la biblioteca estándar de Rust, AsRef se implementa para tipos donde una conversión a referencia es natural y de bajo costo, como de String a &str o de Vec<T> a &[T].

La sintaxis del trait es la siguiente:

pub trait AsRef<T: ?Sized> {
    fn as_ref(&self) -> &T;
}

Esto permite que una función genérica acepte cualquier tipo que implemente AsRef<U>, obteniendo una &U sin requerir conocimiento específico del tipo origen. Por ejemplo, considere una función que procesa cadenas:

fn procesar_cadena<S: AsRef<str>>(cadena: S) {
    let ref_str = cadena.as_ref();
    // Operaciones con ref_str como &str
}

Aquí, procesar_cadena puede invocarse con String, &str o incluso &String, ya que String implementa AsRef<str> y &String también lo hace indirectamente. Una diferencia práctica con otros traits radica en que AsRef no impone restricciones de hashing o igualdad, lo que lo hace ideal para conversiones puras sin suposiciones adicionales. En términos de ergonomía, facilita el uso de &String en APIs que esperan &str, evitando llamadas explícitas a métodos como as_str().

Casos borde incluyen tipos donde la conversión implica una operación costosa; sin embargo, las implementaciones estándar evitan esto, asegurando que as_ref sea siempre O(1). Comparado con lenguajes como C++, donde las conversiones implícitas pueden ocultar costos, Rust explicita el trait para mantener la predictibilidad.

El Trait Borrow

El trait Borrow extiende la idea de préstamo al requerir no solo una conversión a referencia, sino también que el tipo prestado se comporte de manera equivalente al original en términos de igualdad y hashing. Esto lo hace particularmente útil en contextos como claves en estructuras de datos como HashMap, donde la consistencia es crucial.

La definición del trait es:

pub trait Borrow<Borrowed: ?Sized> {
    fn borrow(&self) -> &Borrowed;
}

A diferencia de AsRef, Borrow impone que el tipo implemente Eq y Hash de forma coherente entre el origen y el prestado. Por instancia, String implementa Borrow<str>, permitiendo que una String se use como clave en un mapa que espera &str, ya que string.borrow() devuelve &str y las comparaciones coinciden.

Un ejemplo ilustrativo:

use std::collections::HashMap;

fn insertar_en_mapa<K: std::hash::Hash + Eq, V>(mapa: &mut HashMap<K, V>, clave: impl Borrow<K>, valor: V) {
    mapa.insert(clave.borrow(), valor);
}

Esta función acepta String para claves de tipo str, ya que Borrow garantiza que &str de una String hashee igual que la String misma. En ergonomía, Borrow resuelve problemas con &String versus &str al permitir que APIs genéricas traten ambos de manera intercambiable, reduciendo la necesidad de desreferenciaciones manuales. Un detalle sutil es que Borrow no permite mutabilidad, enfocándose en préstamos inmutables; para mutabilidad, se recurre a AsMut o BorrowMut.

En comparación con Python, donde los diccionarios permiten claves mutables con hashing implícito, Rust usa Borrow para explicitar y asegurar la coherencia, previniendo errores en tiempo de ejecución.

El Trait AsMut

Para escenarios que requieren mutabilidad, el trait AsMut ofrece una conversión a referencia mutable, similar a AsRef pero con permisos de escritura. Se define como:

pub trait AsMut<T: ?Sized> {
    fn as_mut(&mut self) -> &mut T;
}

Esto es útil en funciones que modifican datos prestados, como editar el contenido de un Vec<T> a través de &mut [T]. Por ejemplo:

fn modificar_vector<V: AsMut<[i32]>>(vec: &mut V) {
    let slice = vec.as_mut();
    slice[0] = 42;
}

Aquí, modificar_vector puede aceptar &mut Vec<i32> o incluso &mut [i32; 5], siempre que implementen AsMut<[i32]>. Las diferencias prácticas con AsRef son evidentes en la mutabilidad: AsMut permite cambios in situ, mientras que AsRef es solo para lectura. En cuanto a ergonomía con tipos como String, AsMut<str> no está implementado directamente porque str no es mutable (Rust prefiere AsMut<[u8]> para bytes), pero para String a &mut str no aplica; en su lugar, se usa para otros tipos como PathBuf a &mut Path.

Reglas formales dictan que la implementación debe ser reversible lógicamente, aunque no se fuerza por el compilador. Un caso borde surge con tipos que no soportan mutabilidad interna, donde AsMut fallaría en compilación si se intenta. Frente a Java, donde las interfaces mutables pueden ser implícitas, Rust’s AsMut asegura tipado estático para mutabilidad segura.

El Trait Deref

El trait Deref introduce un nivel de indirección similar a punteros, permitiendo que un tipo se comporte como una referencia a otro tipo mediante desreferenciación automática. A nivel básico, se usa para smart pointers simples, pero este capítulo se limita a sus usos ergonómicos sin cubrir coerciones avanzadas.

Su definición es:

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

Deref habilita la sintaxis * para acceder al tipo objetivo. Un ejemplo clásico es String implementando Deref<Target = str>, lo que permite:

let s: String = String::from("hola");
let slice: &str = &*s;  // Desreferencia automática

Esto mejora la ergonomía al tratar &String como &str en muchos contextos, sin llamadas explícitas. Diferencias con AsRef incluyen que Deref soporta desreferenciación en cadena y se integra con el borrow checker para coerciones implícitas básicas, como pasar &String a una función que espera &str. Sin embargo, un detalle sutil es que Deref no garantiza hashing o igualdad como Borrow, por lo que no es intercambiable en mapas.

Comparado con C’s pointers, Deref añade seguridad al prevenir dangling references. En ergonomía, resuelve fricciones con &String vs &str al hacer que el compilador maneje la conversión, reduciendo boilerplate.

Proyecto Completo: Motor de Conversión Genérico

Para ilustrar la aplicación práctica de estos traits, se presenta un motor de conversión genérico que maneja temperaturas (Celsius a Fahrenheit), divisas (USD a EUR con tasa fija) y unidades de longitud (metros a kilómetros). El diseño usa AsRef para entradas flexibles, Borrow para claves en un mapa de tasas, AsMut para modificaciones en estructuras mutables y Deref para acceder a valores internos. La estructura de carpetas es la siguiente:

proyecto-conversion/
├── Cargo.toml
└── src/
    └── main.rs

Contenido de Cargo.toml:

[package]
name = "conversion-motor"
version = "0.1.0"
edition = "2021"

[dependencies]

Contenido de src/main.rs:

use std::collections::HashMap;

// Trait genérico para conversión
trait Convertir<T> {
    fn convertir(&self, valor: f64) -> f64;
}

// Estructuras para cada tipo de conversión
#[derive(Hash, Eq, PartialEq)]
struct Temperatura(String);  // e.g., "CelsiusToFahrenheit"

impl Convertir<Temperatura> for Temperatura {
    fn convertir(&self, valor: f64) -> f64 {
        (valor * 9.0 / 5.0) + 32.0
    }
}

#[derive(Hash, Eq, PartialEq)]
struct Divisa(String);  // e.g., "USDToEUR"

impl Convertir<Divisa> for Divisa {
    fn convertir(&self, valor: f64) -> f64 {
        valor * 0.85  // Tasa fija USD a EUR
    }
}

#[derive(Hash, Eq, PartialEq)]
struct Unidad(String);  // e.g., "MetersToKilometers"

impl Convertir<Unidad> for Unidad {
    fn convertir(&self, valor: f64) -> f64 {
        valor / 1000.0
    }
}

// Motor genérico usando traits
struct MotorConversion {
    tasas: HashMap<String, f64>,  // Para tasas variables, mutable
}

impl MotorConversion {
    fn new() -> Self {
        let mut tasas = HashMap::new();
        tasas.insert("USDToEUR".to_string(), 0.85);
        MotorConversion { tasas }
    }

    fn convertir_genérico<K, C>(&self, clave: K, valor: f64) -> f64
    where
        K: Borrow<str> + AsRef<str>,
        C: Convertir<C> + From<K>,
    {
        let clave_ref = clave.as_ref();
        let conv: C = clave.into();
        let mut tasa_base = conv.convertir(valor);

        // Usar AsMut para modificar tasas si aplica
        let mut tasas_mut = self.tasas.clone();  // Simulación de mutabilidad
        if let Some(tasa) = tasas_mut.as_mut().get_mut(clave_ref) {
            tasa_base *= *tasa;
        }

        tasa_base
    }

    fn convertir_temperatura<S: AsRef<str> + Borrow<str>>(&self, tipo: S, valor: f64) -> f64 {
        let temp = Temperatura(tipo.as_ref().to_string());
        let deref_temp: &str = &*temp.0;  // Usando Deref para acceso
        println!("Convirtiendo {}", deref_temp);
        temp.convertir(valor)
    }

    // Funciones similares para divisa y unidad
    fn convertir_divisa<S: AsRef<str> + Borrow<str>>(&self, tipo: S, valor: f64) -> f64 {
        let div = Divisa(tipo.as_ref().to_string());
        div.convertir(valor)
    }

    fn convertir_unidad<S: AsRef<str> + Borrow<str>>(&self, tipo: S, valor: f64) -> f64 {
        let uni = Unidad(tipo.as_ref().to_string());
        uni.convertir(valor)
    }
}

fn main() {
    let motor = MotorConversion::new();

    // Ejemplos
    let temp_c = 25.0;
    println!("{} C to F: {}", temp_c, motor.convertir_temperatura("CelsiusToFahrenheit", temp_c));

    let usd = 100.0;
    println!("{} USD to EUR: {}", usd, motor.convertir_divisa("USDToEUR", usd));

    let metros = 5000.0;
    println!("{} m to km: {}", metros, motor.convertir_unidad("MetersToKilometers", metros));

    // Uso genérico con String y &str
    let clave_string = String::from("USDToEUR");
    println!("Genérico con String: {}", motor.convertir_genérico(clave_string, 100.0));

    println!("Genérico con &str: {}", motor.convertir_genérico("MetersToKilometers", 5000.0));
}

Este proyecto demuestra cómo los traits facilitan APIs flexibles, permitiendo entradas como String o &str sin conversiones manuales, y soporta extensiones para más tipos de conversión.

Habiendo establecido las bases de estos traits para conversiones básicas y préstamos, el siguiente capítulo profundizará en patrones avanzados de genéricos que construyen sobre estos mecanismos para estructuras de datos más complejas.

Dejar un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Scroll al inicio