Generic for FnOnce that returns a future with a lifetime

Question

I have a struct that needs a callback that returns a future whose output has a lifetime:

struct Foo;
struct Bar;

struct Baz<F>
where F: for<'a> FnOnce(&'a Foo) -> impl std::future::Future<Output=&'a Bar> // ?
{
    cb: F
}

That doesn't compile, with a syntax error since impl can't appear in trait bounds:

   Compiling playground v0.0.1 (/playground)
error[E0562]: `impl Trait` not allowed outside of function and inherent method return types
 --> src/lib.rs:6:37
  |
6 | where F: for<'a> FnOnce(&'a Foo) -> impl std::future::Future<Output=&'a Bar>,
  |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: aborting due to previous error

This doesn't compile either:

struct Foo;
struct Bar;

struct Baz<O, F>
where
    O: for<'a> std::future::Future<Output=&'a Bar>,
    F: for<'b> FnOnce(&'b Foo) -> O,
{
    cb: F
}

Complaining that 'a isn't recognized (and the lifetimes 'a and 'b would be unrelated):

   Compiling playground v0.0.1 (/playground)
error[E0582]: binding for associated type `Output` references lifetime `'a`, which does not appear in the trait input types
 --> src/lib.rs:7:36
  |
7 |     O: for<'a> std::future::Future<Output=&'a Bar>,
  |                                    ^^^^^^^^^^^^^^

error: aborting due to previous error

Is there a way to specify this relationship?

Answer 1

It's a bit ugly, but this is the best way I could find (using struct Foo(Bar) for demonstration):

Playground

use std::future::Future;

struct Bar;
struct Foo(Bar);

trait FooClosure<'a> {
    type Fut: Future<Output = &'a Bar>;

    fn call(self, foo: &'a Foo) -> Self::Fut;
}

impl<'a, Fut: Future<Output = &'a Bar>, C: FnOnce(&'a Foo) -> Fut> FooClosure<'a> for C {
    type Fut = Fut;

    fn call(self, foo: &'a Foo) -> Fut {
        self(foo)
    }
}

struct Baz<F: for<'a> FooClosure<'a>>(F);

fn main() {
    let closure: Box<dyn for<'a> FnOnce(&'a Foo) -> futures::future::Ready<&'a Bar>> =
        Box::new(|foo| futures::future::ready(&foo.0));
    let baz = Baz(closure);
}

I couldn't get the compiler to infer the types properly, so I had to wrap the closure as boxed trait object. Theoretically this shouldn't be necessary, and there might be a way to avoid this but I couldn't figure it out.

Note: I think there are plans to make your original code work without needing this trait black magic.

Answer 2

A straightforward way to do this is to parameterize the struct Baz itself with the lifetime parameter:

struct Baz<'a, O: Future<Output=&'a Bar>, F: FnOnce(&'a Foo) -> O> {
    cb: F,
    phantom: PhantomData<&'a O>,
}

The PhantomData instance is required to "use" the lifetime parameter 'a and the output type parameter O. You can think of O and 'a as components of the closure type F -- they will always be implicitly inferred from the lifetime and return type used by F.

Playground