Asynchron

Asynchronize blocking operation.

Example

```rust use asynchron::{Futurize, Futurized, ITaskHandle, Progress}; use std::{ convert::Infallible, time::{Duration, Instant}, };

fn main() { let instant: Instant = Instant::now(); let task: Futurized = Futurize::task( 0, move |task: ITaskHandle| -> Progress { let sleepdur = Duration::frommillis(10); std::thread::sleep(sleepdur); // Send current task progress. let result = Ok::("The task wake up from sleep.".into()); if let Ok(value) = result { task.send(value); } else { // return error immediately if something not right, for example: return Progress::Error( "Something ain't right..., programmer out of bounds.".into(), ); } if _task.iscanceled() { let _ = task.send("Canceling the task".into()); Progress::Canceled } else { Progress::Completed(instant.elapsed().subsecmillis()) } }, );

// Try do the task now.
task.try_do();

loop {
    if task.is_in_progress() {
        match task.try_get() {
            Progress::Current(task_receiver) => {
                if let Some(value) = task_receiver {
                    println!("{}\n", value)
                }
                // Cancel if need to.
                // task.cancel()
            }
            Progress::Canceled => {
                println!("The task was canceled\n")
            }
            Progress::Completed(elapsed) => {
                println!("The task finished in: {:?} milliseconds\n", elapsed)
            }
            Progress::Error(e) => {
                println!("{}\n", e)
            }
        }

        if task.is_done() {
            break;
        }
    }
}

} ```

More Example

Mixing sync and async with tokio, reqwest and fltk-rs can be found here.