all tests green

Signed-off-by: Ava Hahn <ava@aidanis.online>

src/eval.rs

@@ -32,7 +32,7 @@ pub fn eval (
 
     // to be assigned from cloned/evaled data
     let mut car;
-    let mut cdr = Box::from(Ctr::None);
+    let mut cdr;
 
     // lets me redirect the input
     let mut arg_car = &ast.car;
@@ -63,6 +63,12 @@ pub fn eval (
                     Ok(s) => car = s,
                     Err(s) => return Err(format!("error in call to {}: {}", tok, s)),
                 }
+
+                if let Some(b) = syms.is_function_type(tok) {
+                    if b {
+                        return Ok(car);
+                    }
+                }
             }
 
             _ => {
@@ -81,24 +87,24 @@ pub fn eval (
             }
 
             Ctr::Seg(ref next) => {
-                if let Ctr::None = *ret {
-                    *ret = Ctr::Seg(Seg::from(car, cdr.clone()))
-                } else if let Ctr::Seg(ref mut s) = *ret {
-                    s.append(Box::from(Ctr::Seg(Seg::from(car, cdr.clone()))))
-                }
+                cdr = Box::from(Ctr::None);
                 arg_car = &next.car;
                 arg_cdr = &next.cdr
             }
 
             _ => {
-                cdr = ast.cdr.clone();
+                cdr = arg_cdr.clone();
                 none = true;
             }
         }
 
-        if let Ctr::None = **arg_car {
-            if let Ctr::None = **arg_cdr {
-                none = true;
+        if let Ctr::None = *ret {
+            *ret = Ctr::Seg(Seg::from(car, cdr))
+        } else if let Ctr::Seg(ref mut s) = *ret {
+            s.append(car);
+            if let Ctr::None = *cdr {
+            } else {
+                s.append(cdr);
             }
         }
 

src/lex.rs

@@ -201,7 +201,25 @@ fn process(document: &String) -> Result<Box<Seg>, String> {
     if is_str {
         Err(UNMATCHED_STR_DELIM.to_string())
     } else {
-        Err(UNMATCHED_LIST_DELIM.to_string())
+        if ref_stack.is_empty() {
+            let obj;
+            if token == "true" {
+                obj = Box::from(Ctr::Bool(true));
+            } else if token == "false" {
+                obj = Box::from(Ctr::Bool(false));
+            } else if let Ok(i) = token.parse::<i128>() {
+                obj = Box::from(Ctr::Integer(i));
+            } else if let Ok(f) = token.parse::<f64>() {
+                obj = Box::from(Ctr::Float(f));
+            } else if let Some(s) = tok_is_symbol(&token) {
+                obj = Box::from(Ctr::Symbol(s));
+            } else {
+                return Err(format!("Unparsable token: {}", token));
+            }
+            Ok(Box::new(Seg::from_mono(obj)))
+        } else {
+            Err(UNMATCHED_LIST_DELIM.to_string())
+        }
     }
 }
 

src/sym.rs

@@ -88,6 +88,7 @@ impl SymTable {
             Some(s) => s,
             None => return Err(format!("undefined symbol: {}", name)),
         };
+        self.insert(name.to_string(), symbol.clone());
 
         let cond_args: &Seg;
         let outer_scope_seg_holder: Seg;
@@ -100,10 +101,15 @@ impl SymTable {
             cond_args = &outer_scope_seg_holder;
         }
 
-        let res = symbol.call(cond_args, self);
-        self.insert(name.to_string(), symbol);
+        symbol.call(cond_args, self)
+    }
 
-        res
+    pub fn is_function_type(&self, name: &String) -> Option<bool> {
+        if let ValueType::VarForm(_) = self.get(name)?.value {
+            Some(false)
+        } else {
+            Some(true)
+        }
     }
 }
 
@@ -144,6 +150,11 @@ impl Args {
                         "expected {} args. Got {}.",
                         num, called_arg_count
                     ));
+                } else if let Ctr::None = *args.car {
+                    return Err(format!(
+                        "expected {} args. Got 0.",
+                        num,
+                    ));
                 }
             }
 
@@ -202,7 +213,7 @@ impl Symbol {
         let evaluated_args: &Seg;
         let outer_scope_seg_storage: Seg;
         let outer_scope_eval: Box<Ctr>;
-        if self.conditional_branches {
+        if !self.conditional_branches {
             let outer_scope_eval_result = eval(args, syms);
             // dont listen to clippy. using ? will move the value.
             if let Err(s) = outer_scope_eval_result {
@@ -257,7 +268,17 @@ impl Symbol {
                             Err(e) => return Err(e),
                         }
                     } else {
-                        panic!("function body not in standard form!")
+                        let temp = Seg::from_mono(iterate.car.clone());
+                        match eval(&temp, syms) {
+                            Ok(ctr) => {
+                                if let Ctr::Seg(s) = *ctr {
+                                    result = s.car.clone();
+                                } else {
+                                    result = ctr;
+                                }
+                            },
+                            Err(e) => return Err(e),
+                        }
                     }
 
                     match *iterate.cdr {