生命周期绑定在异步函数中，这也是一个参数

Question

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

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> 子句更改为适当的泛型参数，导致编译器认为lifetime 存在于返回的 future 中，这可以防止使用 locals。即使我明确地将 'a 生命周期绑定到 Fut 并等待结果，情况似乎也是如此。

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

此解决方案添加了一个新特征（带有一揽子实现），可以直接用作 F 的特征绑定，如果 input/output 是参考。我可能弄错了，但这似乎可行，因为未知的具体未来类型作为关联类型被包装到新特征中，因此 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;
}

生命周期绑定在异步函数中，这也是一个参数

Lifetime bound in Async function which is also an argument

asynchronous

rust

arguments

lifetime