Rust Lifetime Annotations Cheat Sheet

Rust lifetime annotations are confusing, especially when functions return references or structs hold references.

Lifetime annotation patterns:

// Function returning a reference must specify lifetime
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

// Struct holding references
struct Excerpt<'a> {
    text: &'a str,
}

impl<'a> Excerpt<'a> {
    fn level(&self) -> i32 { 3 }  // No lifetime needed (elision)
    fn announce(&self, msg: &str) -> &str {
        // Returns &self lifetime (elision rule 3)
        self.text
    }
}

// Multiple lifetimes
fn first_or_default<'a, 'b>(s: &'a str, default: &'b str) -> &'a str {
    if s.is_empty() { panic!("empty") } else { s }
}

// Static lifetime (lives for entire program)
let s: &'static str = "hello";

// Lifetime bounds on generics
fn print_it<T: std::fmt::Display + 'static>(val: T) {
    println!("{}", val);
}

Elision rules (when you DON'T need annotations):

1. Each reference param gets its own lifetime
2. If one input lifetime, output gets that lifetime
3. If &self or &mut self, output gets self's lifetime

Lifetimes ensure references are always valid. The borrow checker uses them to prevent dangling references at compile time, but the annotation syntax can be intimidating.

Working with references in Rust