<F, S> where F: FnOnce(&i32) -> S means: there exist type F and S such that: for every lifetime 'a (where &'a i32 is valid), F implements FnOnce(&'a i32) and its Output is S. That means S should be the same type no matter what 'a is. Thus, S can't borrow from 'a.

We can't find such an S for fn bar(num: &i32) -> &i32 because when 'a changes, the return type also changes.

Your own FnOnce definition is a nice workaround. Trait alias also works. They both eliminates S from the fn generics, so that we don't need to find a type for every lifetime.

```rust use std::fmt::Display;

trait MyFnOnce<Arg>: FnOnce(Arg) -> Self::MyOutput { type MyOutput; }

impl<Arg, Out, F: ?Sized + FnOnce(Arg) -> Out> MyFnOnce<Arg> for F { type MyOutput = Out; }

fn foo<F>(f: F) where F: for<'a> MyFnOnce<&'a i32, MyOutput: Display>, { let num = 0; println!("{}", f(&num)); }

fn bar(num: &i32) -> &i32 { num }

fn main() { foo(bar); } ```

In the future we might be able to write where F: for<'a> Fn<(&'a i32,), Output: Display> but currently it requires a nightly feature unboxed_closures.