monad 0.0.2

Stackless monads in Rust
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

#![feature(phase)]
#![feature(unboxed_closures)]

#[phase(link, plugin)]
extern crate monad_macros;
extern crate monad;

use std::collections::BTreeMap;

use monad::monad::reader::trampoline::{
    Reader,
    ask,
    bind,
    point,
};

use self::Exp::{
    Add,
    Let,
    Val,
    Var,
};

#[deriving(Clone)]
#[deriving(Show)]
enum Exp
{
    Add(Box<Exp>, Box<Exp>),
    Let(String, Box<Exp>, Box<Exp>),
    Val(uint),
    Var(String),
}

#[allow(dead_code)]
fn eval<'a>(e: Exp) -> Reader<'a, BTreeMap<String, uint>, Option<uint>> {
    match e {
        Add(box e1, box e2) => {
            mdo! {
                o1: Option<uint> <- eval(e1);
                o2: Option<uint> <- eval(e2);
                let res =
                    o1.and_then(|v1|
                    o2.and_then(|v2|
                        Some(v1 + v2)
                    ));
                end point(res)
            }
        },
        Let(x, box e1, box e2) => {
            mdo! {
                o1: Option<uint> <- eval(e1);
                end eval(e2).local(move |:mut ctx: BTreeMap<String, uint>| {
                    o1.map(|v1| (&mut ctx).insert(x.clone(), v1));
                    ctx
                })
            }
        },
        Val(n) => point(Some(n)),
        Var(x) => {
            mdo! {
                ctx: BTreeMap<String, uint> <- ask();
                end point(ctx.get(&x).map(|x| *x))
            }
        },
    }
}

#[allow(dead_code)]
fn main() {
    fn exp_test(var: &str) -> Exp {
        Let(String::from_str("x"),
            box Val(42u),
            box Add(
                box Let(String::from_str("y"),
                    box Val(43u),
                    box Add(
                        box Var(String::from_str("x")),
                        box Var(String::from_str("y"))
                    )
                ),
                box Var(String::from_str(var))
            )
        )
    }

    println!("{}", eval(exp_test("x")).run(BTreeMap::new()));
    println!("{}", eval(exp_test("y")).run(BTreeMap::new()));
}