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

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 ，并且两者都受到过度限制。不过，您不需要过度限制结构本身。