ruloom 0.1.2

A thin wrapper around 'corosensei' that provides support for stackful coroutines in Rust (like Loom in Java or goroutines in golang).
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

use corosensei::{Coroutine, Yielder};

/// Creates a new stream. A stream has one producer and (typically) one consumer.
pub fn new_stream<F, I, T, R>(function: F) -> Stream<I, T, R>
where
    F: FnOnce(StreamContext<'_, I, T>) -> R + 'static,
    I: 'static,
    T: 'static,
    R: 'static,
{
    let coroutine = Coroutine::<I, T, R>::new(|yielder, _| {
        let stream_context = StreamContext { yielder };
        function(stream_context)
    });
    Stream { coroutine }
}

pub struct StreamContext<'a, I, T> {
    yielder: &'a Yielder<I, T>,
}

impl<'a, I, T> StreamContext<'a, I, T> {
    pub fn emit(&self, value: T) -> I {
        self.yielder.suspend(value)
    }
}

pub struct Stream<I, T, R> {
    coroutine: Coroutine<I, T, R>,
}

impl<I, T, R> Stream<I, T, R> {
    pub fn next(&mut self, input: I) -> StreamResult<T, R> {
        if self.coroutine.done() {
            return StreamResult::Completed;
        } else {
            match self.coroutine.resume(input) {
                corosensei::CoroutineResult::Yield(value) => StreamResult::Next(value),
                corosensei::CoroutineResult::Return(value) => StreamResult::Last(value),
            }
        }
    }
}

#[derive(Debug, PartialEq, Eq, Clone, Hash, Ord, PartialOrd)]
pub enum StreamResult<T, R> {
    /// A new value from the stream.
    Next(T),
    /// The last value from the stream.
    Last(R),
    /// There are no more values this stream can produce.
    Completed,
}