Tokio Compat 0.2

toml tokio-compat-02 = "0.2"

This crate includes utilities around integrating Tokio with other runtimes by allowing the context to be attached to futures. This allows spawning futures on other executors while still using Tokio to drive them. This can be useful if you need to use a Tokio based library in an executor/runtime that does not provide a Tokio context.

Be aware that the .compat() region allows you to use both Tokio 0.2 and 1 features. It is not the case that you opt-out of Tokio 1 when you are inside a Tokio 0.2 compatibility region.

Basic usage: ```rust use hyper::{Client, Uri}; use tokiocompat02::FutureExt;

[tokio::main]

async fn main() -> Result<(), Box> { let client = Client::new();

// This will not panic because we are wrapping it in the
// Tokio 0.2 context via the `FutureExt::compat` fn.
client
    .get(Uri::from_static("http://tokio.rs"))
    .compat()
    .await?;

Ok(())

} Usage on async function: rust use hyper::{Client, Uri}; use tokiocompat02::FutureExt;

[tokio::main]

async fn main() -> Result<(), Box> { // By calling compat on the async function, everything inside it is able // to use Tokio 0.2 features. hyper_get().compat().await?; Ok(()) }

async fn hyper_get() -> Result<(), Box> { let client = Client::new();

// This will not panic because the `main` function wrapped it in the
// Tokio 0.2 context.
client
    .get(Uri::from_static("http://tokio.rs"))
    .await?;

Ok(())

} Be aware that the constructors of some type require being inside the context. For example, this includes `TcpStream` and `delay_for`. rust use tokio02::time::delayfor; use tokiocompat02::FutureExt;

[tokio::main]

async fn main() -> Result<(), Box> { let duration = std::time::Duration::from_secs(1);

// Call the non-async constructor in the context.
let time_future = async { delay_for(duration) }.compat().await;

// Use the constructed `Delay`.
time_future.compat().await;

Ok(())

} `` Of course the above would also work if the surrounding async function was called with.compat()`.