如何将异步函数存储在结构中并从结构实例调用它？

我正在尝试用新的方法来实现这一目标async/await句法，std::future::Futures 和最新版本的 Tokio。我正在使用东京0.2.0-alpha.4和铁锈1.39.0-nightly.

我尝试过的不同事情包括：

• using Box<dyn>s 代表我想要存储在结构中的类型
• 在结构体定义中使用泛型

我无法完全获得最小的工作版本，所以这是我想要实现的简化版本：

async fn foo(x: u8) -> u8 {
    2 * x
}

// type StorableAsyncFn = Fn(u8) -> dyn Future<Output = u8>;

struct S {
    f: StorableAsyncFn,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let s = S { f: foo };

    let out = (s.f)(1).await;

    Ok(())
}

当然，这段代码无法编译，并出现以下错误：

error[E0412]: cannot find type `StorableAsyncFn` in this scope

StorableAsyncFn此处未定义，这是我要定义的类型。

让我们用它作为我们的最小的、可重复的示例 https://stackoverflow.com/help/minimal-reproducible-example:

async fn foo(x: u8) -> u8 {
    2 * x
}

struct S {
    foo: (),
}

async fn example() {
    let s = S { foo };
}

它产生错误：

error[E0308]: mismatched types
  --> src/main.rs:10:17
   |
10 |     let s = S { foo };
   |                 ^^^ expected (), found fn item
   |
   = note: expected type `()`
              found type `fn(u8) -> impl std::future::Future {foo}`

的类型foo是一个函数指针，它接受一个u8并返回一些实现该特征的类型std::future::Future. async fn实际上只是转换的语法糖-> Foo into -> impl Future<Output = Foo>.

我们使我们的结构通用，并在匹配的通用上放置一个特征绑定。在实际代码中，您可能希望对Output关联类型，但本示例不需要它。然后我们可以像任何其他可调用成员字段一样调用该函数：

async fn foo(x: u8) -> u8 {
    2 * x
}

struct S<F>
where
    F: std::future::Future,
{
    foo: fn(u8) -> F,
}

impl<F> S<F>
where
    F: std::future::Future,
{
    async fn do_thing(self) {
        (self.foo)(42).await;
    }
}

async fn example() {
    let s = S { foo };
    s.do_thing().await;
}

为了更加灵活，您可以使用另一个泛型来存储闭包，而不是仅强制使用函数指针：

struct S<C, F>
where
    C: Fn(u8) -> F,
    F: std::future::Future,
{
    foo: C,
}

impl<C, F> S<C, F>
where
    C: Fn(u8) -> F,
    F: std::future::Future,
{
    async fn do_thing(self) {
        (self.foo)(42).await;
    }
}

也可以看看：

• 如何通过成员变量调用函数？ https://stackoverflow.com/q/27994509/155423
• 如何在 Rust 的结构中存储闭包？ https://stackoverflow.com/q/27831944/155423