lubeck 0.0.0-prealpha.5-abandoned

Functional programming framework written in cutting edge 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
51
52
53
54
55
56
57

use crate::traits::GenType;

pub struct Reader<'a, R, A>
where
    R: Clone,
{
    pub(crate) run_reader: Option<Box<dyn FnOnce(R) -> A + 'a>>,
}

impl<'a, R, A> Reader<'a, R, A>
where
    R: Clone,
{
    pub fn get() -> Reader<'a, R, R> {
        Reader::<'a, R, R> {
            run_reader: Some(Box::new(|r: R| r)),
        }
    }

    pub fn new<F>(f: F) -> Self
    where
        F: FnOnce(R) -> A + 'a,
    {
        Self {
            run_reader: Some(Box::new(f)),
        }
    }

    pub fn run(self, r: R) -> A {
        self.run_reader
            .map(move |f| f(r))
            .expect("Reader has inner func")
    }
}

impl<'a, RA, A> Reader<'a, RA, A>
where
    RA: Clone + 'a,
    A: 'a,
{
    pub fn modify<F, RB>(self, f: F) -> Reader<'a, RB, A>
    where
        F: FnOnce(RB) -> RA + 'a,
        RB: Clone,
    {
        Reader::<'a, RB, A> {
            run_reader: Some(Box::new(move |rt: RB| -> A { self.run(f(rt)) })),
        }
    }
}

impl<'a, R, A> GenType for Reader<'a, R, A>
where
    R: Clone,
{
    type Type<B> = Reader<'a, R, B>;
}