Bounds múltiples, where y la síntesis: traits más genéricos

Rara vez una función genérica necesita una sola capacidad. Para imprimir y clonar un valor, T debe cumplir dos traits a la vez; para recorrer un iterador y mostrar sus elementos, las condiciones se acumulan. Rust las combina con + y, cuando la firma se vuelve un muro ilegible, las reordena con la cláusula where. Pero esta lección es también el cierre del nivel, y toca dar un paso atrás: los genéricos que has aprendido son solo una mitad. La otra son los traits. Juntos forman el sistema de abstracción de Rust —su respuesta, de coste cero, a lo que otros lenguajes resuelven con herencia—.

Bounds múltiples con +

Cuando el cuerpo de una función usa varias capacidades de T, las exiges todas encadenándolas con +. Se lee como un “y” lógico: T debe implementar cada uno de los traits nombrados.

use std::fmt::{Debug, Display};

fn describe<T: Display + Debug + Clone>(x: T) -> T {
    println!("bonito: {x}");     // usa Display
    println!("crudo:  {x:?}");   // usa Debug
    x.clone()                    // usa Clone
}

Cada operación del cuerpo se apoya en un trait distinto, y el compilador comprueba que estén todos presentes antes de aceptar una llamada. El orden de los bounds no importa: Display + Debug y Debug + Display son la misma exigencia. Y solo debes pedir lo que realmente usas: sumar un bound que el cuerpo no necesita no es más seguro, solo más restrictivo para quien llama.

where: cuando la firma se complica

Con uno o dos parámetros, la sintaxis en línea va bien. Pero cuando hay varios parámetros, cada uno con varios bounds, la cabecera se vuelve un jeroglífico:

// Legible a duras penas
fn procesa<T: Clone + Debug, U: Display + Default, R: Iterator<Item = T>>(t: T, u: U, r: R) {
    // ...
}

La cláusula where separa la declaración de los parámetros de sus restricciones, y la firma respira:

fn procesa<T, U, R>(t: T, u: U, r: R)
where
    T: Clone + Debug,
    U: Display + Default,
    R: Iterator<Item = T>,
{
    // ...
}

Mismo significado, exactamente; puro reordenamiento visual. Pero where no es solo cosmética: es más expresiva. Permite escribir bounds que la sintaxis en línea no admite —sobre tipos asociados o sobre tipos que no son un parámetro directo—, como veremos ahora. La regla práctica: en línea para uno o dos bounds simples, where en cuanto la cosa crece o exige condiciones sobre tipos asociados.

Bounds sobre tipos asociados y relaciones

El verdadero poder de where aparece cuando la condición no recae sobre el parámetro en sí, sino sobre algo derivado de él. Un caso cotidiano: aceptar cualquier cosa iterable cuyos elementos sepan imprimirse. El bound no es sobre I, sino sobre I::Item, el tipo asociado del iterador:

use std::fmt::Display;

fn imprime_todo<I>(iter: I)
where
    I: IntoIterator,
    I::Item: Display,
{
    for x in iter {
        println!("- {x}");
    }
}

imprime_todo(vec![1, 2, 3]);
imprime_todo(["a", "b", "c"]);

I: IntoIterator dice que I se puede recorrer; I::Item: Display dice que lo que produce al recorrerlo sabe mostrarse. Esa segunda condición, sobre un tipo asociado, es intraducible a la sintaxis en línea: solo where la expresa. Es la puerta a firmas genéricas de verdad expresivas, las que verás en el ecosistema de iteradores y en las APIs de la std.

El mismo patrón permite exigir que el iterador produzca un tipo concreto. Aquí pedimos que sus elementos sean i32 para poder sumarlos:

fn suma<I>(iter: I) -> i32
where
    I: IntoIterator<Item = i32>,
{
    let mut total = 0;
    for x in iter {
        total += x;
    }
    total
}

assert_eq!(suma(vec![1, 2, 3]), 6);
assert_eq!(suma(1..=4), 10);

Item = i32 es un bound de igualdad sobre el tipo asociado: no basta con que I sea iterable, debe producir exactamente i32. Es otra restricción que solo la forma where (o el equivalente IntoIterator<Item = i32>) sabe expresar.

La síntesis: traits + genéricos

Demos el paso atrás. Estos dos niveles —traits y genéricos— no son temas separados: son las dos mitades de una sola idea.

• Los traits definen capacidades: “un tipo que se puede comparar”, “que se puede imprimir”, “que se puede clonar”.
• Los genéricos abstraen código sobre “cualquier tipo T”.
• El bound los une: “cualquier tipo T que tenga la capacidad X”.

Ese T: Trait es el átomo de la abstracción en Rust, y sustituye a la herencia. Donde un lenguaje de clases dice “B es un A” y organiza el mundo en jerarquías, Rust dice “T sabe hacer X” y compone capacidades. No preguntas de qué desciende un tipo, sino qué es capaz de hacer. Y gracias a la monomorfización del nivel anterior, toda esta abstracción es de coste cero: se resuelve en compilación y se evapora en el binario.

flowchart TB
trait[Trait define una capacidad] --> bound[Bound T dos puntos Trait]
gen[Generico abstrae sobre todo T] --> bound
bound --> idea[Para todo T que sepa hacer X]
idea --> mono[Monomorfizacion resuelve en compilacion]
mono --> abs[Sistema de abstraccion de coste cero]
style bound fill:#cba6f7,color:#11111b
style idea fill:#89b4fa,color:#11111b
style abs fill:#a6e3a1,color:#11111b