fx-rs 0.1.1-dev0

Algebraic Effects inspired by Kyo and Fx.go
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

use crate::{Fx, State};

#[derive(Clone)]
pub enum Item<T> {
    Next(T),
    Done(T),
}

#[derive(Clone)]
pub enum Stream<'f, I: Clone, S: Clone> {
    Nil,
    Cons(I, Box<StreamFx<'f, I, S>>),
}

pub type StreamFx<'f, I, S> = Fx<'f, S, Stream<'f, I, S>>;

impl<'f, I: Clone, S: Clone> Stream<'f, I, S> {
    pub fn empty() -> StreamFx<'f, I, S> {
        Fx::value(Self::Nil)
    }

    pub fn cons(head: I, tail: StreamFx<'f, I, S>) -> StreamFx<'f, I, S> {
        Fx::value(Self::Cons(head, Box::new(tail)))
    }

    pub fn single(i: I) -> StreamFx<'f, I, S> {
        Fx::value(Self::Cons(i, Box::new(Self::empty())))
    }

    pub fn concat(left: StreamFx<'f, I, S>, right: StreamFx<'f, I, S>) -> StreamFx<'f, I, S> {
        left.concat(right)
    }
}

impl<'f, I: Clone, S: Clone> StreamFx<'f, I, S> {
    pub fn concat(self, tail: Self) -> Self {
        self.map_m(|s| match s {
            Stream::Nil => tail,
            Stream::Cons(head, fx) => Stream::cons(head, Self::concat(*fx, tail)),
        })
    }

    pub fn fold_stream<A, F>(f: F) -> Fx<'f, (Self, (A, S)), A>
    where
        A: Clone + 'f,
        F: FnOnce(A, I) -> Fx<'f, S, Item<A>> + Clone + 'f,
    {
        State::get()
            .flat_map(move |(stream, initial): (Self, A)| {
                Self::fold_stream_rec(initial, stream, f.clone())
            })
            .contra_map(|(s, (a, r))| ((s, a), r), |_, ((s, a), r)| (s, (a, r)))
    }

    pub fn fold<A, F>(self, f: F) -> Fx<'f, (A, S), A>
    where
        A: Clone + 'f,
        F: FnOnce(A, I) -> Fx<'f, S, Item<A>> + Clone + 'f,
    {
        State::get()
            .flat_map(move |initial: A| Self::fold_stream_rec(initial, self.clone(), f.clone()))
    }

    fn fold_stream_rec<A, F>(current: A, stream: Self, f: F) -> Fx<'f, S, A>
    where
        A: Clone + 'f,
        F: FnOnce(A, I) -> Fx<'f, S, Item<A>> + Clone + 'f,
    {
        stream.map_m(move |step| {
            match step {
                Stream::Nil => Fx::value(current.clone()),
                Stream::Cons(head, tail) => {
                    let f0 = f.clone();
                    let acc = f(current.clone(), head);
                    acc.map_m(move |acc| match acc {
                        Item::Done(a) => Fx::value(a), // TODO: stop stream producer
                        Item::Next(a) => Self::fold_stream_rec(a, (&*tail).clone(), f0),
                    })
                }
            }
        })
    }
}