Example of sync function wrapped into a future for the tokio runtime

sync_to_async.rs

use std::{thread, time};
use futures::future;
use std::time::Instant;

// Delay function will wait for n seconds
async fn delay(secs: u64) -> anyhow::Result<()> {
    let ten_secs = time::Duration::from_secs(secs);
    let now = time::Instant::now();

    // Wraps a sync call into a future
    future::ok({
        thread::sleep(ten_secs);
    }).await
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let start = Instant::now();
    let secs_to_wait = 2;
    
    // Creates the future to be resolved sometime
    let op = delay(secs_to_wait);
    
    println!("This will print immediately");
    
    // Await the async function to be resolved
    op.await?;
    
    println!("This will print after {secs_to_wait} seconds");
    
    let duration = start.elapsed();
    println!("Duration of the program {:?}", duration);
    
    Ok(())
}