cocoro 0.3.0

A more type-safe take on Rust stackless coroutines
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
92
93
94
95
96
97
98
99
100
101
102
103
104

use core::marker::PhantomData;

use either::Either;

use crate::coro::Coro;
use crate::suspend::Suspend;
use crate::suspended::Suspended;
use crate::suspended::SuspendedVisitor;

pub struct FlattenImpl<Y, Outer, Inner> {
    outer: Outer,
    _phantom: core::marker::PhantomData<(Y, Inner)>,
}

impl<Y, Outer, Inner> FlattenImpl<Y, Outer, Inner> {
    pub fn new(outer: Outer) -> Self {
        FlattenImpl {
            outer,
            _phantom: core::marker::PhantomData,
        }
    }
}

impl<I, Y, R, Outer, Inner> Coro<I, Y, R> for FlattenImpl<Y, Outer, Inner>
where
    I: Copy,
    Outer: Coro<I, Y, Inner>,
    Inner: Coro<I, Y, R>,
{
    type Next = Either<FlattenImpl<Y, Outer::Next, Inner>, Inner::Next>;
    type Suspend = Suspend<Y, R, Self::Next>;
    fn resume(self, input: I) -> Self::Suspend {
        use Suspend::Return;
        use Suspend::Yield;
        use either::Left;
        use either::Right;

        let Self { outer, .. } = self;

        struct OuterVisitor<I, Y, R, Inner> {
            input: I,
            _phantom: PhantomData<(Y, R, Inner)>,
        }

        impl<I, Y, R, Inner, Outer> SuspendedVisitor<I, Y, Inner, Outer>
            for OuterVisitor<I, Y, R, Inner>
        where
            I: Copy,
            Inner: Coro<I, Y, R>,
            Outer: Coro<I, Y, Inner>,
        {
            type Out = Suspend<
                Y,
                R,
                Either<FlattenImpl<Y, Outer, Inner>, Inner::Next>,
            >;

            fn on_yield(self, y: Y, next_outer: Outer) -> Self::Out {
                Yield(y, Left(FlattenImpl::new(next_outer)))
            }

            fn on_return(self, inner: Inner) -> Self::Out {
                struct InnerVisitor<I, Y, R, Outer, Inner> {
                    _phantom: PhantomData<(I, Y, R, Outer, Inner)>,
                }

                impl<I, Y, R, Outer, InnerCoro, InnerNext>
                    SuspendedVisitor<I, Y, R, InnerNext>
                    for InnerVisitor<I, Y, R, Outer, InnerCoro>
                where
                    I: Copy,
                    InnerNext: Coro<I, Y, R>,
                {
                    type Out = Suspend<
                        Y,
                        R,
                        Either<FlattenImpl<Y, Outer, InnerCoro>, InnerNext>,
                    >;

                    fn on_yield(
                        self,
                        y: Y,
                        next_inner: InnerNext,
                    ) -> Self::Out {
                        Yield(y, Right(next_inner))
                    }

                    fn on_return(self, r: R) -> Self::Out {
                        Return(r)
                    }
                }

                inner.resume(self.input).visit(InnerVisitor {
                    _phantom: PhantomData,
                })
            }
        }

        outer.resume(input).visit(OuterVisitor {
            input,
            _phantom: PhantomData,
        })
    }
}