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
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use crate::common::reader::Reader;
use crate::prelude::{Applicative, Functor, GenType, Monad};

// Read a Config an get an Option

pub struct ReaderOptionT<'a, R, A>
where
    R: Clone,
{
    run_reader_option: Reader<'a, R, Option<A>>,
}

impl<'a, R, A> ReaderOptionT<'a, R, A>
where
    R: Clone,
{
    pub fn new<F>(f: F) -> Self
    where
        F: FnOnce(R) -> Option<A> + 'a,
    {
        Self {
            run_reader_option: Reader::new(f),
        }
    }

    pub fn run(self, r: R) -> Option<A> {
        self.run_reader_option.run(r)
    }
}

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

impl<'a, R, A> Functor<'a, A> for ReaderOptionT<'a, R, A>
where
    R: Clone + 'a,
    A: 'a,
{
    fn fmap<F, B: 'a>(self, f: F) -> Self::Type<B>
    where
        F: Fn(A) -> B + 'a,
    {
        let reader_opt_b = self
            .run_reader_option
            .fmap(move |opt_a: Option<A>| opt_a.fmap(|a| f(a)));
        Self::Type::<B> {
            run_reader_option: reader_opt_b,
        }
    }
}

impl<'a, R, A> Applicative<'a, A> for ReaderOptionT<'a, R, A>
where
    R: Clone + 'a,
    A: 'a,
{
    type PureT<T: 'a> = T;

    fn pure(a: Self::PureT<A>) -> Self::Type<Self::PureT<A>> {
        let opt_a = Option::<A>::pure(a);
        let reader_opt_a = Reader::<'a, R, Option<A>>::pure(opt_a);
        Self::Type::<Self::PureT<A>> {
            run_reader_option: reader_opt_a,
        }
    }

    fn app<F, B: 'a>(self, f: Self::Type<F>) -> Self::Type<B>
    where
        F: Fn(A) -> B + 'a,
    {
        let reader_opt_b = Reader::new(move |r: R| {
            let opt_a = self.run_reader_option.run(r.clone());
            let opt_f = f.run_reader_option.run(r);
            opt_a.app(opt_f)
        });
        Self::Type::<B> {
            run_reader_option: reader_opt_b,
        }
    }
}

impl<'a, R, A> Monad<'a, A> for ReaderOptionT<'a, R, A>
where
    R: Clone + 'a,
    A: 'a,
{
    fn bind<F, B: 'a>(self, f: F) -> Self::Type<B>
    where
        F: Fn(A) -> Self::Type<B> + 'a,
    {
        let reader_opt_b = Reader::new(move |r: R| {
            let opt_a = self.run_reader_option.run(r.clone());
            opt_a
                // Option<A> -> Option<Reader<R, Option<B>>>
                .map(f)
                // Option<Reader<R, Option<B>>> -> Option<B>
                .and_then(|reader_opt_b| {
                    // Reader<R, Option<B>> -> Option<B>
                    reader_opt_b.run_reader_option.run(r)
                })
        });
        Self::Type::<B> {
            run_reader_option: reader_opt_b,
        }
    }
}