Bounds

Just like generic types can be bounded, lifetimes (themselves generic)
use bounds as well. The : character has a slightly different meaning here,
but + is the same. Note how the following read:

  1. T: 'a: All references in T must outlive lifetime 'a.
  2. T: Trait + 'a: Type T must implement trait Trait and all references
    in T must outlive 'a.

The example below shows the above syntax in action:

  1. use std::fmt::Debug; // Trait to bound with.
  3. #[derive(Debug)]
  4. struct Ref<'a, T: 'a>(&'a T);
  5. // `Ref` contains a reference to a generic type `T` that has
  6. // an unknown lifetime `'a`. `T` is bounded such that any
  7. // *references* in `T` must outlive `'a`. Additionally, the lifetime
  8. // of `Ref` may not exceed `'a`.
  10. // A generic function which prints using the `Debug` trait.
  11. fn print<T>(t: T) where
  12.     T: Debug {
  13.     println!("`print`: t is {:?}", t);
  14. }
  16. // Here a reference to `T` is taken where `T` implements
  17. // `Debug` and all *references* in `T` outlive `'a`. In
  18. // addition, `'a` must outlive the function.
  19. fn print_ref<'a, T>(t: &'a T) where
  20.     T: Debug + 'a {
  21.     println!("`print_ref`: t is {:?}", t);
  22. }
  24. fn main() {
  25.     let x = 7;
  26.     let ref_x = Ref(&x);
  28.     print_ref(&ref_x);
  29.     print(ref_x);
  30. }

See also:

generics, bounds in generics, and
multiple bounds in generics