En Rust, cuando trabajamos con programación genérica, surge una distinción fundamental: ¿debemos usar parámetros de tipo (generics) o tipos asociados (associated types) en un trait? Esta decisión determina si un tipo puede implementar un trait múltiples veces con diferentes parámetros o si la implementación debe ser única.

Un parámetro de tipo (trait Trait<T>) permite que un mismo tipo implemente el trait para distintos T. Por ejemplo, el trait std::ops::Add<Rhs> utiliza un parámetro genérico para que un i32 pueda sumarse a un f64, a un i32, etc.

Por el contrario, un tipo asociado (trait Trait { type Item; }) establece una relación funcional de uno a uno. Una vez que implementas un trait para un tipo, el tipo asociado queda fijado para esa implementación. Si intentas implementar el mismo trait para el mismo tipo con un tipo asociado distinto, el compilador arrojará un error. Este es el caso de Iterator: un iterador sobre un Vec<i32> siempre producirá i32; no tiene sentido que un mismo iterador produzca diferentes tipos de elementos en diferentes ejecuciones.

Se deben usar associated types cuando existe una única representación natural para el trait (como el tipo de elemento de un iterador o el tipo de salida de una operación aritmética). Se deben usar parámetros genéricos cuando el comportamiento del trait depende de un tipo externo con el que se interactúa, permitiendo múltiples implementaciones.

Para utilizar estos tipos en restricciones de tipos (bounds), existen dos métodos:
1. Igualdad en el bound: T: Trait<Associated = Target> se usa para restringir que el tipo asociado sea uno específico.
2. Cláusula where: where T::Associated: Trait se utiliza para imponer restricciones sobre el tipo que el trait devuelve, permitiendo desambiguar mediante la sintaxis <T as Trait>::Associated.

use std::fmt::Display;

// Definición del trait con un tipo asociado
trait Transformador {
    type Output; // El placeholder para el tipo que implementará cada struct
    fn transformar(&self) -> Self::Output;
}

struct ConvertidorDeEnteros;

// Implementación del trait para nuestro struct
impl Transformador for ConvertidorDeEnteros {
    type Output = String; // Vinculamos 'Output' con 'String'

    fn transformar(&self) -> Self::Output {
        "100".to_string()
    }
}

struct MultiConvertidor;

// Un tipo diferente podría tener un tipo asociado distinto
impl Transformador for MultiConvertidor {
    type Output = i32;

    fn transformar(&self) -> Self::Output {
        100
    }
}

// Caso 1: Uso de equality bound para restringir el tipo asociado
fn procesar_solo_strings<T>(transformador: T)
where
    T: Transformador<Output = String>, // Solo acepta implementaciones que devuelvan String
{
    println!("Resultado string: {}", transformador.transformar());
}

// Caso 2: Uso de cláusula 'where' para referenciar el tipo asociado
fn imprimir_resultado<T>(transformador: T)
where
    T: Transformador,
    T::Output: Display, // Restringe que el tipo asociado implemente Display
{
    println!("Valor imprimible: {}", transformador.transformar());
}

fn main() {
    let c_string = ConvertidorDeEnteros;
    let c_int = MultiConvertidor;

    procesar_solo_strings(c_string);
    imprimir_resultado(c_string);
    imprimir_resultado(c_int);
    
    // procesar_solo_strings(c_int); // Error de compilación: Output es i32, no String
}

Explicación del Código

  • trait Transformador: Define el trait con un tipo asociado llamado Output. Este actúa como un marcador que cada implementación debe definir.
  • impl Transformador for ConvertidorDeEnteros: Aquí se define que, para el tipo ConvertidorDeEnteros, el type Output es String.
  • impl Transformador for MultiConvertidor: Demuestra que un tipo diferente puede tener un type Output distinto (i32), pero un mismo tipo no podría tener dos implementaciones de Transformador con tipos Output diferentes.
  • procesar_solo_strings<T>: Utiliza el bound T: Transformador<Output = String>. Esto es una restricción de igualdad que obliga a que el Output sea estrictamente String, permitiendo que el cuerpo de la función asuma que transformar() devuelve un string.
  • imprimir_resultado<T>: Utiliza una cláusula where T: Transformador, T::Output: Display. Aquí no estamos restringiendo el tipo a un valor concreto (como String), sino que estamos exigiendo que el tipo que T::Output represente cumpla con la característica Display. Esto permite que funcione tanto con ConvertidorDeEnteros (String) como con MultiConvertidor (i32), ya que ambos implementan Display.

N° 106