rust: add step2_eval.

1 files changed, 125 insertions, 0 deletions

diff --git a/rust/src/step2_eval.rs b/rust/src/step2_eval.rs
new file mode 100644
index 0000000..5df9a94
--- /dev/null
+++ b/rust/src/step2_eval.rs
@@ -0,0 +1,125 @@
+// support precompiled regexes in reader.rs
+#![feature(phase)]
+#[phase(plugin)]
+extern crate regex_macros;
+extern crate regex;
+
+use std::rc::Rc;
+use std::collections::HashMap;
+use types::{MalVal,MalRet,Nil,Int,Sym,List,Func};
+mod readline;
+mod types;
+mod reader;
+mod printer;
+
+// read
+fn read(str: String) -> MalRet {
+    reader::read_str(str)
+}
+
+// eval
+fn eval_ast(ast: MalVal, env: &HashMap<String,MalVal>) -> MalRet {
+    match *ast {
+        Sym(ref sym) => {
+            match (*env).find_copy(sym) {
+                Some(mv) => Ok(mv),
+                None     => Ok(Rc::new(Nil)),
+            }
+        },
+        List(ref a) => {
+            let mut ast_vec : Vec<MalVal> = vec![];
+            for mv in a.iter() {
+                let mv2 = mv.clone();
+                match eval(mv2, env) {
+                    Ok(mv) => { ast_vec.push(mv); },
+                    Err(e) => { return Err(e); },
+                }
+            }
+            Ok(Rc::new(List(ast_vec)))
+        },
+        _ => {
+            Ok(ast.clone())
+        }
+    }
+}
+
+fn eval(ast: MalVal, env: &HashMap<String,MalVal>) -> MalRet {
+    let ast2 = ast.clone();
+    match *ast2 {
+        List(_) => (),  // continue
+        _ => return eval_ast(ast2, env),
+    }
+
+    // apply list
+    match eval_ast(ast, env) {
+        Err(e) => Err(e),
+        Ok(el) => {
+            match *el {
+                List(ref args) => {
+                    // TODO: make this work
+                    //match args.as_slice() {
+                    //    [&Func(f), rest..] => {
+                    //        (*f)(rest.to_vec())
+                    //    },
+                    //    _ => Err("attempt to call non-function".to_string()),
+                    //}
+                    let args2 = args.clone();
+                    match *args2[0] {
+                        Func(f) => f(args.slice(1,args.len()).to_vec()),
+                        _ => Err("attempt to call non-function".to_string()),
+                    }
+                }
+                _ => Err("Invalid apply".to_string()),
+            }
+        }
+    }
+}
+
+// print
+fn print(exp: MalVal) -> String {
+    exp.pr_str(true)
+}
+
+fn rep(str: String, env: &HashMap<String,MalVal>) -> Result<String,String> {
+    match read(str) {
+        Err(e) => Err(e),
+        Ok(ast) => {
+            //println!("read: {}", ast);
+            match eval(ast, env) {
+                Err(e)  => Err(e),
+                Ok(exp) => Ok(print(exp)),
+            }
+        }
+    }
+}
+
+fn int_op(f: |i:int,j:int|-> int, a:Vec<MalVal>) -> MalRet {
+    match *a[0] {
+        Int(a0) => match *a[1] {
+            Int(a1) => Ok(Rc::new(Int(f(a0,a1)))),
+            _ => Err("second arg must be an int".to_string()),
+        },
+        _ => Err("first arg must be an int".to_string()),
+    }
+}
+fn add(a:Vec<MalVal>) -> MalRet { int_op(|i,j| { i+j }, a) }
+fn sub(a:Vec<MalVal>) -> MalRet { int_op(|i,j| { i-j }, a) }
+fn mul(a:Vec<MalVal>) -> MalRet { int_op(|i,j| { i*j }, a) }
+fn div(a:Vec<MalVal>) -> MalRet { int_op(|i,j| { i/j }, a) }
+
+fn main() {
+    let mut repl_env : HashMap<String,MalVal> = HashMap::new();
+    repl_env.insert("+".to_string(), Rc::new(Func(add)));
+    repl_env.insert("-".to_string(), Rc::new(Func(sub)));
+    repl_env.insert("*".to_string(), Rc::new(Func(mul)));
+    repl_env.insert("/".to_string(), Rc::new(Func(div)));
+
+    loop {
+        let line = readline::mal_readline("user> ");
+        match line { None => break, _ => () }
+        match rep(line.unwrap(), &repl_env) {
+            Ok(str)  => println!("{}", str),
+            Err(str) => println!("Error: {}", str),
+        }
+    }
+}