Rust 如何将异步函数存储在 struct 中并从 struct 实例中调用它

让我们用这个作为我们的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并返回实现trait std::future::Future的某种类型.async fn实际上只是将-> Foo转换成-> impl Future<Output = Foo>的语法糖.

我们将 struct 设为泛型，并将特征绑定到匹配的泛型上.在实际代码中，您可能希望在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;
    }
}

另见:

• How do I call a function through a member variable?
• How do I store a closure in a struct in Rust?