...

Author: sebffischer

src/callable/core.rs

@@ -38,6 +38,10 @@ 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
+
+        let mut expr_ellipsis: ExprList = ExprList::new();
+
         let mut ellipsis: List = List::new();
         let mut matched_args: List = List::new();
 
@@ -67,19 +71,27 @@ pub trait Callable: CallableFormals {
 
         // backfill unnamed args, populating ellipsis with overflow
         for (key, value) in args.iter_pairs() {
-            match key {
+            match (key, value.clone()) {
                 // named args go directly to ellipsis, they did not match a formal
-                Character::Some(arg) => ellipsis.push_named(Character::Some(arg), value),
+                (Character::Some(arg), Obj::Promise(_, e, _)) => {
+                    expr_ellipsis.push_named(Character::Some(arg.clone()).as_option(), e);
+                    ellipsis.push_named(Character::Some(arg), value);
+                }
 
                 // unnamed args populate next formal, or ellipsis if formals exhausted
-                Character::NA => {
+                (Character::NA, value) => {
                     let next_unassigned_formal = formals.remove(0);
                     if let Some((Some(param), _)) = next_unassigned_formal {
                         matched_args.push_named(Character::Some(param), value);
                     } else {
+                        let Obj::Promise(_, e, _) = value.clone() else {
+                            unreachable!()
+                        };
+                        expr_ellipsis.push_named(Character::NA.as_option(), e);
                         ellipsis.push_named(Character::NA, value);
                     }
                 }
+                _ => unreachable!(),
             }
         }
 
@@ -91,8 +103,20 @@ pub trait Callable: CallableFormals {
             )
         }
 
+        use crate::callable::builtins::BUILTIN;
+
+        let list = BUILTIN.get("list").cloned().unwrap();
+
+        // convert the expr_ellipsis to an Obj::Promise where the expression is a call into List
+
+        let a = Obj::Promise(
+            None,
+            Expr::Call(Box::new(Expr::Primitive(list)), expr_ellipsis),
+            stack.last_frame().env().clone(),
+        );
+
         if let Some(Expr::Ellipsis(Some(name))) = remainder.get(0) {
-            matched_args.push_named(Character::Some(name), Obj::List(ellipsis.clone()));
+            matched_args.push_named(Character::Some(name), a);
         } else if !remainder.is_empty() {
             matched_args.push_named(
                 Character::Some("...".to_string()),

src/callable/primitive/c.rs

@@ -1,7 +1,6 @@
 use r_derive::*;
 
 use crate::callable::core::*;
-use crate::context::Context;
 use crate::object::types::*;
 use crate::object::*;
 use crate::{formals, lang::*};

src/callable/primitive/list.rs

@@ -1,7 +1,6 @@
 use r_derive::*;
 
 use crate::callable::core::*;
-use crate::context::Context;
 use crate::formals;
 use crate::lang::*;
 use crate::object::*;

src/callable/primitive/quote.rs

@@ -25,8 +25,12 @@ use crate::object::*;
 ///
 /// ```custom,{class=r-repl}
 /// quote(x + y)
+/// quote(1)
 /// ```
-///
+/// ## Differentes to the R implementation
+/// While R treats literals as expressions this implementation of `quote` differentiates between
+/// the literal `1` and the length-1 vector "`c(1)`".
+/// Thereby the return type of `quote()` can be expected to be an object of type `Expression`.
 #[doc(alias = "quote")]
 #[builtin(sym = "quote")]
 #[derive(Debug, Clone, PartialEq)]

src/context/core.rs

@@ -1,7 +1,6 @@
 use std::rc::Rc;
 
 use crate::lang::{EvalResult, Signal};
-use crate::object::types::Character;
 use crate::object::*;
 use crate::{error::*, internal_err};
 

src/object/ast.rs

@@ -100,6 +100,14 @@ pub struct ExprList {
     pub values: Vec<Expr>,
 }
 
+impl ExprList {
+    pub fn push_named(&mut self, key: Option<String>, value: Expr) {
+        self.keys.push(key);
+        self.values.push(value);
+    }
+}
+
+
 impl fmt::Display for ExprList {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let pairs: Vec<String> = self