Crate wait 

Wait for Rust

Documentation - Website

Wait for Rust simplifies the integration of asynchronous code into synchronous applications without the need to rewrite your entire application as async or add a bulky runtime just to use block_on().

Installation

Either use cargo add wait or add it to your Cargo.toml manually. You can also add the tokio feature if you are calling an async function that requires it (like a reqwest method, for example).

Usage

Getting started with Wait for Rust is straightforward:

Step 1: Add the prelude to your application:

use wait::prelude::*;

Step 2: Call the .wait() method instead of .await from within any function, method, or closure, even if it’s not an async context:

let body = reqwest::get("https://www.rust-lang.org")
  .wait()?
  .text()
  .wait()?;

println!("body = {body:?}");

Step 3: ????

Step 4: Profit

You can see the complete example in the examples folder.

Building with no_std

This crate is no_std so that modules from std and alloc are only pulled in when the std feature flag is enabled (which it is by default). Even though this crate can work with no_std, the tokio feature flag brings in a tokio runtime, which does require std.

Without the std feature flag, this library uses a hot loop to wait for the Future to complete. This is not ideal, so it should only be used when absolutely necessary.

Troubleshooting

If your application panics with the message there is no reactor running, must be called from the context of a Tokio 1.x runtime, you can fix this by enabling the tokio feature flag in your crate. Unfortunately, this means you wind up using a tokio runtime under the hood, but this crate disables all but the minimum required features of tokio that are necessary for it to work. It also manages the runtime for you so you can use .wait() exactly the same.

If you encounter any other problems, please open an issue on GitHub.

Acknowledgements

This crate rests on the shoulders of giants. Rust futures are complicated, but popular libraries like tokio, async-std, futures-rs, and embassy are incredible resources for learning how futures work. We thank the maintainers and contributors of these libraries and the broader Rust community for all of their hard work and dedication. Additionally, the CI workflow for this repository is heavily based on the one in the futures-rs repository.

License

Licensed under either of the Apache License, Version 2.0 or the MIT license at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

Modules

prelude

This is the convenience module where the magic happens.

Traits

Waitable

The Waitable trait declares the .wait() method.