1 files changed, 225 insertions, 0 deletions
diff --git a/rust/src/bin/step4_if_fn_do.rs b/rust/src/bin/step4_if_fn_do.rs
new file mode 100644
index 0000000..afbf69a
--- /dev/null
+++ b/rust/src/bin/step4_if_fn_do.rs
@@ -0,0 +1,225 @@
+extern crate mal;
+
+use std::collections::HashMap;
+
+use mal::types::{MalVal, MalRet, MalError, err_str};
+use mal::types::{symbol, _nil, list, vector, hash_map, malfunc};
+use mal::types::MalType::{Nil, False, Sym, List, Vector, Hash_Map};
+use mal::types::MalError::{ErrString, ErrMalVal};
+use mal::{readline, reader, core};
+use mal::env::{env_set, env_get, env_new, Env};
+
+// read
+fn read(str: String) -> MalRet {
+    reader::read_str(str)
+}
+
+// eval
+fn eval_ast(ast: MalVal, env: Env) -> MalRet {
+    let ast2 = ast.clone();
+    match *ast2 {
+    //match *ast {
+        Sym(_) => env_get(&env, &ast),
+        List(ref a,_) | Vector(ref a,_) => {
+            let mut ast_vec : Vec<MalVal> = vec![];
+            for mv in a.iter() {
+                let mv2 = mv.clone();
+                match eval(mv2, env.clone()) {
+                    Ok(mv) => { ast_vec.push(mv); },
+                    Err(e) => { return Err(e); },
+                }
+            }
+            Ok(match *ast { List(_,_) => list(ast_vec),
+                            _         => vector(ast_vec) })
+        },
+        Hash_Map(ref hm,_) => {
+            let mut new_hm: HashMap<String,MalVal> = HashMap::new();
+            for (key, value) in hm.iter() {
+                match eval(value.clone(), env.clone()) {
+                    Ok(mv) => { new_hm.insert(key.to_string(), mv); },
+                    Err(e) => return Err(e),
+                }
+            }
+            Ok(hash_map(new_hm))
+        },
+        _ => {
+            Ok(ast)
+        }
+    }
+}
+
+fn eval(ast: MalVal, env: Env) -> MalRet {
+    //println!("eval: {}, {}", ast, env.borrow());
+    //println!("eval: {}", ast);
+    let ast2 = ast.clone();
+    match *ast2 {
+        List(_,_) => (),  // continue
+        _ => return eval_ast(ast2, env),
+    }
+
+    // apply list
+    match *ast2 {
+        List(_,_) => (),  // continue
+        _ => return Ok(ast2),
+    }
+
+    let (args, a0sym) = match *ast2 {
+        List(ref args,_) => {
+            if args.len() == 0 {
+                return Ok(ast);
+            }
+            let ref a0 = *args[0];
+            match *a0 {
+                Sym(ref a0sym) => (args, &a0sym[..]),
+                _ => (args, "__<fn*>__"),
+            }
+        },
+        _ => return err_str("Expected list"),
+    };
+
+    match a0sym {
+        "def!" => {
+            let a1 = (*args)[1].clone();
+            let a2 = (*args)[2].clone();
+            let res = eval(a2, env.clone());
+            match res {
+                Ok(r) => {
+                    match *a1 {
+                        Sym(_) => {
+                            env_set(&env.clone(), a1.clone(), r.clone());
+                            return Ok(r);
+                        },
+                        _ => {
+                            return err_str("def! of non-symbol")
+                        }
+                    }
+                },
+                Err(e) => return Err(e),
+            }
+        },
+        "let*" => {
+            let let_env = env_new(Some(env.clone()));
+            let a1 = (*args)[1].clone();
+            let a2 = (*args)[2].clone();
+            match *a1 {
+                List(ref binds,_) | Vector(ref binds,_) => {
+                    let mut it = binds.iter();
+                    while it.len() >= 2 {
+                        let b = it.next().unwrap();
+                        let exp = it.next().unwrap();
+                        match **b {
+                            Sym(_) => {
+                                match eval(exp.clone(), let_env.clone()) {
+                                    Ok(r) => {
+                                        env_set(&let_env, b.clone(), r);
+                                    },
+                                    Err(e) => {
+                                        return Err(e);
+                                    },
+                                }
+                            },
+                            _ => {
+                                return err_str("let* with non-symbol binding");
+                            },
+                        }
+                    }
+                },
+                _ => return err_str("let* with non-list bindings"),
+            }
+            return eval(a2, let_env.clone());
+        },
+        "do" => {
+            let el = list(args[1..].to_vec());
+            return match eval_ast(el, env.clone()) {
+                Err(e) => return Err(e),
+                Ok(el) => {
+                    match *el {
+                        List(ref lst,_) => {
+                            let ref last = lst[lst.len()-1];
+                            return Ok(last.clone());
+                        }
+                        _ => return err_str("invalid do call"),
+                    }
+                },
+            };
+        },
+        "if" => {
+            let a1 = (*args)[1].clone();
+            let cond = eval(a1, env.clone());
+            match cond {
+                Err(e) => return Err(e),
+                Ok(c) => match *c {
+                    False | Nil => {
+                        if args.len() >= 4 {
+                            let a3 = (*args)[3].clone();
+                            return eval(a3, env.clone());
+                        } else {
+                            return Ok(_nil());
+                        }
+                    },
+                    _ => {
+                        let a2 = (*args)[2].clone();
+                        return eval(a2, env.clone());
+                    },
+                }
+            }
+        },
+        "fn*" => {
+            let a1 = (*args)[1].clone();
+            let a2 = (*args)[2].clone();
+            return Ok(malfunc(eval, a2, env.clone(), a1, _nil()));
+        },
+        _ => { // function call
+            return match eval_ast(ast, env.clone()) {
+                Err(e) => Err(e),
+                Ok(el) => {
+                    let args = match *el {
+                        List(ref args,_) => args,
+                        _ => return err_str("Invalid apply"),
+                    };
+                    let ref f = args.clone()[0];
+                    f.apply(args[1..].to_vec())
+                }
+            };
+        },
+    }
+}
+
+// print
+fn print(exp: MalVal) -> String {
+    exp.pr_str(true)
+}
+
+fn rep(str: &str, env: Env) -> Result<String,MalError> {
+    match read(str.to_string()) {
+        Err(e) => Err(e),
+        Ok(ast) => {
+            //println!("read: {}", ast);
+            match eval(ast, env) {
+                Err(e)  => Err(e),
+                Ok(exp) => Ok(print(exp)),
+            }
+        }
+    }
+}
+
+fn main() {
+    // core.rs: defined using rust
+    let repl_env = env_new(None);
+    for (k, v) in core::ns().into_iter() {
+        env_set(&repl_env, symbol(&k), v);
+    }
+
+    // core.mal: defined using the language itself
+    let _ = rep("(def! not (fn* (a) (if a false true)))", repl_env.clone());
+
+    loop {
+        let line = readline::mal_readline("user> ");
+        match line { None => break, _ => () }
+        match rep(&line.unwrap(), repl_env.clone()) {
+            Ok(str)  => println!("{}", str),
+            Err(ErrMalVal(_)) => (),  // Blank line
+            Err(ErrString(s)) => println!("Error: {}", s),
+        }
+    }
+}