Rust async 关键字

async

观察代码：

async fn dd(a: i32) -> i32 {
    dbg!(a);
    2 * a
}

异步方法内可以执行await，很显然上面的代码等价于下面两种形式：

async fn dd(a: i32) -> i32 {
    dbg!(a);
    async { 2 * a }.await
}

async fn dd(a: i32) -> i32 {
    async move {
      dbg!(a);
      2 * a
    }.await
}

只有执行await，一个异步方法或者异步代码块才会被执行，所以上面的代码其实又等价于：

fn dd(a: i32) -> impl Future<Output = i32> {
    async move {
      dbg!(a);
      2 * a
    }
}

看起来，我们就像直接返回了一个异步代码块！这个块也是需要执行await才会被执行的。它们的调用都是：

let a = dd(10).await;
assert_eq!(a, 20);

注意，它和下面的代码并不等价，因为dbg!(a);不需要执行await就被立即执行了：

fn dd(a: i32) -> impl Future<Output = i32> {
    dbg!(a);
    async move { 
      2 * a
    }
}

async Fn ?

我们可以指定参数类型为impl Fn:

mod test {
    fn main(handle: impl Fn(i32) -> i32) {
        let a = handle(8);
        assert_eq!(a, 80);
    }

    #[tokio::test]
    async fn test() {
        main(|a| { a * 10 });
        main(handle);
    }

    fn handle(a: i32) -> i32 {
        a * 10
    }
}

那么有没有impl AsyncFn之类的东西呢？显然没有，但是根据我们上面的研究，可以做到：

mod test {
    use std::future::Future;

    async fn main<R>(handle: impl Fn(i32) -> R)
    where
        R: Future<Output = i32>
    {
        let a = handle(8).await;
        assert_eq!(a, 80);
    }

    async fn main2<F, R>(handle: F)
    where
        F: Fn(i32) -> R,
        R: Future<Output = i32>
    {
        let a = handle(123).await;
        assert_eq!(a, 12300);
    }

    #[tokio::test]
    async fn test() {
        main(|a| async move { a * 10 }).await;
        main2(handle).await;
    }

    async fn handle(a: i32) -> i32 {
        a * 100
    }
}