algar 0.4.1

Algebraic structures, higher-kinded types and other category theory bad ideas
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

fn main() {}

// This solution to expression problem is "Object algebras"
// https://www.cs.utexas.edu/~wcook/Drafts/2012/ecoop2012.pdf
pub trait Expr<E> {
    fn i_val(&self, v: i32) -> E;
    fn add(&self, lhs: E, rhs: E) -> E;
}

pub struct EvaluateInt {}

impl Expr<i32> for EvaluateInt {
    fn i_val(&self, v: i32) -> i32 {
        v
    }

    fn add(&self, lhs: i32, rhs: i32) -> i32 {
        lhs + rhs
    }
}

// ---------------------------------------------
// We can  easily add new operations
pub struct Render {}

impl Expr<String> for Render {
    fn i_val(&self, v: i32) -> String {
        v.to_string()
    }

    fn add(&self, lhs: String, rhs: String) -> String {
        format!("({} + {})", lhs, rhs)
    }
}

// ---------------------------------------
// We can easily add another expression term!

pub trait MulExpr<E>: Expr<E> {
    fn mul(&self, lhs: E, rhs: E) -> E;
}

impl MulExpr<i32> for EvaluateInt {
    fn mul(&self, lhs: i32, rhs: i32) -> i32 {
        lhs * rhs
    }
}

impl MulExpr<String> for Render {
    fn mul(&self, lhs: String, rhs: String) -> String {
        format!("({} + {})", lhs, rhs)
    }
}

// But if we add another "type" to our abstraction?

pub trait BoolExpr<E>: Expr<E> {
    fn b(&self, value: bool) -> E;
    fn and(&self, lhs: E, rhs: E) -> E;
}

impl BoolExpr<String> for Render {
    fn b(&self, value: bool) -> String {
        format!("[{}]", value)
    }

    fn and(&self, lhs: String, rhs: String) -> String {
        format!("({} AND {})", lhs, rhs)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn make_simple_expr<E>(expr: &dyn Expr<E>) -> E {
        return expr.add(expr.i_val(2), expr.i_val(3));
    }

    fn make_complex_expr<E>(expr: &dyn Expr<E>) -> E {
        return expr.add(expr.add(expr.i_val(2), expr.i_val(3)), expr.i_val(3));
    }

    fn make_complex_mul_expr<E>(expr: &dyn MulExpr<E>) -> E {
        return expr.mul(
            expr.add(
                expr.mul(expr.add(expr.i_val(1), expr.i_val(5)), expr.i_val(7)),
                expr.i_val(3),
            ),
            expr.i_val(3),
        );
    }

    // DOH! It compiles, but we are mixing boolean and integers!
    fn make_mixed_expr<E>(expr: &dyn BoolExpr<E>) -> E {
        return expr.add(expr.add(expr.b(false), expr.i_val(3)), expr.i_val(3));
    }

    #[test]
    fn simple_expression() {
        let expr = make_simple_expr(&EvaluateInt {});

        assert_eq!(5, expr);
    }
    #[test]
    fn complex_expression() {
        let expr = make_complex_expr(&Render {});

        assert_eq!("((2 + 3) + 3)", expr);
    }

    #[test]
    fn handle_mul_expression() {
        let expr = make_complex_mul_expr(&Render {});

        assert_eq!("((((1 + 5) + 7) + 3) + 3)", expr);
    }

    #[test]
    fn handle_mixed_wrong_expression_doh() {
        let expr = make_mixed_expr(&Render {});

        // What does this mean???? Let's try to improve it...Final tagless encoding!
        assert_eq!("(([false] + 3) + 3)", expr);
    }
}