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
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use core::marker::PhantomData;

use either::Either;

use crate::Coro;
use crate::FixedPointCoro;
use crate::Suspend;
use crate::Suspend::Return;
use crate::Suspend::Yield;
use crate::Suspended;
use crate::weave;

struct Weaving<Src, Processor, Cont, P> {
    src: Src,
    processor: Processor,
    cont: Cont,
    phantom: P,
}

impl<I, Y, A, X, R, Src, Worker, Start, Processor, Finish, Transition, Cont>
    Coro<A, X, R>
    for Weaving<
        Src,
        Processor,
        Cont,
        PhantomData<(I, Y, Worker, Start, Transition)>,
    >
where
    Src: FixedPointCoro<I, Y, R>,
    Worker: FixedPointCoro<Y, I, X>,
    Start: Suspended<Y, I, X, Next = Worker>,
    Processor: Coro<A, Start, R>,
    Finish: Coro<A, X, R>,
    Transition: Suspended<A, X, R, Next = Finish>,
    Cont: FnOnce(R, Worker) -> Transition,
{
    type Next = Either<
        Weaving<
            Src,
            Processor::Next,
            Cont,
            PhantomData<(I, Y, Worker, Start, Transition)>,
        >,
        Finish,
    >;
    type Suspend = Suspend<X, R, Self::Next>;
    fn resume(self, a: A) -> Self::Suspend {
        use Either::*;
        let Self {
            src,
            processor,
            cont,
            phantom,
        } = self;
        match processor.resume(a).into_enum() {
            Yield(start, processor) => match start.into_enum() {
                Yield(i, worker) => match weave(src, worker, i) {
                    Left((r, worker)) => match cont(r, worker).into_enum() {
                        Yield(x, finish) => Yield(x, Right(finish)),
                        Return(r) => Return(r),
                    },
                    Right((x, src)) => Yield(
                        x,
                        Left(Weaving {
                            src,
                            processor,
                            cont,
                            phantom,
                        }),
                    ),
                },
                Return(x) => Yield(
                    x,
                    Left(Weaving {
                        src,
                        processor,
                        cont,
                        phantom,
                    }),
                ),
            },
            Return(r) => Return(r),
        }
    }
}

pub fn process<
    I,
    Y,
    R,
    A,
    X,
    Src,
    Worker,
    Start,
    Processor,
    Finish,
    Transition,
>(
    src: Src,
    processor: Processor,
    cont: impl FnOnce(R, Worker) -> Transition,
) -> impl Coro<A, X, R>
where
    Src: FixedPointCoro<I, Y, R>,
    Worker: FixedPointCoro<Y, I, X>,
    Start: Suspended<Y, I, X, Next = Worker>,
    Processor: Coro<A, Start, R>,
    Finish: Coro<A, X, R>,
    Transition: Suspended<A, X, R, Next = Finish>,
{
    Weaving {
        src,
        processor,
        cont,
        phantom: PhantomData,
    }
}