Traits como parámetros: impl Trait, bounds y valores de retorno

Un trait cobra su verdadero valor cuando lo usas para abstraer una firma. En vez de escribir una función que acepta un Articulo, escribes una que acepta cualquier cosa que sea Resumible. El tipo concreto deja de importar; lo que importa es la capacidad. Rust te da tres formas de expresar esto —impl Trait en el argumento, el trait bound genérico y impl Trait en el retorno—, y detrás de las tres hay una única idea con dos caras opuestas.

impl Trait en la posición de argumento

La forma más directa de pedir una capacidad es anteponer impl al trait en el tipo del parámetro:

use std::fmt::Display;

fn anunciar(x: impl Display) {
    println!(">> {x}");
}

anunciar no acepta un tipo concreto: acepta cualquier valor cuyo tipo implemente Display. La función razona solo con la capacidad —“esto se puede mostrar”— y se olvida de con qué la cumples:

anunciar(42);       // el tipo anónimo es i32
anunciar("hola");   // ahora es &str
anunciar(3.14);     // ahora f64

Cada llamada puede usar un tipo distinto, y todas son válidas mientras cumplan el bound.

La forma explícita: trait bounds genéricos

impl Trait en el argumento es azúcar sintáctico para un parámetro de tipo genérico con una restricción. Esta función es equivalente a la anterior:

fn anunciar_generico<T: Display>(x: T) {
    println!(">> {x}");
}

El <T: Display> se lee “para todo tipo T que implemente Display”. La parte : Display es el trait bound: la restricción que el parámetro debe satisfacer. Ambas formas generan el mismo código, pero la diferencia se vuelve tangible con dos parámetros. Con un único parámetro de tipo, ambos argumentos quedan atados al mismo tipo concreto:

fn par_igual<T: Display>(a: T, b: T) {
    println!("{a} y {b}");
}

par_igual(1, 2);         // OK: ambos son i32
// par_igual(1, "dos");  // ERROR: T no puede ser i32 y &str a la vez

Con impl Display en los dos parámetros, en cambio, cada uno introduce su propio tipo anónimo y podrían diferir. La genérica es más verbosa, pero tiene dos ventajas que la forma con impl Trait no ofrece:

Usa impl Trait cuando la firma es simple y no necesitas referirte al tipo; pasa a la forma <T: ...> en cuanto quieras ligar varios argumentos o mencionar el parámetro.

Devolver impl Trait

impl Trait también sirve en la posición de retorno, y ahí resuelve un problema que de otro modo sería intratable: devolver un valor cuyo tipo no se puede escribir.

fn contador_par(desde: u32) -> impl Iterator<Item = u32> {
    (desde..).step_by(2)
}

fn multiplicador(factor: i32) -> impl Fn(i32) -> i32 {
    move |x| x * factor
}

El tipo real que devuelve contador_par es algo como StepBy<RangeFrom<u32>>, y el de multiplicador es un closure cuyo nombre el compilador genera y no expone: es inescribible. -> impl Iterator y -> impl Fn(...) te dejan prometer solo la capacidad —“esto itera”, “esto se puede llamar”— y ocultar el tipo concreto. Quien recibe el valor puede iterarlo o llamarlo, pero no conoce ni depende de su tipo exacto.

El caso más frecuente es devolver una cadena de adaptadores de iterador, cuyo tipo se hincha a cada eslabón:

fn pares_al_cuadrado(hasta: u32) -> impl Iterator<Item = u32> {
    (0..hasta).filter(|n| n % 2 == 0).map(|n| n * n)
}

El tipo verdadero anida un Map sobre un Filter sobre un Range, con un parámetro por cada closure: prácticamente imposible de escribir a mano y sujeto a cambiar en cuanto añadas un eslabón. -> impl Iterator te libera de nombrarlo; prometes la capacidad y el compilador lleva la cuenta del tipo exacto por ti.

El consumidor, al otro lado, opera solo por la capacidad, sin nombrar tipo alguno:

let cuadrados: Vec<u32> = pares_al_cuadrado(6).take(3).collect(); // [0, 4, 16]
let doblar = multiplicador(2);
assert_eq!(doblar(21), 42);   // se invoca como Fn, sin conocer su tipo real

flowchart LR
arg[impl Trait como parametro] --> q1[el llamador elige el tipo concreto]
ret[impl Trait como retorno] --> q2[la funcion elige y oculta el tipo concreto]
q1 --> mono[monomorfizacion genera una copia especializada por tipo]
q2 --> mono
mono --> zero[coste cero en ejecucion]

La dualidad: universal frente a existencial

Las dos posiciones de impl Trait parecen la misma sintaxis, pero significan cosas opuestas, y entenderlo separa a quien copia patrones de quien los domina.