How do I synchronously return a value calculated in an asynchronous Future?

by

Standard library futures

Let’s use this as our minimal, reproducible example:

async fn example() -> i32 {
    42
}

Call executor::block_on:

use futures::executor; // 0.3.1

fn main() {
    let v = executor::block_on(example());
    println!("{}", v);
}

Tokio

Use the tokio::main attribute on any function (not just main!) to convert it from an asynchronous function to a synchronous one:

use tokio; // 0.3.5

#[tokio::main]
async fn main() {
    let v = example().await;
    println!("{}", v);
}

tokio::main is a macro that transforms this

#[tokio::main]
async fn main() {}

Into this:

fn main() {
    tokio::runtime::Builder::new_multi_thread()
        .enable_all()
        .build()
        .unwrap()
        .block_on(async { {} })
}

This uses Runtime::block_on under the hood, so you can also write this as:

use tokio::runtime::Runtime; // 0.3.5

fn main() {
    let v = Runtime::new().unwrap().block_on(example());
    println!("{}", v);
}

For tests, you can use tokio::test.

async-std

Use the async_std::main attribute on the main function to convert it from an asynchronous function to a synchronous one:

use async_std; // 1.6.5, features = ["attributes"]

#[async_std::main]
async fn main() {
    let v = example().await;
    println!("{}", v);
}

For tests, you can use async_std::test.

Futures 0.1

Let’s use this as our minimal, reproducible example:

use futures::{future, Future}; // 0.1.27

fn example() -> impl Future<Item = i32, Error = ()> {
    future::ok(42)
}

For simple cases, you only need to call wait:

fn main() {
    let s = example().wait();
    println!("{:?}", s);
}

However, this comes with a pretty severe warning:

This method is not appropriate to call on event loops or similar I/O situations because it will prevent the event loop from making progress (this blocks the thread). This method should only be called when it’s guaranteed that the blocking work associated with this future will be completed by another thread.

Tokio

If you are using Tokio 0.1, you should use Tokio’s Runtime::block_on:

use tokio; // 0.1.21

fn main() {
    let mut runtime = tokio::runtime::Runtime::new().expect("Unable to create a runtime");
    let s = runtime.block_on(example());
    println!("{:?}", s);
}

If you peek in the implementation of block_on, it actually sends the future’s result down a channel and then calls wait on that channel! This is fine because Tokio guarantees to run the future to completion.

See also:

  • How can I efficiently extract the first element of a futures::Stream in a blocking manner?

Related Contents:

  1. Why doesn’t println! work in Rust unit tests?
  2. Why are Rust executables so huge?
  3. How do I split a string in Rust?
  4. Why is it discouraged to accept a reference to a String (&String), Vec (&Vec), or Box (&Box) as a function argument?
  5. What is the difference between Copy and Clone?
  6. What are non-lexical lifetimes?
  7. How to print a Vec?
  8. What do I have to do to solve a “use of moved value” error?
  9. How to uninstall Rust that was installed via rustup?
  10. Is there a modulus (not remainder) function / operation?
  11. Using map with Vectors
  12. How I can mutate a struct’s field from a method?
  13. Promise equivalent in C#
  14. References to traits in structs
  15. How to use a map over vectors?
  16. How do I check if a thing is in a vector
  17. Why are recursive struct types illegal in Rust?
  18. How do I implement Copy and Clone for a type that contains a String (or any type that doesn’t implement Copy)?
  19. How do I get an enum as a string?
  20. How do I get an absolute value in Rust?
  21. How can I implement Rust’s Copy trait?
  22. How do I get an owned value out of a `Box`?
  23. What is the purpose of the unit type in Rust?
  24. Repeat string with integer multiplication
  25. What does the “box” keyword do?
  26. How to generate statically linked executables?
  27. Convert float to integer in Rust
  28. error[E0554]: #![feature] may not be used on the stable release channel Couldn’t install racer using cargo
  29. How to implement a custom ‘fmt::Debug’ trait?
  30. The compiler suggests I add a ‘static lifetime because the parameter type may not live long enough, but I don’t think that’s what I want
  31. How can I randomly select one element from a vector or array?
  32. Why can’t this higher kinded lifetime associated type trait bound be satisfied?
  33. What exactly does ‘#[derive(Debug)]’ mean in Rust?
  34. Why does std::fs::write(…) use an inner function?
  35. Returning a closure from a function
  36. How to execute cargo test using the nightly channel?
  37. Is it possible to control the size of an array using the type parameter of a generic?
  38. Understanding the Send trait
  39. What is the bitwise NOT operator in Rust?
  40. How do I convert an enum reference to a number?
  41. Dividing two integers doesn’t print as a decimal number in Rust
  42. How do I return a reference to something inside a RefCell without breaking encapsulation?
  43. Is there a way other than traits to add methods to a type I don’t own?
  44. How to disable a clippy lint for a single line / block? [duplicate]
  45. When would you use a Mutex without an Arc?
  46. Sort HashMap data by value
  47. How can I pattern match against an Option?
  48. What’s the most idiomatic way of working with an Iterator of Results? [duplicate]
  49. could not find `blocking` in `reqwest` [duplicate]
  50. Is there any way to create a type alias for multiple traits?

Leave a Comment