Question

我正在尝试将异步函数包装在结构中。例如：

use std::future::Future;

struct X;
struct Y;

async fn f(x: &X) -> Y {
    Y
}

struct MyStruct<F, Fut>(F)
where
    F: Fn(&X) -> Fut,
    Fut: Future<Output = Y>;

fn main() {
    MyStruct(f);
}

编译器对此提出以下（无益的）错误：

error[E0308]: mismatched types
  --> src/main.rs:16:5
   |
16 |     MyStruct(f);
   |     ^^^^^^^^ one type is more general than the other
   |
   = note: expected associated type `<for<'_> fn(&X) -> impl Future {f} as FnOnce<(&X,)>>::Output`
              found associated type `<for<'_> fn(&X) -> impl Future {f} as FnOnce<(&X,)>>::Output`

这样的事情真的可能吗？据我了解，f 脱糖为：

fn f<'a>(x: &'a X) -> impl Future<Output = Y> + 'a {
    Y
}

所以我需要以某种方式在 MyStruct 中表示 Fut 与 x 具有相同的生命周期。

Answer 1

实际上我对async知之甚少。

然而，当谈到 trait-bounds 时，通常情况下，trait-bound 越少越好。换句话说，只声明那些你真正需要的 trait-bounds。

在结构体的情况下，只要您的结构体中不需要关联类型，您就可以无限制地使用。这与@George Glavan 在他的回答中所写的差不多。

当您向结构中添加方法时，您更有可能使用 trait，因此需要 trait-bounds。有时通过在 impl 块本身上声明它来组合多个函数的 trait-bound 很有用。 Tho，这有一些限制。您还应该考虑每个功能是否真的需要所有这些约束。

例如，考虑以下代码：

struct X;
struct Y;

struct MyStruct<F>(F);

impl<F> MyStruct<F> {
    pub fn new(f: F) -> Self {
        MyStruct(f)
    }

    pub fn invoke<'a, Fut>(&self) -> Fut
    where
        F: Fn(&'a X) -> Fut,
    {
        (self.0)(&X)
    }
}

我添加了一个 new 和一个 invoke 函数。前者不需要任何 trait，因此它没有 trait-bounds。后者只调用函数，因此它以F 为界Fn。这已经足够好了，因为最终调用者必须已经知道返回类型是什么，即它是否是某个 Future。

然而，在少数情况下确实需要额外的 trait-bounds，这涉及额外的泛型，例如函数返回类型。在这种情况下，您可以在结构上声明额外的（幻像）泛型，例如：

use std::future::Future;
use std::marker::PhantomData;

struct X;
struct Y;

struct MyStruct<F, Fut> {
    func: F,
    _fut: PhantomData<Fut>,
}

impl<'a, F, Fut> MyStruct<F, Fut>
where
    F: Fn(&'a X) -> Fut,
    Fut: Future<Output = Y> + Send + Sync + 'a,
{
    pub fn new(f: F) -> Self {
        MyStruct {
            func: f,
            _fut: PhantomData,
        }
    }

    pub fn invoke(&self) {
        (self.func)(&X);
    }
}

请注意，在此示例中，特征边界适用于函数 new 和 invoke，并且两者都受到过度限制。不过，您不需要过度限制结构本身。

在结构中包装异步函数时的生命周期

1 个答案: