atask 0.1.1

An async task implementation
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

#![expect(clippy::redundant_async_block)]

use crate::{Builder, JoinHandle, Result, Runnable};

use std::{
    collections::VecDeque,
    pin::pin,
    sync::{Arc, Mutex},
    task::{Context, Poll, Waker},
};

fn poll_loop<R>(future: impl Future<Output = R>) -> R {
    let mut future = pin!(future);
    let waker = Waker::noop();
    let mut cx = Context::from_waker(waker);
    loop {
        if let Poll::Ready(value) = future.as_mut().poll(&mut cx) {
            return value;
        }
    }
}

struct Runtime {
    queue: Arc<Mutex<VecDeque<Runnable>>>,
}

impl Runtime {
    fn new() -> Runtime {
        Runtime {
            queue: Arc::new(Mutex::new(VecDeque::new())),
        }
    }

    fn spawn<R: Send + 'static>(
        &self,
        task: impl Future<Output = R> + Send + 'static,
    ) -> JoinHandle<R> {
        let queue = Arc::clone(&self.queue);
        let (runnable, handle) = Builder::new()
            .catch_unwind(true)
            .spawn(task, move |r| queue.lock().unwrap().push_back(r));
        runnable.schedule();
        handle
    }

    fn spawn_local<R: 'static>(&self, task: impl Future<Output = R> + 'static) -> JoinHandle<R> {
        let queue = Arc::clone(&self.queue);
        let (runnable, handle) = Builder::new()
            .catch_unwind(true)
            .spawn_local(task, move |r| queue.lock().unwrap().push_back(r));
        runnable.schedule();
        handle
    }

    fn run<R: Send + 'static>(
        &self,
        future: impl Future<Output = R> + Send + 'static,
    ) -> Result<R> {
        let handle = self.spawn(future);
        while !handle.finished() {
            self.queue.lock().unwrap().pop_front().unwrap().run();
        }
        poll_loop(handle)
    }
}

#[test]
fn run_block() -> Result<()> {
    let rt = Runtime::new();
    let res = rt.run(async { "hewwo" })?;
    assert_eq!(res, "hewwo");
    Ok(())
}

#[test]
fn await_task() -> Result<()> {
    let rt = Runtime::new();
    let handle = rt.spawn(async { "hewwo" });
    let res = rt.run(async move { handle.await })??;
    assert_eq!(res, "hewwo");
    Ok(())
}

#[test]
fn local_future() -> Result<()> {
    let rt = Runtime::new();
    let handle = rt.spawn_local(async { "hewwo" });
    let res = rt.run(async move { handle.await })??;
    assert_eq!(res, "hewwo");
    Ok(())
}