Strange error message when trying to call a function that takes a closure that returns a future

[tljubej-tbtl]

Code

use std::future::Future;

fn bar<Fn, Res>(x: &i32, function: Fn) -> Res
where
    Res: Future<Output = i32>,
    Fn: FnOnce(&i32) -> Res,
{
    function(x)
}

async fn foo(x: &i32) -> i32 {
    x + 1
}

fn main() {
    bar(&1, foo);
}

Current output

error[E0308]: mismatched types
  --> lifetime-error-minimal-example/src/main.rs:16:5
   |
16 |     bar(&1, foo);
   |     ^^^^^^^^^^^^ one type is more general than the other
   |
   = note: expected opaque type `impl for<'a> Future<Output = i32>`
              found opaque type `impl Future<Output = i32>`
   = help: consider `await`ing on both `Future`s
   = note: distinct uses of `impl Trait` result in different opaque types
note: the lifetime requirement is introduced here
  --> lifetime-error-minimal-example/src/main.rs:6:25
   |
6  |     Fn: FnOnce(&i32) -> Res,
   |                         ^^^

For more information about this error, try `rustc --explain E0308`.
error: could not compile `lifetime-error-minimal-example` (bin "lifetime-error-minimal-example") due to 1 previous error

Desired output

The compiler should somehow warn me that I need to constrain the lifetime of `Res` to the lifetime of the `&i32`.

Rationale and extra context

If the main function looks like this:

fn main() {
    bar(&1, |x| foo(x));
}

The error message becomes more clear and closer to what I'd expect:

error: lifetime may not live long enough
  --> lifetime-error-minimal-example/src/main.rs:16:17
   |
16 |     bar(&1, |x| foo(x));
   |              -- ^^^^^^ returning this value requires that `'1` must outlive `'2`
   |              ||
   |              |return type of closure `impl Future<Output = i32>` contains a lifetime `'2`
   |              has type `&'1 i32`

Other cases

No response

Rust Version

rustc 1.77.2 (25ef9e3d8 2024-04-09)
binary: rustc
commit-hash: 25ef9e3d85d934b27d9dada2f9dd52b1dc63bb04
commit-date: 2024-04-09
host: aarch64-apple-darwin
release: 1.77.2
LLVM version: 17.0.6

Anything else?

No response

[compiler-errors]

This error message is (unfortunately) correct, though I would agree that it's not particularly helpful.

The technical reason why this code doesn't work is that there is no single future type Res that can represent the return type of the higher-ranked Fn trait for<'a>FnOnce(&'a i32) -> Res since Res would need to capture that lifetime 'a (like it does in the async fn foo).

On nightly, try using an async FnOnce trait goal like Fn: async FnOnce(&i32) -> i32.

[tljubej-tbtl]

Thanks for the response, I understand why this particular example doesn't compile, however I have a slightly expanded example that yields the same error that is closer to my actual codebase:

use std::future::Future;

fn bar<'a, Fn, Res>(x: &i32, function: Fn) -> i32
where
    Res: Future<Output = i32>,
    Fn: FnOnce(&i32) -> Res,
{
    run_future(function(x))
}

fn run_future(f: impl Future<Output = i32>) -> i32 {
    2
}

async fn foo(x: &i32) -> i32 {
    x + 1
}

fn main() {
    bar(&1, foo);
}

This yields the exact same error however I don't understand why since the Future from the closure is immediately consumed and is IMO guaranteed to not outlive the &i32 parameter, I don't understand why the compiler complains in this case.

The other thing that's weird to me is the error appears at call site and not within the actual function definition.

[compiler-errors]

That's because a where clause bound like Fn: FnOnce(&i32) -> Res is equivalent to Fn: for<'r> FnOnce(&'r i32) -> Res,, so it doesn't matter about the lifetime of other &i32 parameter passed into bar.

The explanation I gave above still is the reason why this doesn't work, and it's an error at the call-site because the foo parameter you pass in is what makes this code incompatible with the where-clauses you wrote.

The proper way to express this code would be:

use std::future::Future;

fn bar<'a, Fn>(x: &'a i32, function: Fn) -> i32
where
    Fn: async FnOnce(&'a i32) -> i32,
{
    run_future(function(x))
}

fn run_future(f: impl Future<Output = i32>) -> i32 {
    2
}

async fn foo(x: &i32) -> i32 {
    x + 1
}

fn main() {
    bar(&1, foo);
}

(or if you're on nightly, try: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=9bf1b5a8d16cad2c2a4baa8db645f534)

[traviscross]

@rustbot labels +AsyncAwait-Triaged

We discussed this one in async triage today. As @compiler-errors points out, async closures may be the more general future solution here.