Los Higher-Ranked Trait Bounds (HRTB) son una característica avanzada de Rust que permite definir límites de rasgos (trait bounds) que son universales sobre todos los lifetimes posibles. En Rust estándar, cuando declaras una función genérica con un lifetime 'a, dicho lifetime se determina en el momento en que se llama a la función. Sin embargo, a veces necesitamos que un parámetro (como un closure) sea capaz de operar con cualquier lifetime que se le presente, no solo con uno específico decidido por el llamador.

La sintaxis for<'a> es la clave de los HRTB. Representa un cuantificador universal: “para cualquier lifetime ‘a que el llamador decida en el momento de la ejecución”. Sin los HRTB, si intentas pasar un closure que recibe una referencia a un lifetime genérico a una función, el compilador intentará unificar ese lifetime con un único lifetime específico de la función contenedora, provocando errores de “lifetime mismatch”.

Es crucial distinguir HRTB de las relaciones de “outlives” ('a: 'b). Mientras que 'a: 'b establece que 'a debe durar al menos tanto como 'b, for<'a> establece que el comportamiento del trait debe ser válido para absolutamente cualquier lifetime, incluso aquellos que se crean y destruyen dentro de un scope local de la función que recibe el trait. Un caso común de uso (y desugaring) ocurre con los traits Fn. Por ejemplo, Box<dyn Fn(&str) -> bool> es en realidad una abreviatura de Box<dyn for<'a> Fn(&'a str) -> bool>, asegurando que el closure pueda procesar cualquier referencia de cadena, sin importar su duración.

Si se intenta usar un lifetime específico en lugar de un HRTB cuando el closure necesita ser polimórfico sobre lifetimes, el compilador emitirá un error indicando que el lifetime del argumento no coincide con el lifetime esperado, ya que el compilador no puede garantizar que el closure sea válido para todos los posibles contextos de tiempo de vida.

// Una función que acepta un closure genérico mediante HRTB
fn ejecutar_callback<F>(callback: F)
where
    // HRTB: El trait Fn debe ser válido para CUALQUIER lifetime 'a
    F: for<'a> Fn(&'a str) -> &'a str,
{
    let texto_corto = String::from("Corto");
    let texto_largo = String::from("Mucho más largo");

    // La función 'callback' se llama con el lifetime de 'texto_corto'
    let res1 = callback(&texto_corto);
    println!("Resultado 1: {}", res1);

    // La función 'callback' se llama con el lifetime de 'texto_largo'
    // Si no usáramos HRTB, esto fallaría porque 'texto_largo' 
    // tendría un lifetime distinto al de 'texto_corto'
    let res2 = callback(&texto_largo);
    println!("Resultado 2: {}", res2);
}

fn main() {
    // Un closure que simplemente devuelve la referencia recibida
    // Este closure es compatible con HRTB porque funciona para cualquier lifetime
    let identity = |s: &str| s;

    ejecutar_callback(identity);

    // Otro closure que transforma el texto (simulado)
    let transformar = |s: &str| {
        // El compilador verifica que la firma sea compatible con for<'a> Fn(&'a str) -> &'a str
        s
    };

    ejecutar_callback(transformar);
}

Explicación del Código


– La función ejecutar_callback<F> es genérica sobre el tipo F.
– El bound F: for<'a> Fn(&'a str) -> &'a str es el núcleo del HRTB. Indica que el parámetro callback debe implementar el trait Fn de tal manera que pueda aceptar una referencia de cualquier lifetime 'a y devolver una referencia de ese mismo lifetime 'a.
– Dentro de ejecutar_callback, texto_corto y texto_largo tienen scopes distintos. Al llamar a callback(&texto_corto), el lifetime 'a se especializa para el tiempo de vida de texto_corto.
– Al llamar a callback(&texto_largo), el lifetime 'a se especializa para el tiempo de vida de texto_largo. Gracias al cuantificador for<'a>, callback es capaz de adaptarse a ambos sin conflictos de unificación de lifetimes.
– En main, el closure identity tiene una firma implícita que permite la inferencia de lifetimes, haciéndolo compatible con la restricción de “alto rango” definida en ejecutar_callback.

N° 108