Rust error E0106: missing lifetime specifier

Q: How do I fix E0106 (missing lifetime specifier)?

Name the lifetime: Say which input the output borrows from. Give the struct a lifetime: Or store an owned String and skip lifetimes entirely. Return an owned value: If nothing is borrowed from the inputs, return String, not &str.

What it meansA reference in a struct field or a return type needs a lifetime, and Rust cannot work out which input it borrows from.

What rustc prints

error[E0106]: missing lifetime specifier
 --> main.rs:1:18
  |
1 | struct Foo1 { x: &bool }
  |                  ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 | struct Foo1<'a> { x: &'a bool }
  |            ++++       ++

Real output of rustc 1.99.0 compiling the official example below (2021 edition). Your names and line numbers will differ; the first line is the part to match.

Why it happens

A struct with a &str or &T field and no <'a>.
A function with two reference parameters that returns a reference.
A function with no reference parameters that returns a reference (usually a sign it should return an owned value).

How to fix it

1. Name the lifetime

Say which input the output borrows from.

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

2. Give the struct a lifetime

Or store an owned String and skip lifetimes entirely.

struct Token<'a> { text: &'a str }
// or
struct Token { text: String }

3. Return an owned value

If nothing is borrowed from the inputs, return String, not &str.

fn greeting() -> String { "hello".to_string() }

Other wordings of this error

missing lifetime specifier, expected named lifetime parameter, this function's return type contains a borrowed value

E0106Ownership and borrowing

Activein rustc 1.99.0

6related errors linked below

The compiler team's explanation

This error indicates that a lifetime is missing from a type. If it is an error inside a function signature, the problem may be with failing to adhere to the lifetime elision rules (see below).

Erroneous code examples:

struct Foo1 { x: &bool }
              // ^ expected lifetime parameter
struct Foo2<'a> { x: &'a bool } // correct

struct Bar1 { x: Foo2 }
              // ^^^^ expected lifetime parameter
struct Bar2<'a> { x: Foo2<'a> } // correct

enum Baz1 { A(u8), B(&bool), }
                  // ^ expected lifetime parameter
enum Baz2<'a> { A(u8), B(&'a bool), } // correct

type MyStr1 = &str;
           // ^ expected lifetime parameter
type MyStr2<'a> = &'a str; // correct

Lifetime elision is a special, limited kind of inference for lifetimes in function signatures which allows you to leave out lifetimes in certain cases. For more background on lifetime elision see the book.

The lifetime elision rules require that any function signature with an elided output lifetime must either have:

exactly one input lifetime
or, multiple input lifetimes, but the function must also be a method with a &self or &mut self receiver

In the first case, the output lifetime is inferred to be the same as the unique input lifetime. In the second case, the lifetime is instead inferred to be the same as the lifetime on &self or &mut self.

Here are some examples of elision errors:

// error, no input lifetimes
fn foo() -> &str { }

// error, `x` and `y` have distinct lifetimes inferred
fn bar(x: &str, y: &str) -> &str { }

// error, `y`'s lifetime is inferred to be distinct from `x`'s
fn baz<'a>(x: &'a str, y: &str) -> &str { }

From rustc --explain E0106 (1.99.0), part of the Rust project, MIT or Apache-2.0. Official page.

Up next

Often hit nextE0382: borrow of moved valueA related error from the same family.Read it next →

Also worth your time

Did this answer your question?