Lifetime error only when function written as a closure

There seems to be a difference in lifetime inference between normal functions and functions defined as closures. Consider the following minimal example:

fn foo(f: &String) -> &str {
    f
}

fn bar() {
    |f: &String| -> &str { f };
}

The compiler (Rustc 1.69.0 with --edition=2021) accepts foo, but rejects the closure in bar (which is the same function as foo) with the error

error: lifetime may not live long enough
 --> clos.rs:8:33
  |
8 |     move |f: &String| -> &str { f };
  |              -           -      ^ returning this value requires that `'1` must outlive `'2`
  |              |           |
  |              |           let's call the lifetime of this reference `'2`
  |              let's call the lifetime of this reference `'1`

In the case of foo, my understanding is that the compiler desugars it to

fn foo<'a>(f: &'a String) -> &'a str { ... }

Why doesn't it do the same for the closure? And is there some way I can manually specify the lifetimes myself (in particular, where would I place the <'a> to declare the lifetime)?

I think this is because for functions, there is never any captured state, therefore the lifetimes of the input and output are almost always connected. For closures, the lifetimes could be from the environment.

You can make a function that generates the closure, which lets you use impl Fn syntax, which seems to infer lifetimes correctly, at least in this case. If you capture any state, you will need to pass that as an argument to the generator function.

fn generate() -> impl Fn(&String) -> &str {
    |f: &String| -> &str { f }
}

If it doesn't work for a certain case, you can use for syntax to specify the lifetimes explicitly.

fn generate_for() -> impl for<'a> Fn(&'a String) -> &'a str {
    |f: &String| -> &str { f }
}

There's a nightly feature for this: closure_lifetime_binder. When stabilized, it will allow you to add for annotations to closure expressions instead of only to traits.

#![feature(closure_lifetime_binder)]

fn bar_nightly() {
    for<'a> |f: &'a String| -> &'a str { f };
}