Understanding Rust Error E0106: Missing Lifetime in Type

Introduction to Rust Error E0106

Rust Error E0106 occurs when a lifetime is missing from a type. This error typically appears in function signatures, structs, enums, or type aliases that involve references, and it is caused by non-adherence to the lifetime elision rules.

Examples of Erroneous Code

The error code examples given in the documentation highlight various cases in which the E0106 error occurs, due to the absence of an expected lifetime parameter:

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 Rules

Lifetime elision is a form of inference in function signatures which allows you to omit lifetimes in specific cases. There are two scenarios in which the output lifetime of a function signature with an elided lifetime can be inferred:

1. The function has exactly one input lifetime.

2. The function has multiple input lifetimes but is a method with a &self or &mut self receiver.

Examples of Lifetime Elision Errors

Here are some examples of elision errors that may trigger Rust Error E0106:

// 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 { }

Resolving Rust Error E0106

To resolve Rust Error E0106, you need to ensure that the missing lifetime is explicitly added to the type. Review the code for structs, enums, or type aliases that involve references and make sure to adhere to the lifetime elision rules.