finish quick path of no spreading

calcit-lang · Feb 23, 2024 · 477a3b9 · 477a3b9
1 parent e71b44c
commit 477a3b9
Show file tree

Hide file tree

Showing 2 changed files with 11 additions and 52 deletions.
diff --git a/src/cirru/calcit-core.cirru b/src/cirru/calcit-core.cirru
@@ -505,8 +505,8 @@
                 &let
                   x0 $ &list:first xs
                   if (list? x0)
-                    recur (append x0 base) & $ &list:rest xs
-                    recur ([] x0 base) & $ &list:rest xs
+                    &call-spread recur (append x0 base) & $ &list:rest xs
+                    &call-spread recur ([] x0 base) & $ &list:rest xs
         |/ $ %{} :CodeEntry (:doc |dividing)
           :code $ quote
             defn / (x & ys)

diff --git a/src/runner.rs b/src/runner.rs
@@ -531,65 +531,24 @@ pub fn evaluate_lines(
   Ok(ret)
 }
 
-/// TODO: simplify this
-/// evaluate symbols before calling a function
-/// notice that `&` is used to spread a list
+/// quick path evaluate symbols before calling a function, not need to check `&` for spreading
 pub fn evaluate_args(
   items: CalcitList,
   scope: &CalcitScope,
   file_ns: &str,
   call_stack: &CallStackList,
 ) -> Result<Vec<Calcit>, CalcitErr> {
   let mut ret: Vec<Calcit> = Vec::with_capacity(items.len());
-  let mut spreading = false;
   for item in &items {
-    match item {
-      Calcit::Syntax(CalcitSyntax::ArgSpread, _) => {
-        spreading = true;
-      }
-      _ => {
-        if item.is_expr_evaluated() {
-          if spreading {
-            match item {
-              Calcit::List(xs) => {
-                for x in &**xs {
-                  ret.push((*x).to_owned());
-                }
-                spreading = false
-              }
-              a => {
-                return Err(CalcitErr::use_msg_stack(
-                  format!("expected list for spreading, got: {a}"),
-                  call_stack,
-                ))
-              }
-            }
-          } else {
-            ret.push(item.to_owned());
-          }
-        } else {
-          let v = evaluate_expr(item, scope, file_ns, call_stack)?;
+    // if let Calcit::Syntax(CalcitSyntax::ArgSpread, _) = item {
+    //   unreachable!("unexpected spread in args: {items}, should be handled before calling this")
+    // }
 
-          if spreading {
-            match v {
-              Calcit::List(xs) => {
-                for x in &*xs {
-                  ret.push((*x).to_owned());
-                }
-                spreading = false
-              }
-              a => {
-                return Err(CalcitErr::use_msg_stack(
-                  format!("expected list for spreading, got: {a}"),
-                  call_stack,
-                ))
-              }
-            }
-          } else {
-            ret.push(v);
-          }
-        }
-      }
+    if item.is_expr_evaluated() {
+      ret.push(item.to_owned());
+    } else {
+      let v = evaluate_expr(item, scope, file_ns, call_stack)?;
+      ret.push(v);
     }
   }
   // println!("Evaluated args: {}", ret);