asynchronous - 生命周期绑定(bind)在异步函数中，这也是一个参数

Question

我正在尝试将异步函数作为参数传递。异步函数在争论时接受引用。

use std::future::Future;

async fn f(x: &i32) -> i32 {
    todo!()
}

async fn g<F, Fut>(f: F)
where
    F: Send + Sync + 'static + for<'a> Fn(&'a i32) -> Fut,
    Fut: Future<Output = i32> + Send + Sync,
{
//    let x = 3;
//    f(&x).await;
}

#[tokio::main]
async fn main() {
    g(f).await;
}

但是我有编译错误。

error[E0308]: mismatched types
  --> src/main.rs:18:5
   |
18 |     g(f).await;
   |     ^ lifetime mismatch
   |
   = note: expected associated type `<for<'_> fn(&i32) -> impl Future<Output = i32> {f} as FnOnce<(&i32,)>>::Output`
              found associated type `<for<'_> fn(&i32) -> impl Future<Output = i32> {f} as FnOnce<(&'a i32,)>>::Output`
   = note: the required lifetime does not necessarily outlive the empty lifetime
note: the lifetime requirement is introduced here
  --> src/main.rs:9:55
   |
9  |     F: Send + Sync + 'static + for<'a> Fn(&'a i32) -> Fut,
   |                                                       ^^^

For more information about this error, try `rustc --explain E0308`.
error: could not compile `test-async-tokio` due to previous error

Fut这里为什么要引入lifetime呢？如何指定此代码的生命周期？

最好的问候!

Answer 1

从进一步的测试来看，我原来的更改 'a 的建议似乎是正确的。来自 for<'a> 的生命周期参数绑定(bind)到适当泛型参数的 trait 上的子句导致编译器认为生命周期存在于返回的 future 中，从而防止使用局部变量。即使我明确应用 'a 似乎也是如此。终身绑定(bind)到 Fut并等待结果。

我不完全确定为什么你建立的特征界限不起作用，但我相信这是由于异步函数返回 impl Future 造成的。而不是已知的具体类型。我遇到这个问题时与您的原始代码有一些偏差。 This source似乎是您问题的解决方案，我在下面包含了针对您的特定用例的修改示例。 注意:我重命名了 f参数为 y强调它没有调用 f直接运行。

此解决方案添加了一个新特征(带有一揽子实现)，可用作 F 的特征绑定(bind)直接用for<'a>如果输入/输出是引用，则需要子句。我可能弄错了，但这似乎可行，因为未知的具体 future 类型作为关联类型被包装到新特征中，所以 g并且它的 trait bounds 不需要直接担心它。

use std::future::Future;

trait AsyncFn<T>: Fn(T) -> <Self as AsyncFn<T>>::Fut {
    type Fut: Future<Output = <Self as AsyncFn<T>>::Output>;
    type Output;
}
impl<T, F, Fut> AsyncFn<T> for F where F: Fn(T) -> Fut, Fut: Future {
    type Fut = Fut;
    type Output = Fut::Output;
}

async fn f(_: &i32) -> i32 {
    todo!()
}

async fn g<F>(y: F) where F: for<'a> AsyncFn<&'a i32, Output = i32> {
    let x = 3;
    let res = y(&x).await;
}

#[tokio::main]
async fn main() {
    g(f).await;
}