Lifetimes Explained

A lifetime is the span during which a reference is valid. Lifetime parameters like 'a relate references in function signatures and structs so the compiler can reject dangling pointers.

Recipe

fn first<'a>(items: &'a [i32]) -> Option<&'a i32> {
    items.first()
}
 
fn main() {
    let data = vec![3, 1, 4];
    println!("{:?}", first(&data));
}

When to reach for this: Returning references from functions, storing references in structs, or understanding "does not live long enough" errors.

Working Example

struct Excerpt<'a> {
    text: &'a str,
}
 
fn excerpt<'a>(full: &'a str, end: usize) -> Excerpt<'a> {
    Excerpt { text: &full[..end.min(full.len())] }
}
 
fn main() {
    let article = String::from("Rust lifetimes are compile-time checks.");
    let e = excerpt(&article, 4);
    println!("{}", e.text);
}

What this demonstrates:

• Struct holding a reference needs a lifetime parameter
• Excerpt<'a> cannot outlive the String it borrows
• Returned excerpt borrows from full input
• Lifetime connects struct field to source data

Deep Dive

How It Works

• Every reference has an inferred or explicit lifetime
• Lifetime 'a means "valid for some region at least as long as 'a"
• Subtyping: longer-lived data can satisfy shorter lifetime requirements
• Lifetimes are not stored at runtime

Why They Exist

Without lifetimes, this would compile unsafely:

// impossible in safe Rust
// fn dangle() -> &str { let s = String::from("x"); &s }

Relationship to Ownership

• Owner dropped -> borrows end
• Lifetimes encode ordering constraints between owners and borrowers
• 'static is the longest lifetime (entire program)

Gotchas

• Thinking lifetimes change runtime behavior - They are static analysis only. Fix: Focus on borrow regions, not runtime timers.
• Over-annotating every reference - Elision covers common cases. Fix: Annotate when compiler asks or signatures are public API.
• Returning reference from if with different locals - Unified lifetime may fail. Fix: Return owned value or ensure both arms borrow same source.
• Self-referential structs without care - Classic pitfall. Fix: Use indices, Pin, or owned graph (Rc).
• Confusing 'static with immortality - Means valid for program duration, not that data never frees if leaked differently. Fix: Read 'static page.

Alternatives

FAQs

Related

• Lifetime Annotations - writing 'a
• Lifetime Elision - omission rules
• 'static & Bounds - 'static meaning
• Borrowing & References - loan rules

Stack versions: This page was written for Rust 1.97.0 (edition 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, and Polars 0.46+.