dynosaur 0.3.0

Dynamic dispatch for return position impl traits and async in Rust
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

#[trait_variant::make(SendNext: Send)]
#[dynosaur::dynosaur(DynNext = dyn(box) Next, bridge(dyn))]
#[dynosaur::dynosaur(DynSendNext = dyn(box) SendNext, bridge(dyn))]
trait Next {
    type Item;
    async fn next(&mut self) -> Option<Self::Item>;
}

async fn dyn_dispatch(iter: &mut DynSendNext<'_, i32>) {
    print!("dyn_dispatch: ");
    while let Some(item) = iter.next().await {
        print!("{item} ");
    }
    println!();
}

async fn dyn_dispatch_local(iter: &mut DynNext<'_, i32>) {
    print!("dyn_dispatch: ");
    while let Some(item) = iter.next().await {
        print!("{item} ");
    }
    println!();
}

async fn static_dispatch(mut iter: impl SendNext<Item = i32>) {
    print!("static_dispatch: ");
    while let Some(item) = iter.next().await {
        print!("{item} ");
    }
    println!();
}

async fn static_dispatch_local(mut iter: impl Next<Item = i32>) {
    print!("static_dispatch: ");
    while let Some(item) = iter.next().await {
        print!("{item} ");
    }
    println!();
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
    let v = [1, 2, 3];
    dyn_dispatch(&mut DynSendNext::new_box(from_iter(v))).await;
    dyn_dispatch(&mut DynSendNext::from_box(Box::new(from_iter(v)))).await;
    dyn_dispatch_local(DynNext::from_mut(&mut from_iter(v))).await;
    dyn_dispatch_local(DynNext::from_mut(&mut from_iter(v))).await;
    static_dispatch(from_iter(v)).await;
    static_dispatch_local(from_iter(v)).await;
    static_dispatch(DynSendNext::new_box(from_iter(v))).await;
    static_dispatch(DynSendNext::from_mut(&mut from_iter(v))).await;
    static_dispatch_local(DynNext::new_box(from_iter(v))).await;
    static_dispatch_local(DynNext::from_mut(&mut from_iter(v))).await;
}

struct ForArray<T: Copy, const N: usize> {
    v: [T; N],
    i: usize,
}

fn from_iter<T: Copy, const N: usize>(v: [T; N]) -> ForArray<T, N> {
    ForArray { v, i: 0 }
}

impl<T: Copy + Send, const N: usize> SendNext for ForArray<T, N> {
    type Item = T;

    async fn next(&mut self) -> Option<Self::Item> {
        if self.i >= self.v.len() {
            return None;
        }
        stuff().await;
        let item = self.v[self.i];
        self.i += 1;
        Some(item)
    }
}

async fn stuff() {}