...

Author: sebffischer

src/CHANGELOG.md

@@ -14,13 +14,21 @@
 * The `typeof()` primitive was added
 * Type stability for numeric operations (@69)
 
+## Noteable Bugs Addressed:
+
+* `substitute()` now works on datatypes such as literals or calls.
+
 ## Internals
 
 * The `List` is now represented as a `Rep<Obj>`, unifying heterogenous and atomic vectors.
   This included a considerable refactor.
 * Iterating over references of a `Rep<T>` was made much simpler and new methods were added
   and unused ones removed.
 * The `RepType` struct that was introduced in 0.4.0 was removed again (#189).
+* `eval_list_eager()` was removed from the `Context` trait and added as a member method for `CallStack`.
+* `eval_list_lazy()` now boxes all expressions in promises (including literals)
+  This is necessary to box `..a`-style ellipsis arguments in a list-call promise, which requires
+  access to the underlying expression.
 
 ## Notable Bugs Addressed
 

src/callable/core.rs

@@ -38,10 +38,9 @@ pub trait CallableFormals {
 pub trait Callable: CallableFormals {
     fn match_args(&self, args: List, stack: &mut CallStack) -> Result<(List, List), Signal> {
         let mut formals = self.formals();
-        // instead of using a List for ellipsis I want an ExprList
 
+        // this collects the expressions
         let mut expr_ellipsis: ExprList = ExprList::new();
-
         let mut ellipsis: List = List::new();
         let mut matched_args: List = List::new();
 

src/callable/primitive/list.rs

@@ -58,17 +58,6 @@ formals!(PrimitiveList, "(...)");
 
 impl Callable for PrimitiveList {
     fn call(&self, args: ExprList, stack: &mut CallStack) -> EvalResult {
-        for (name, arg) in args.clone() {
-            dbg!(&name);
-            dbg!(&arg);
-            //dbg!(stack.eval(arg)?);
-        }
-        // args.iter_pairs()
-        //     .map(|(k, v)| match (k, v.force(stack)) {
-        //         (k, Ok(v)) => Ok((k, v)),
-        //         (_, Err(e)) => Err(e),
-        //     })
-        //     .collect()
         stack.eval_list_eager(args)
     }
 

src/callable/primitive/substitute.rs

@@ -199,4 +199,11 @@ mod test {
         r_expect!(substitute(true) == true);
         r_expect!(substitute(1L) == 1L);
     }
+
+    #[test]
+    fn calls_work() {
+        r_expect! {{"
+            eval(substitute(fn(x) x))(1) == 1
+        "}}
+    }
 }

src/lang.rs

@@ -663,7 +663,6 @@ impl CallStack {
                                     Obj::Promise(_, expr, _) => {
                                         Ok((k, self.eval_and_finalize(expr)?))
                                     }
-                                    // todo: evaluated promise(?)
                                     _ => Ok((k, v)),
                                 })
                                 .collect::<Result<Vec<(Character, Obj)>, Signal>>()?;
@@ -1270,16 +1269,6 @@ mod test {
 
     #[test]
     fn fn_rest_arg_ellipsis() {
-        let x = CallStack::default()
-            .map_session(|s| s.with_experiments(vec![Experiment::RestArgs]))
-            .parse_and_eval(
-                "
-                    f <- fn(...) { . }
-                    f(1, 2, 3)
-                    ",
-            );
-        println!("{:?}", x);
-        // dbg!(&x);
         assert_eq!(
             CallStack::default()
                 .map_session(|s| s.with_experiments(vec![Experiment::RestArgs]))
@@ -1293,6 +1282,21 @@ mod test {
         )
     }
 
+    #[test]
+    fn accessing_ellipsis_forces_evaluation() {
+        assert_eq!(
+            CallStack::default()
+                .map_session(|s| s.with_experiments(vec![Experiment::RestArgs]))
+                .parse_and_eval(
+                    "
+                    f = fn(...) { . }
+                    f(sum(1))
+                    ",
+                ),
+            r! { list(1) }
+        )
+    }
+
     #[test]
     fn fn_duplicated_parameters() {
         assert_eq!(

src/object/ast.rs

@@ -107,7 +107,6 @@ impl ExprList {
     }
 }
 
-
 impl fmt::Display for ExprList {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let pairs: Vec<String> = self