Rust by Example

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

See also:

traits

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 used after keyword where:

use std::fmt::Debug; // Trait to bound with.

#[derive(Debug)]

struct Ref<'a, T: 'a>(&'a T);

// `Ref` contains a reference to a generic type `T` that has

// an unknown lifetime `'a`. `T` is bounded such that any

// *references* in `T` must outlive `'a`. Additionally, the lifetime

// of `Ref` may not exceed `'a`.

// A generic function which prints using the `Debug` trait.

fn print(t: T) where

T: Debug {

println!("`print`: t is {:?}", t);

}

// Here a reference to `T` is taken where `T` implements

// `Debug` and all *references* in `T` outlive `'a`. In

// addition, `'a` must outlive the function.

fn print_ref<'a, T>(t: &'a T) where

T: Debug + 'a {

println!("`print_ref`: t is {:?}", t);

}

fn main() {

let x = 7;

let ref_x = Ref(&x);

print_ref(&ref_x);

print(ref_x);

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

See also:

generics, bounds in generics, and multiple bounds in generics

Coercion

A longer lifetime can be coerced into a shorter one so that it works inside a scope it normally wouldn't work in. This comes in the form of inferred coercion by the Rust compiler, and also in the form of declaring a lifetime difference:

// Here, Rust infers a lifetime that is as short as possible.

// The two references are then coerced to that lifetime.

fn multiply<'a>(first: &'a i32, second: &'a i32) -> i32 {

first * second

}

// `<'a: 'b, 'b>` reads as lifetime `'a` is at least as long as `'b`.

// Here, we take in an `&'a i32` and return a `&'b i32` as a result of coercion.

fn choose_first<'a: 'b, 'b>(first: &'a i32, _: &'b i32) -> &'b i32 {

first

}

fn main() {

let first = 2; // Longer lifetime

{

let second = 3; // Shorter lifetime

println!("The product is {}", multiply(&first, &second));