E0311 - Error codes index
Description: Book listing all Rust error codes

## Keyboard shortcuts

Press `←` or `→` to navigate between chapters

Press `S` or `/` to search in the book

Press `?` to show this help

Press `Esc` to hide this help

# Error code E0311

This error occurs when there is an unsatisfied outlives bound involving an elided region and a generic type parameter or associated type.

Erroneous code example:

    #![allow(unused)]
    fn main() {
    fn no_restriction<T>(x: &()) -> &() {
        with_restriction::<T>(x)
    }

    fn with_restriction<'a, T: 'a>(x: &'a ()) -> &'a () {
        x
    }
    }

Why doesn’t this code compile? It helps to look at the lifetime bounds that are automatically added by the compiler. For more details see the documentation for lifetime elision.

The compiler elides the lifetime of `x` and the return type to some arbitrary lifetime `'anon` in `no_restriction()`. The only information available to the compiler is that `'anon` is valid for the duration of the function. When calling `with_restriction()`, the compiler requires the completely unrelated type parameter `T` to outlive `'anon` because of the `T: 'a` bound in `with_restriction()`. This causes an error because `T` is not required to outlive `'anon` in `no_restriction()`.

If `no_restriction()` were to use `&T` instead of `&()` as an argument, the compiler would have added an implied bound, causing this to compile.

This error can be resolved by explicitly naming the elided lifetime for `x` and then explicitly requiring that the generic parameter `T` outlives that lifetime:

    #![allow(unused)]
    fn main() {
    fn no_restriction<'a, T: 'a>(x: &'a ()) -> &'a () {
        with_restriction::<T>(x)
    }

    fn with_restriction<'a, T: 'a>(x: &'a ()) -> &'a () {
        x
    }
    }