## 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 E0482

#### Note: this error code is no longer emitted by the compiler.

A lifetime of a returned value does not outlive the function call.

Erroneous code example:

    #![allow(unused)]
    fn main() {
    fn prefix<'a>(
        words: impl Iterator<Item = &'a str>
    ) -> impl Iterator<Item = String> { // error!
        words.map(|v| format!("foo-{}", v))
    }
    }

To fix this error, make the lifetime of the returned value explicit:

    #![allow(unused)]
    fn main() {
    fn prefix<'a>(
        words: impl Iterator<Item = &'a str> + 'a
    ) -> impl Iterator<Item = String> + 'a { // ok!
        words.map(|v| format!("foo-{}", v))
    }
    }

The `impl Trait` feature in this example uses an implicit `'static` lifetime restriction in the returned type. However the type implementing the `Iterator` passed to the function lives just as long as `'a`, which is not long enough.

The solution involves adding lifetime bound to both function argument and the return value to make sure that the values inside the iterator are not dropped when the function goes out of the scope.

An alternative solution would be to guarantee that the `Item` references in the iterator are alive for the whole lifetime of the program.

    #![allow(unused)]
    fn main() {
    fn prefix(
        words: impl Iterator<Item = &'static str>
    ) -> impl Iterator<Item = String> {  // ok!
        words.map(|v| format!("foo-{}", v))
    }
    }

A similar lifetime problem might arise when returning closures:

    #![allow(unused)]
    fn main() {
    fn foo(
        x: &mut Vec<i32>
    ) -> impl FnMut(&mut Vec<i32>) -> &[i32] { // error!
        |y| {
            y.append(x);
            y
        }
    }
    }

Analogically, a solution here is to use explicit return lifetime and move the ownership of the variable to the closure.

    #![allow(unused)]
    fn main() {
    fn foo<'a>(
        x: &'a mut Vec<i32>
    ) -> impl FnMut(&mut Vec<i32>) -> &[i32] + 'a { // ok!
        move |y| {
            y.append(x);
            y
        }
    }
    }

To better understand the lifetime treatment in the `impl Trait`, please see the RFC 1951.