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

use super::Ability;

#[derive(Clone)]
pub struct Fx<'f, S: Clone, V: Clone>(Eff<'f, S, V>);

#[derive(Clone)]
enum Eff<'f, S: Clone, V: Clone> {
    Immediate(S, V),
    Pending(Ability<'f, S, S, V>),
}

impl<V: Clone> Fx<'_, (), V> {
    pub fn eval(self) -> V {
        let mut e = self;
        loop {
            match e.0 {
                Eff::Immediate((), v) => return v,
                Eff::Pending(f) => e = f.apply(()),
            }
        }
    }
}

impl<'f, S: Clone, V: Clone> Fx<'f, S, V> {
    pub fn immediate(s: S, value: V) -> Self {
        Fx(Eff::Immediate(s, value))
    }

    pub fn pending<F>(f: F) -> Self
    where
        F: FnOnce(S) -> Self + Clone + 'f,
    {
        Fx(Eff::Pending(Ability::new(f)))
    }

    pub fn adapt<T, U, C, F>(self, cmap: C, fmap: F) -> Fx<'f, T, U>
    where
        T: Clone,
        S: Clone,
        U: Clone,
        C: FnOnce(T) -> S + Clone + 'f,
        F: FnOnce(T, S, V) -> Fx<'f, T, U> + Clone + 'f,
    {
        Fx::pending(|t: T| match self.0 {
            Eff::Immediate(s, v) => fmap(t, s, v),
            Eff::Pending(f) => f.apply(cmap.clone()(t)).adapt(cmap, fmap),
        })
    }
}