async-local-executor 0.1.0

Lightweight executor for building single-threaded async runtimes.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

# async-local-executor   [![Action Badge]][actions] [![Version Badge]][crates.io] [![License Badge]][license] [![Docs Badge]][docs]

[Version Badge]: https://img.shields.io/crates/v/async-local-executor.svg
[crates.io]: https://crates.io/crates/async-local-executor
[Action Badge]: https://github.com/JayceFayne/async-local-executor/workflows/Rust/badge.svg
[actions]: https://github.com/JayceFayne/async-local-executor/actions
[License Badge]: https://img.shields.io/crates/l/async-local-executor.svg
[license]: https://github.com/JayceFayne/async-local-executor/blob/master/LICENSE.md
[Docs Badge]: https://docs.rs/async-local-executor/badge.svg
[docs]: https://docs.rs/async-local-executor

Lightweight executor for building single-threaded async runtimes.

## Why?

This crate provides an `Executor` for spawning and executing `!Send` futures without locks. It is meant to be integrated into an existing event loop and driven by that event loop whenever tasks need to make progress. This crate providies the task execution layer while leaving I/O, timers, and event handling to the external event loop.

## Usage

Examples of how to use the library can be found [here](./examples).
A short example of building a runtime on top of `Executor` is shown below.

```rust
use async_io::Timer;
use async_local_executor::{spawn_local, Executor};
use std::sync::mpsc;
use std::time::Duration;

pub fn block_on<F>(future: F) -> F::Output
where
    F: IntoFuture + 'static,
{
    let (tx, rx) = mpsc::channel();
    let mut ex = Executor::new(move |task| tx.send(task).unwrap());
    ex.run_in(|| {
        let main = spawn_local(future);
        loop {
            rx.recv().unwrap().tick();
            if let Some(result) = main.result() {
                break result;
            }
        }
    })
}

fn main() {
    let res = block_on(async {
        spawn_local(async {
            for _ in 0..10 {
                println!("Hello, again!");
                Timer::after(Duration::from_secs(1)).await;
            }
        })
        .detach();
        for _ in 0..3 {
            println!("Hello, world!");
            Timer::after(Duration::from_secs(1)).await;
        }
        1
    });
    assert_eq!(res, 1);
}

```

This is basically the implementation of `block_on`

## Contributing

If you find any errors in async-local-executor or just want to add a new feature feel free to [submit a PR](https://github.com/jaycefayne/async-local-executor/pulls).