algoroutine 0.1.7

Light-weight algebraic effect(algebraic goroutine) 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

use std::{ops::Coroutine, pin::Pin};

pub enum OneStep<I, R> {
    Return(R),
    Yield(I),
}

/// Consume whe whole coroutine until finished
pub trait Consumer<E, I, R> {
    fn consume<F>(&mut self, continuation: F, arg: I) -> F::Return
    where
        F: Coroutine<I, Yield = E, Return = R> + 'static;
}

/// Step a coroutine until it yields or return
pub trait Step<E, I, R>: Sized {
    fn step<F>(&mut self, continuation: Pin<&mut F>, arg: I) -> OneStep<I, R>
    where
        F: Coroutine<I, Yield = E, Return = R> + 'static;
}

/// Build a sync consumer based on `Step`
pub struct SyncConsumer<S> {
    step: S,
}

impl<S> SyncConsumer<S> {
    pub fn from(step: S) -> Self {
        Self { step }
    }
}

impl<E, I, R, S> Consumer<E, I, R> for SyncConsumer<S>
where
    S: Step<E, I, R>,
{
    fn consume<F>(&mut self, continuation: F, mut arg: I) -> F::Return
    where
        F: Coroutine<I, Yield = E, Return = R> + 'static,
    {
        let mut f = Box::pin(continuation);
        loop {
            let step = self.step.step(f.as_mut(), arg);
            match step {
                OneStep::Return(ans) => break ans,
                OneStep::Yield(x) => arg = x,
            }
        }
    }
}