Lifetime Elision

Lifetime elision lets you omit explicit 'a annotations in common patterns. The compiler applies three rules to infer relationships between references in function signatures.

Recipe

fn first_word(s: &str) -> &str {
    s.split_whitespace().next().unwrap_or("")
}
 
fn main() {
    let line = String::from("hello world");
    println!("{}", first_word(&line));
}

When to reach for this: Writing clean APIs without redundant 'a when the elision rules cover your signature.

Working Example

struct Buffer<'a> { data: &'a [u8] }
 
impl<'a> Buffer<'a> {
    fn get(&self, i: usize) -> Option<&u8> {
        self.data.get(i)
    }
 
    fn slice(&self, range: std::ops::Range<usize>) -> Option<&[u8]> {
        self.data.get(range)
    }
}
 
fn main() {
    let bytes = [1u8, 2, 3];
    let buf = Buffer { data: &bytes };
    println!("{:?}", buf.slice(0..2));
}

What this demonstrates:

• Method elision ties returned refs to &self lifetime
• No explicit 'a on get or slice signatures
• Returned borrows cannot outlive buf
• impl<'a> still required on struct with lifetime param

Deep Dive

The Three Elision Rules

1. Each elided input reference gets a distinct lifetime parameter
2. If exactly one input lifetime (or &self), it is assigned to all outputs
3. If multiple input lifetimes but &self, output borrows from self

Examples

// Elided: fn foo(s: &str) -> &str
// Desugared: fn foo<'a>(s: &'a str) -> &'a str
 
// Elided method: fn bar(&self, x: &str) -> &str
// Output borrows from self, not x (rule 3)

When Elision Fails

• Multiple input refs and return ref without &self - must annotate
• Struct definitions with references - usually explicit lifetimes
• Complex higher-ranked trait bounds

Gotchas

• Assuming return borrows from any parameter - Only elision rules decide. Fix: Annotate when multiple inputs compete.
• Method returning ref from argument not self - Needs explicit lifetimes. Fix: fn merge<'a>(&self, other: &'a str) -> &'a str etc.
• Confusing elision with inference inside body - Elision is signature-only. Fix: Body inference is separate.
• Changing &self to &mut self subtly - Elision still applies but borrow rules differ. Fix: Re-check conflicts.
• Trait methods without elision guarantee across editions - Read trait docs. Fix: Explicit lifetimes on public traits for clarity.

Alternatives

FAQs

Related

• Lifetime Annotations - explicit 'a
• Lifetimes Explained - concepts
• Non-Lexical Lifetimes & Reborrows - loan end points
• The Borrow Checker - enforcement

External Related Links

• The Rust Programming Language (The Book) - Canonical beginner-to-intermediate guide (ownership, borrowing, traits, etc.).
• The Rust Reference - Formal language reference (precise semantics).
• Rust By Example - Runnable examples covering language features and standard library.
• The Rust Programming Language, 2nd Edition (Amazon) - Steve Klabnik & Carol Nichols.
• Programming Rust, 2nd Edition (O'Reilly) - Same Programming Rust on O'Reilly.

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+. 636f64656775696465732e696f7c6367696f3231377c323032363037