Async 函数中的生命周期限制，这也是一个参数

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

从进一步的测试来看，我最初的建议似乎是将特征上的 for<'a> 子句中的 'a 生命周期参数更改为绑定到适当的泛型参数，这导致编译器认为生命周期存在于返回的未来中，这可以防止使用本地人。即使我明确地将'a 生命周期绑定到Fut 并等待结果，情况似乎也是如此。

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

此解决方案添加了一个新特征（带有全面 impl），可以直接用作F 的特征绑定，如果输入/输出是引用，则需要 for<'a> 子句。我可能弄错了，但这似乎可行，因为未知的具体未来类型作为关联类型被包装到新特征中，因此 g 及其特征边界不需要直接担心。

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;
}