Bounds múltiples y la cláusula where: firmas legibles

Una capacidad rara vez basta. Una función que ordena e imprime necesita que su tipo sepa comparar y mostrarse; una que serializa y clona necesita ambas cosas. Rust te deja acumular restricciones con el operador +, pero cuando son muchas la firma se vuelve un muro ilegible. La cláusula where rescata la legibilidad y, de paso, desbloquea restricciones que en línea ni siquiera se pueden escribir. Aprender a leer un bloque where es aprender a leer la especificación exacta de lo que una función exige.

Varias capacidades con el operador +

Para exigir más de un trait a la vez, encadénalos con +:

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

fn describir<T: Display + Debug>(x: T) {
    println!("humano: {x}");     // usa Display
    println!("depuracion: {x:?}"); // usa Debug
}

T: Display + Debug se lee “para todo T que implemente a la vez Display y Debug”. El cuerpo puede usar cualquiera de las dos capacidades porque el bound garantiza que ambas están presentes. La misma sintaxis funciona con impl Trait:

fn describir_impl(x: impl Display + Debug) {
    println!("{x} / {x:?}");
}

Ciertas combinaciones de capacidades reaparecen tanto que se vuelven vocabulario fijo del ecosistema:

Cuando la firma se satura

Con dos parámetros y varios bounds cada uno, la firma en línea se convierte en una sola línea kilométrica que hay que descifrar antes de llegar al cuerpo:

fn combinar<T: Display + Clone, U: Display + Clone + Default>(a: T, b: U) -> String {
    format!("{a} y {b}")
}

La cláusula where extrae las restricciones y las coloca en un bloque aparte, dejando la lista de parámetros limpia:

fn combinar<T, U>(a: T, b: U) -> String
where
    T: Display + Clone,
    U: Display + Clone + Default,
{
    format!("{a} y {b}")
}

Ambas firmas son idénticas para el compilador: where es la forma general, y los bounds en línea son azúcar para el caso simple. Pero la versión con where se lee de un vistazo —“aquí están los parámetros, allí están sus obligaciones”— y escala sin ensuciar la firma. La convención en la biblioteca estándar y en el ecosistema es clara: en cuanto haya más de un bound por parámetro, usa where.

En una función realista, la cláusula reúne obligaciones sobre varios parámetros a la vez y sobre lo que estos producen:

fn procesar<I, T>(entrada: I) -> Vec<String>
where
    I: IntoIterator<Item = T>,
    T: Display + Clone,
{
    entrada.into_iter().map(|x| format!("[{x}]")).collect()
}

Leída de arriba abajo, la firma dice: “dame cualquier cosa iterable cuyos elementos se puedan mostrar y clonar, y te devuelvo un vector de cadenas”. El bloque where es esa frase traducida al lenguaje de los traits.

flowchart TB
firma[firma generica con varios parametros] --> w[clausula where]
w --> o1[obligacion I implementa IntoIterator]
w --> o2[obligacion el Item implementa Display]
w --> o3[obligacion T implementa Clone]
o1 --> sitio[el compilador verifica cada obligacion en cada llamada]
o2 --> sitio
o3 --> sitio

Lo que where puede y los bounds en línea no

Aquí está la razón de fondo para conocer where más allá de la estética: es estrictamente más expresivo. Los bounds en línea solo pueden restringir a los propios parámetros de tipo (T, U). La cláusula where puede restringir tipos arbitrarios construidos a partir de ellos, como un tipo asociado o un tipo compuesto:

fn imprimir_todo<I>(iter: I)
where
    I: IntoIterator,
    I::Item: Display,      // restringe el tipo ASOCIADO, imposible en linea
{
    for x in iter {
        println!("- {x}");
    }
}

La restricción I::Item: Display no habla de I, sino del tipo que I produce al iterarse. Ese tipo asociado no tiene un nombre en la lista de parámetros, así que no hay forma de escribir el bound entre los <...>; solo la cláusula where puede referirse a él. Lo mismo ocurre con bounds sobre tipos compuestos como Vec<T>: SomeTrait o for<'a> &'a T: Iterator. La forma en línea es un subconjunto; where es el mecanismo completo.

La cláusula where no es exclusiva de las funciones: aparece igual en bloques impl, donde condiciona qué métodos existen según las capacidades del tipo envuelto:

struct Envoltorio<T>(T);

impl<T> Envoltorio<T>
where
    T: Display + Clone,
{
    fn mostrar_doble(&self) {
        println!("{} / {}", self.0, self.0.clone());
    }
}

mostrar_doble solo existe cuando el T interior cumple las obligaciones; un Envoltorio de un tipo que no las cumpla sigue siendo válido, pero carece de ese método. Las cláusulas where son, en todas sus posiciones, el mismo mecanismo de enunciar prerrequisitos.