rust: add step9_try. Refactor error handling.

Additional core functions.

1 files changed, 78 insertions, 72 deletions

diff --git a/rust/src/step3_env.rs b/rust/src/step3_env.rs
index f9f79ea..ac7199c 100644
--- a/rust/src/step3_env.rs
+++ b/rust/src/step3_env.rs
@@ -6,7 +6,8 @@ extern crate regex;
 
 use std::collections::HashMap;
 
-use types::{MalVal,MalRet,Int,Sym,List,Vector,Hash_Map,
+use types::{MalVal,MalRet,MalError,ErrString,ErrMalVal,err_str,
+            Int,Sym,List,Vector,Hash_Map,
             _int,list,vector,hash_map,func};
 use env::{Env,env_new,env_set,env_get};
 mod readline;
@@ -67,84 +68,88 @@ fn eval(ast: MalVal, env: Env) -> MalRet {
 
     // 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) => {
-                    match a0sym.as_slice() {
-                        "def!" => {
-                            let a1 = (*args)[1].clone();
-                            let a2 = (*args)[2].clone();
-                            let res = eval(a2, env.clone());
-                            match res {
-                                Ok(r) => {
-                                    match *a1 {
-                                        Sym(ref s) => {
-                                            env_set(&env.clone(), s.clone(), r.clone());
-                                            return Ok(r);
-                                        },
-                                        _ => {
-                                            return Err("def! of non-symbol".to_string())
-                                        }
-                                    }
-                                },
-                                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(ref bstr) => {
-                                                match eval(exp.clone(), let_env.clone()) {
-                                                    Ok(r) => {
-                                                        env_set(&let_env, bstr.clone(), r);
-                                                    },
-                                                    Err(e) => {
-                                                        return Err(e);
-                                                    },
-                                                }
-                                            },
-                                            _ => {
-                                                return Err("let* with non-symbol binding".to_string());
-                                            },
-                                        }
-                                    }
-                                },
-                                _ => return Err("let* with non-list bindings".to_string()),
-                            }
-                            return eval(a2, let_env.clone());
+                Sym(ref a0sym) => (args, a0sym.as_slice()),
+                _ => (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(ref s) => {
+                            env_set(&env.clone(), s.clone(), r.clone());
+                            return Ok(r);
                         },
-                        _ => ()
+                        _ => {
+                            return err_str("def! of non-symbol")
+                        }
                     }
-                }
-                _ => (),
+                },
+                Err(e) => return Err(e),
             }
-            // function call
+        },
+        "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(ref bstr) => {
+                                match eval(exp.clone(), let_env.clone()) {
+                                    Ok(r) => {
+                                        env_set(&let_env, bstr.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());
+        },
+        _ => { // function call
             return match eval_ast(ast, env) {
                 Err(e) => Err(e),
                 Ok(el) => {
-                    match *el {
-                        List(ref args) => {
-                            let ref f = args.clone()[0];
-                            f.apply(args.slice(1,args.len()).to_vec())
-                        }
-                        _ => Err("Invalid apply".to_string()),
-                    }
+                    let args = match *el {
+                        List(ref args) => args,
+                        _ => return err_str("Invalid apply"),
+                    };
+                    let ref f = args.clone()[0];
+                    f.apply(args.slice(1,args.len()).to_vec())
                 }
-            }
-        }
-        _ => Err("Expected list".to_string()),
+            };
+        },
     }
 }
 
@@ -153,8 +158,8 @@ fn print(exp: MalVal) -> String {
     exp.pr_str(true)
 }
 
-fn rep(str: String, env: Env) -> Result<String,String> {
-    match read(str) {
+fn rep(str: &str, env: Env) -> Result<String,MalError> {
+    match read(str.to_string()) {
         Err(e) => Err(e),
         Ok(ast) => {
             //println!("read: {}", ast);
@@ -170,9 +175,9 @@ fn int_op(f: |i:int,j:int|-> int, a:Vec<MalVal>) -> MalRet {
     match *a[0] {
         Int(a0) => match *a[1] {
             Int(a1) => Ok(_int(f(a0,a1))),
-            _ => Err("second arg must be an int".to_string()),
+            _ => err_str("second arg must be an int"),
         },
-        _ => Err("first arg must be an int".to_string()),
+        _ => err_str("first arg must be an int"),
     }
 }
 fn add(a:Vec<MalVal>) -> MalRet { int_op(|i,j| { i+j }, a) }
@@ -190,9 +195,10 @@ fn main() {
     loop {
         let line = readline::mal_readline("user> ");
         match line { None => break, _ => () }
-        match rep(line.unwrap(), repl_env.clone()) {
+        match rep(line.unwrap().as_slice(), repl_env.clone()) {
             Ok(str)  => println!("{}", str),
-            Err(str) => println!("Error: {}", str),
+            Err(ErrMalVal(_)) => (),  // Blank line
+            Err(ErrString(s)) => println!("Error: {}", s),
         }
     }
 }