Rust provides what it calls futures for implementing concurrency. Similar to:

• JavaScript’s Promise.
• C++11’s std::future<T>.

Alternatives:

• An alternative to busy waiting which ****is a loop with a delay in each iteration.
• Threading. More powerful but in certain situations also more complex.

A function that returns something that will be ready in the future.

async fn expensive() -> i32 {
    0
}

// Same as:
fn expensive() -> impl Future<Output = i32> {
    // Doesn't run until awaited.
    async { 0 }
}

#[tokio::main]
async fn main() {
    // Await the Future's completion. Yields control in the meantime.
    expensive().await // must be inside an async function
}

Futures are lazy. They do nothing until awaited.

• No cost to creating a future.
• Futures can be cancelled by not awaiting.

Useful for:

• Network and file requests
• Timers
• Parallelizing independent work