Vínculos

Al igual que los tipos genéricos pueden estar enlazados, las vidas útiles (en sí mismas genéricas) también usan vínculos. El carácter : tiene un significado ligeramente diferente aquí, pero + es el mismo. Ten en cuenta cómo se lee lo siguiente:

  1. T: 'a: Todas las referencias en T deben sobrevivir a la vida útil de 'a.
  2. T: Rasgo + 'a: El tipo T debe implementar el rasgo Rasgo y todas las referencias en T debe sobrevivir a 'a.

El siguiente ejemplo muestra la sintaxis anterior en acción utilizada después de la palabra clave where:

use std::fmt::Debug; // Rasgo con el que vincularse.

#[derive(Debug)]
struct Ref<'a, T: 'a>(&'a T);
// `Ref` contiene una referencia a un tipo genérico `T` que tiene una vida útil 
// desconocida `'a`. `T` está vinculado de tal manera que cualquier *referencia* en `T`
// deben sobrevivir a` 'a`. Además, la vida útil de `Ref` no puede exceder la de `'a`.

// Una función genérica que imprime usando el rasgo `Debug`.
fn imprime<T>(t: T) where
    T: Debug {
    println!("`imprime`: t es {:?}", t);
}

// Aquí se toma una referencia a `T` donde` T` implementa `Debug` y todas las
// *referencias* en `T` sobreviven a `'a`. Además, `'a` debe sobrevivir a la función.
fn imprime_ref<'a, T>(t: &'a T) where
    T: Debug + 'a {
    println!("`imprime_ref`: t es {:?}", t);
}

fn main() {
    let x = 7;
    let ref_x = Ref(&x);

    imprime_ref(&ref_x);
    imprime(ref_x);
}

Ve también

tipos genéricos, vínculos en tipos genéricos, y vínculos múltiples en tipos genéricos