diff options
Diffstat (limited to 'rust/src/bin/step4_if_fn_do.rs')
| -rw-r--r-- | rust/src/bin/step4_if_fn_do.rs | 158 |
1 files changed, 59 insertions, 99 deletions
diff --git a/rust/src/bin/step4_if_fn_do.rs b/rust/src/bin/step4_if_fn_do.rs index afbf69a..2be0f6b 100644 --- a/rust/src/bin/step4_if_fn_do.rs +++ b/rust/src/bin/step4_if_fn_do.rs @@ -4,11 +4,12 @@ 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::types::MalType::{Nil, False, Sym, List, Vector, Hash_Map}; 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) @@ -16,57 +17,48 @@ fn read(str: String) -> MalRet { // eval fn eval_ast(ast: MalVal, env: Env) -> MalRet { - let ast2 = ast.clone(); - match *ast2 { - //match *ast { + 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); }, - } + ast_vec.push(try!(eval(mv2, env.clone()))); } 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), - } + new_hm.insert(key.to_string(), + try!(eval(value.clone(), env.clone()))); } Ok(hash_map(new_hm)) - }, - _ => { - Ok(ast) } + _ => Ok(ast.clone()), } } fn eval(ast: MalVal, env: Env) -> MalRet { //println!("eval: {}, {}", ast, env.borrow()); //println!("eval: {}", ast); - let ast2 = ast.clone(); - match *ast2 { + match *ast { List(_,_) => (), // continue - _ => return eval_ast(ast2, env), + _ => return eval_ast(ast, env), } // apply list - match *ast2 { + match *ast { List(_,_) => (), // continue - _ => return Ok(ast2), + _ => return Ok(ast), } - let (args, a0sym) = match *ast2 { + let tmp = ast; + let (args, a0sym) = match *tmp { List(ref args,_) => { if args.len() == 0 { - return Ok(ast); + return Ok(tmp.clone()); } let ref a0 = *args[0]; match *a0 { @@ -81,20 +73,13 @@ fn eval(ast: MalVal, env: Env) -> MalRet { "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") - } - } + let r = try!(eval(a2, env.clone())); + match *a1 { + Sym(_) => { + env_set(&env.clone(), a1, r.clone()); + return Ok(r); }, - Err(e) => return Err(e), + _ => return err_str("def! of non-symbol"), } }, "let*" => { @@ -109,18 +94,10 @@ fn eval(ast: MalVal, env: Env) -> MalRet { 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"); + let r = try!(eval(exp.clone(), let_env.clone())); + env_set(&let_env, b.clone(), r); }, + _ => return err_str("let* with non-symbol binding"), } } }, @@ -130,57 +107,45 @@ fn eval(ast: MalVal, env: Env) -> MalRet { }, "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"), - } - }, - }; + match *try!(eval_ast(el, env.clone())) { + 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()); - }, - } + let c = try!(eval(a1, env.clone())); + 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())); + let a1 = args[1].clone(); + let a2 = args[2].clone(); + return Ok(malfunc(eval, a2, env, 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()) - } + let el = try!(eval_ast(tmp.clone(), env.clone())); + 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()) }, } } @@ -191,16 +156,10 @@ fn print(exp: MalVal) -> String { } 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)), - } - } - } + let ast = try!(read(str.to_string())); + //println!("read: {}", ast); + let exp = try!(eval(ast, env)); + Ok(print(exp)) } fn main() { @@ -213,6 +172,7 @@ fn main() { // core.mal: defined using the language itself let _ = rep("(def! not (fn* (a) (if a false true)))", repl_env.clone()); + // repl loop loop { let line = readline::mal_readline("user> "); match line { None => break, _ => () } |