lifetime mismatch

The “lifetime mismatch” error in Rust means the compiler determined that a reference may outlive the data it points to, or that two references with different lifetimes were used where matching lifetimes are required. Lifetimes are Rust’s mechanism for ensuring all references are valid.

What It Means

Every reference in Rust has a lifetime — the scope during which the borrowed data remains valid. The compiler tracks these lifetimes to prevent dangling references. When you return a reference from a function, store a reference in a struct, or pass multiple references, the lifetimes must align.

Why It Happens

• A function returns a reference to data that was created inside the function.
• A struct contains a reference without a lifetime parameter.
• Two references in a function signature have different inferred lifetimes.
• You passed a reference with one lifetime where another lifetime was expected.
• The compiler cannot infer the relationship between input and output lifetimes.

How to Fix It

1. Add lifetime parameters to functions

When a function returns a reference, annotate the lifetimes:

// Error: missing lifetime specifier
fn first_word(s: &str) -> &str {
    s.split_whitespace().next().unwrap()
}

// Fix: add lifetime annotation
fn first_word<'a>(s: &'a str) -> &'a str {
    s.split_whitespace().next().unwrap()
}

The 'a annotation tells the compiler that the returned reference lives as long as the input reference.

2. Add lifetime parameters to structs

Structs that hold references need lifetime annotations:

// Error: missing lifetime specifier
struct Config {
    name: &str,
}

// Fix: add lifetime parameter
struct Config<'a> {
    name: &'a str,
}

3. Do not return references to local data

A reference to a function-local variable is always invalid:

// Error: returns reference to local data
fn get_message() -> &str {
    let msg = String::from("hello");
    &msg // msg is dropped when function returns
}

// Fix: return an owned type
fn get_message() -> String {
    String::from("hello")
}

4. Use the same lifetime for related references

When multiple references must live as long as each other:

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

Both input references and the output share the same lifetime 'a.

5. Use lifetime elision rules

In many common patterns, Rust can infer lifetimes automatically:

// No annotation needed — elision rules apply
fn first_word(s: &str) -> &str {
    s.split_whitespace().next().unwrap()
}

// This is equivalent to: fn first_word<'a>(s: &'a str) -> &'a str

The elision rules cover: each input reference gets its own lifetime, and if there is exactly one input lifetime, the output uses it.

FAQ