improvements to eval prototype

src/eval.rs

@@ -45,40 +45,45 @@ fn eval_inner(
      * 1. make new ast
      * 2. call process_ctr on ast.car
      * 3. set new.car to result
-     * 3. if cdr is an AST
-     *   - set first_item to false
-     *   - set new.cdr to result of process_ctr(ast.ctr)
      * 4. else call process_ctr on cdr
+     *    (set first_item to false)
      *    (and set new.cdr to result)
      * 5. return new ast
      */
     let ret: Ast;
     let mret = ret.clone().borrow_mut();
-    let ret_inner = ast.clone().borrow_mut();
+    let ast_inner = ast.clone().borrow_mut();
-    mret.car = process_ctr(
+
-        ret_inner.car,
+    match process_ctr(
+        ast_inner.car,
         vars.clone(),
         funcs.clone(),
         sym_loose,
-        first_item
+        first_item,
-    );
+        mret.cdr
+    ) {
+        Ok(ctr) => {
+            mret.car = ctr
+        },
+        Err(err) => {
+            return Err(err)
+        }
+    }
 
-    if let Ctr::Seg(s) = ret_inner.cdr {
+    match process_ctr(
-        mret.cdr = process_ctr(
+        ast_inner.cdr,
-            ret_inner.cdr,
+        vars.clone(),
-            vars.clone(),
+        funcs.clone(),
-            funcs.clone(),
+        sym_loose,
-            sym_loose,
+        false,
-            false
+        RefCell::new(Rc::clone(Ctr::None))
-        );
+    ) {
-    } else {
+        Ok(ctr) => {
-        mret.cdr = process_ctr(
+            mret.cdr = ctr
-            ret_inner.cdr,
+        },
-            vars.clone(),
+        Err(err) => {
-            funcs.clone(),
+            return Err(err)
-            sym_loose,
+        }
-            first_item
-        );
     }
 }
 
@@ -99,14 +104,17 @@ fn process_ctr(
      */
 
     match ctr {
-        Symbol(token) => {
+        Ctr::Symbol(token) => {
             let mut tok = token;
-            if let Some(s) = vt.borrow().get(token) {
+            if let Some(s) = vars.borrow().get(token) {
 
                 // is function, or variable alias?
-                if first_item && let Symbol(t) = s {
+                if first_item {
-                    if let Some(f) = ft.borrow().get(t) {
+                    if let Ctr::Symbol(t) = s {
-                        tok = t;
+                        if let Some(f) = funcs.borrow().get(t) {
+                            tok = t;
+                        }
+                    }
 
                 // is a basic value.
                 } else {
@@ -118,14 +126,25 @@ fn process_ctr(
                 return Err("variable not found")
             }
 
-            if first_item && let Some(f) = ft.borrow().get(tok) {
+            if first_item {
-                match func_call(f, rest, vars.clone(), funcs.clone()) {
+                if let Some(f) = funcs.borrow().get(tok) {
-                    Ok(a) => Ok(Ctr::Seg(a.borrow().clone())),
+                    match func_call(f, rest, vars.clone(), funcs.clone()) {
-                    Err(s) => Err(s)
+                        Ok(a) => Ok(Ctr::Seg(a.borrow().clone())),
+                        Err(s) => Err(s)
+                    }
+                }
+            }
+        },
+        Ctr::Seg(tree) => {
+            match eval(tree, vars, funcs, sym_loose) {
+                Ok(ast) => {
+                    Ok(ast.borrow())
+                },
+                Err(e) => {
+                    Err(e)
                 }
             }
         },
-        Seg(tree) => eval_inner(tree, vars, funcs, sym_loose, first_item),
         _ => Ok(ctr.clone())
     }
 }