如何接受异步函数作为参数？

Question

我想就像复制行为，并采取封闭/函数作为参数人体工程学map的作用：iterator.map(|x| ...)。

我注意到一些库代码允许传入异步功能，但此方法不允许我传入参数：

pub fn spawn<F, T>(future: F) -> JoinHandle<T>
where
    F: Future<Output = T> + Send + 'static,
    T: Send + 'static,

spawn(async { foo().await });

我希望执行以下操作之一：

iterator.map(async |x| {...});

async fn a(x: _) {}
iterator.map(a)

Answer 1

async函数被有效地脱糖为返回impl Future。一旦你知道了这一点，那就是结合现有的 Rust 技术来接受一个函数/闭包，从而产生一个具有两种泛型类型的函数：

use std::future::Future;

async fn example<F, Fut>(f: F)
where
    F: FnOnce(i32, i32) -> Fut,
    Fut: Future<Output = bool>,
{
    f(1, 2).await;
}

这也可以写成

use std::future::Future;

async fn example<Fut>(f: impl FnOnce(i32, i32) -> Fut)
where
    Fut: Future<Output = bool>,
{
    f(1, 2).await;
}

• 如何将 Rust 函数作为参数传递？
• 从“async fn”返回的未来的具体类型是什么？
• Rust 中 async/await 的目的是什么？
• 如何在结构中存储异步函数并从结构实例调用它？
• `|_| 和有什么不一样 异步移动{}`和`异步移动|_| {}`

Answer 2

所述async |...| expr封闭件的语法是可在夜间信道启用该功能async_closure。

#![feature(async_closure)]

use futures::future;
use futures::Future;
use tokio;

pub struct Bar;

impl Bar {
    pub fn map<F, T>(&self, f: F)
    where
        F: Fn(i32) -> T,
        T: Future<Output = Result<i32, i32>> + Send + 'static,
    {
        tokio::spawn(f(1));
    }
}

async fn foo(x: i32) -> Result<i32, i32> {
    println!("running foo");
    future::ok::<i32, i32>(x).await
}

#[tokio::main]
async fn main() {
    let bar = Bar;
    let x = 1;

    bar.map(foo);

    bar.map(async move |x| {
        println!("hello from async closure.");
        future::ok::<i32, i32>(x).await
    });
}

有关更多详细信息，请参阅2394-async_await RFC