What is the difference between `|_| async move {}` and `async move |_| {}`

Question

Let's consider the following examples:

main.rs

use futures::executor::block_on;
use futures::future::{FutureExt, TryFutureExt};


async fn fut1() -> Result<String, u32> {
  Ok("ok".to_string())
}

fn main() {
    println!("Hello, world!");
    match block_on(fut1().and_then(|x| async move { Ok(format!("{} is \"ok\"", x)) })) {
      Ok(s) => println!("{}", s),
      Err(u) => println!("{}", u)
    };
}

Cargo.toml

[dependencies]
futures = "^0.3"

I'm asking about the expression |x| async move {} instead of async move |x| {}. The latter is more obvious, but it runs into the compilation error:

error[E0658]: async closures are unstable

Then I wonder, what is the difference between async move || {} and || async move {}. They both seems to be closures for using the move keyword.

$ rustc --version
rustc 1.39.0 (4560ea788 2019-11-04)

Answer 1

One is the async block (a closure with async block as its body to be precise), while the other is async closure. Per async/await RFC:

async || closures

In addition to functions, async can also be applied to closures. Like an async function, an async closure has a return type of impl Future<Output = T>, rather than T.

On the other hand:

async blocks

You can create a future directly as an expression using an async block. This form is almost equivalent to an immediately-invoked async closure:

 async { /* body */ }

 // is equivalent to

 (async || { /* body */ })()

except that control-flow constructs like return, break and continue are not allowed within body.

The move keyword here is to denote that the async closure and block are to capture ownership of the variables they close over.

async closures differ from closures containing async blocks in their lifetime rules: async closures can borrow from closure captures, while async blocks in closures cannot. For more info, see: https://blog.rust-lang.org/2025/02/20/Rust-1.85.0.html#async-closures and https://github.com/rust-lang/rust/pull/132706

async closures are stable since Rust 1.85.