chore: macro cleanup; lazy_static to sync::LazyLock (#171)

.rustfmt.toml

@@ -0,0 +1 @@
+struct_lit_width = 50

Cargo.toml

@@ -33,7 +33,6 @@ r_derive = { path = "r_derive" }
 # parser
 pest = "2.7.10"
 pest_derive = "2.7.10"
-lazy_static = "1.4.0"
 
 # rng
 rand = "0.8.5"

r_derive/src/lib.rs

@@ -27,12 +27,7 @@ impl Parse for Builtin {
 
         for var in vars {
             match (var.path, var.value) {
-                (
-                    k,
-                    Expr::Lit(ExprLit {
-                        lit: Lit::Str(s), ..
-                    }),
-                ) => match k {
+                (k, Expr::Lit(ExprLit { lit: Lit::Str(s), .. })) => match k {
                     sym if sym.is_ident("sym") => symbol = Some(s),
                     _ => (),
                 },

src/callable/builtins.rs

@@ -2,61 +2,58 @@
 ///
 /// The contents of this file are built by build.rs
 ///
-use hashbrown::HashMap;
-
-use ::lazy_static::lazy_static;
-
 use crate::callable::core::Builtin;
 use crate::callable::operators::*;
 use crate::callable::primitive::*;
+use hashbrown::HashMap;
+use std::sync::LazyLock;
 
-lazy_static! {
-    pub static ref BUILTIN: HashMap<&'static str, Box<dyn Builtin>> = {
-        HashMap::from([
-            // automatically populated on build. see build.rs // builtins start
-            ("<-", Box::new(InfixAssign) as Box<dyn Builtin>),
-            ("+", Box::new(InfixAdd) as Box<dyn Builtin>),
-            ("-", Box::new(InfixSub) as Box<dyn Builtin>),
-            ("-", Box::new(PrefixSub) as Box<dyn Builtin>),
-            ("!", Box::new(PrefixNot) as Box<dyn Builtin>),
-            ("..", Box::new(PrefixPack) as Box<dyn Builtin>),
-            ("*", Box::new(InfixMul) as Box<dyn Builtin>),
-            ("/", Box::new(InfixDiv) as Box<dyn Builtin>),
-            ("^", Box::new(InfixPow) as Box<dyn Builtin>),
-            ("%", Box::new(InfixMod) as Box<dyn Builtin>),
-            ("||", Box::new(InfixOr) as Box<dyn Builtin>),
-            ("&&", Box::new(InfixAnd) as Box<dyn Builtin>),
-            ("|", Box::new(InfixVectorOr) as Box<dyn Builtin>),
-            ("&", Box::new(InfixVectorAnd) as Box<dyn Builtin>),
-            (">", Box::new(InfixGreater) as Box<dyn Builtin>),
-            (">=", Box::new(InfixGreaterEqual) as Box<dyn Builtin>),
-            ("<", Box::new(InfixLess) as Box<dyn Builtin>),
-            ("<=", Box::new(InfixLessEqual) as Box<dyn Builtin>),
-            ("==", Box::new(InfixEqual) as Box<dyn Builtin>),
-            ("!=", Box::new(InfixNotEqual) as Box<dyn Builtin>),
-            ("|>", Box::new(InfixPipe) as Box<dyn Builtin>),
-            (":", Box::new(InfixColon) as Box<dyn Builtin>),
-            ("$", Box::new(InfixDollar) as Box<dyn Builtin>),
-            ("..", Box::new(PostfixPack) as Box<dyn Builtin>),
-            ("[[", Box::new(PostfixIndex) as Box<dyn Builtin>),
-            ("[", Box::new(PostfixVecIndex) as Box<dyn Builtin>),
-            ("c", Box::new(PrimitiveC) as Box<dyn Builtin>),
-            ("callstack", Box::new(PrimitiveCallstack) as Box<dyn Builtin>),
-            ("environment", Box::new(PrimitiveEnvironment) as Box<dyn Builtin>),
-            ("eval", Box::new(PrimitiveEval) as Box<dyn Builtin>),
-            ("length", Box::new(PrimitiveLength) as Box<dyn Builtin>),
-            ("list", Box::new(PrimitiveList) as Box<dyn Builtin>),
-            ("names", Box::new(PrimitiveNames) as Box<dyn Builtin>),
-            ("parent", Box::new(PrimitiveParent) as Box<dyn Builtin>),
-            ("paste", Box::new(PrimitivePaste) as Box<dyn Builtin>),
-            ("print", Box::new(PrimitivePrint) as Box<dyn Builtin>),
-            ("q", Box::new(PrimitiveQ) as Box<dyn Builtin>),
-            ("quote", Box::new(PrimitiveQuote) as Box<dyn Builtin>),
-            ("rnorm", Box::new(PrimitiveRnorm) as Box<dyn Builtin>),
-            ("runif", Box::new(PrimitiveRunif) as Box<dyn Builtin>),
-            ("substitute", Box::new(PrimitiveSubstitute) as Box<dyn Builtin>),
-            ("sum", Box::new(PrimitiveSum) as Box<dyn Builtin>),
-            // builtins end
-        ])
-    };
-}
+#[rustfmt::skip]
+pub static BUILTIN: LazyLock<HashMap<&'static str, Box<dyn Builtin>>> = LazyLock::new(|| {
+    HashMap::from([
+        // automatically populated on build. see build.rs // builtins start
+        ("<-", Box::new(InfixAssign) as Box<dyn Builtin>),
+        ("+", Box::new(InfixAdd) as Box<dyn Builtin>),
+        ("-", Box::new(InfixSub) as Box<dyn Builtin>),
+        ("-", Box::new(PrefixSub) as Box<dyn Builtin>),
+        ("!", Box::new(PrefixNot) as Box<dyn Builtin>),
+        ("..", Box::new(PrefixPack) as Box<dyn Builtin>),
+        ("*", Box::new(InfixMul) as Box<dyn Builtin>),
+        ("/", Box::new(InfixDiv) as Box<dyn Builtin>),
+        ("^", Box::new(InfixPow) as Box<dyn Builtin>),
+        ("%", Box::new(InfixMod) as Box<dyn Builtin>),
+        ("||", Box::new(InfixOr) as Box<dyn Builtin>),
+        ("&&", Box::new(InfixAnd) as Box<dyn Builtin>),
+        ("|", Box::new(InfixVectorOr) as Box<dyn Builtin>),
+        ("&", Box::new(InfixVectorAnd) as Box<dyn Builtin>),
+        (">", Box::new(InfixGreater) as Box<dyn Builtin>),
+        (">=", Box::new(InfixGreaterEqual) as Box<dyn Builtin>),
+        ("<", Box::new(InfixLess) as Box<dyn Builtin>),
+        ("<=", Box::new(InfixLessEqual) as Box<dyn Builtin>),
+        ("==", Box::new(InfixEqual) as Box<dyn Builtin>),
+        ("!=", Box::new(InfixNotEqual) as Box<dyn Builtin>),
+        ("|>", Box::new(InfixPipe) as Box<dyn Builtin>),
+        (":", Box::new(InfixColon) as Box<dyn Builtin>),
+        ("$", Box::new(InfixDollar) as Box<dyn Builtin>),
+        ("..", Box::new(PostfixPack) as Box<dyn Builtin>),
+        ("[[", Box::new(PostfixIndex) as Box<dyn Builtin>),
+        ("[", Box::new(PostfixVecIndex) as Box<dyn Builtin>),
+        ("c", Box::new(PrimitiveC) as Box<dyn Builtin>),
+        ("callstack", Box::new(PrimitiveCallstack) as Box<dyn Builtin>),
+        ("environment", Box::new(PrimitiveEnvironment) as Box<dyn Builtin>),
+        ("eval", Box::new(PrimitiveEval) as Box<dyn Builtin>),
+        ("length", Box::new(PrimitiveLength) as Box<dyn Builtin>),
+        ("list", Box::new(PrimitiveList) as Box<dyn Builtin>),
+        ("names", Box::new(PrimitiveNames) as Box<dyn Builtin>),
+        ("parent", Box::new(PrimitiveParent) as Box<dyn Builtin>),
+        ("paste", Box::new(PrimitivePaste) as Box<dyn Builtin>),
+        ("print", Box::new(PrimitivePrint) as Box<dyn Builtin>),
+        ("q", Box::new(PrimitiveQ) as Box<dyn Builtin>),
+        ("quote", Box::new(PrimitiveQuote) as Box<dyn Builtin>),
+        ("rnorm", Box::new(PrimitiveRnorm) as Box<dyn Builtin>),
+        ("runif", Box::new(PrimitiveRunif) as Box<dyn Builtin>),
+        ("substitute", Box::new(PrimitiveSubstitute) as Box<dyn Builtin>),
+        ("sum", Box::new(PrimitiveSum) as Box<dyn Builtin>),
+        // builtins end
+    ])
+});

src/callable/core.rs

@@ -1,10 +1,8 @@
 extern crate r_derive;
 
-use crate::callable::builtins::BUILTIN;
 use crate::callable::dyncompare::*;
 use crate::cli::Experiment;
 use crate::context::Context;
-use crate::error::Error;
 use crate::object::List;
 use crate::object::{Expr, ExprList, Obj};
 use crate::{internal_err, lang::*};
@@ -31,11 +29,13 @@ pub trait CallableClone: Callable {
     fn callable_clone(&self) -> Box<dyn Builtin>;
 }
 
-pub trait Callable {
+pub trait CallableFormals {
     fn formals(&self) -> ExprList {
-        ExprList::new()
+        ExprList::default()
     }
+}
 
+pub trait Callable: CallableFormals {
     fn match_args(&self, args: List, stack: &mut CallStack) -> Result<(List, List), Signal> {
         let mut formals = self.formals();
         let ellipsis: List = vec![].into();
@@ -200,7 +200,7 @@ pub trait Format {
     }
 }
 
-pub trait Builtin: Callable + CallableClone + Format + DynCompare + Sync {
+pub trait Builtin: Callable + CallableClone + Format + DynCompare + Sync + Send {
     fn is_transparent(&self) -> bool {
         false
     }
@@ -273,20 +273,9 @@ where
     }
 }
 
+impl CallableFormals for String {}
 impl Builtin for String {}
 
-pub fn builtin(s: &str) -> Result<Box<dyn Builtin>, Signal> {
-    let err = Error::VariableNotFound(s.to_string());
-    <Box<dyn Builtin>>::try_from(s).or(Err(err.into()))
-}
-
-impl TryFrom<&str> for Box<dyn Builtin> {
-    type Error = ();
-    fn try_from(s: &str) -> Result<Self, Self::Error> {
-        BUILTIN.get(s).map_or(Err(()), |b| Ok(b.clone()))
-    }
-}
-
 pub fn force_promises(
     vals: List,
     stack: &mut CallStack,
@@ -316,6 +305,15 @@ impl Callable for String {
 
 impl Format for Obj {}
 
+impl CallableFormals for Obj {
+    fn formals(&self) -> ExprList {
+        match self {
+            Obj::Function(formals, _, _) => formals.clone(),
+            _ => ExprList::new(),
+        }
+    }
+}
+
 impl Callable for Obj {
     fn call(&self, args: ExprList, stack: &mut CallStack) -> EvalResult {
         let Obj::Function(_, body, _) = self else {
@@ -344,13 +342,6 @@ impl Callable for Obj {
         stack.env().append(args);
         stack.eval(body.clone())
     }
-
-    fn formals(&self) -> ExprList {
-        match self {
-            Obj::Function(formals, _, _) => formals.clone(),
-            _ => ExprList::new(),
-        }
-    }
 }
 
 #[cfg(test)]

src/callable/keywords.rs

@@ -21,6 +21,8 @@ impl Format for KeywordReturn {
     }
 }
 
+impl CallableFormals for KeywordReturn {}
+
 impl Callable for KeywordReturn {
     fn call(&self, args: ExprList, stack: &mut CallStack) -> EvalResult {
         let mut args = args.values.into_iter();
@@ -50,6 +52,8 @@ impl Format for KeywordIf {
     }
 }
 
+impl CallableFormals for KeywordIf {}
+
 impl Callable for KeywordIf {
     fn call(&self, args: ExprList, stack: &mut CallStack) -> EvalResult {
         let mut args = args.values.into_iter();
@@ -70,6 +74,8 @@ impl Callable for KeywordIf {
 #[builtin]
 pub struct KeywordFor;
 
+impl CallableFormals for KeywordFor {}
+
 impl Format for KeywordFor {
     fn rfmt_call_with(&self, _state: FormatState, args: &ExprList) -> String {
         let Some(sym) = &args.keys[0] else {
@@ -126,6 +132,8 @@ impl Callable for KeywordFor {
 #[builtin]
 pub struct KeywordWhile;
 
+impl CallableFormals for KeywordWhile {}
+
 impl Format for KeywordWhile {
     fn rfmt_call_with(&self, _state: FormatState, args: &ExprList) -> String {
         format!("while ({}) {}", args.values[0], args.values[1])
@@ -181,6 +189,8 @@ impl Format for KeywordRepeat {
     }
 }
 
+impl CallableFormals for KeywordRepeat {}
+
 impl Callable for KeywordRepeat {
     fn call(&self, args: ExprList, stack: &mut CallStack) -> EvalResult {
         let mut args = args.values.into_iter();
@@ -213,6 +223,8 @@ impl Callable for KeywordRepeat {
 #[builtin]
 pub struct KeywordParen;
 
+impl CallableFormals for KeywordParen {}
+
 impl Format for KeywordParen {
     fn rfmt_call_with(&self, _state: FormatState, args: &ExprList) -> String {
         format!("({})", args.values.first().unwrap())
@@ -234,6 +246,8 @@ impl Callable for KeywordParen {
 #[builtin]
 pub struct KeywordBlock;
 
+impl CallableFormals for KeywordBlock {}
+
 impl Format for KeywordBlock {
     fn rfmt_call_with(&self, _state: FormatState, args: &ExprList) -> String {
         format!(
@@ -267,6 +281,44 @@ impl Callable for KeywordBlock {
     }
 }
 
+#[derive(Debug, Clone, PartialEq)]
+#[builtin]
+pub struct KeywordVec;
+
+impl Format for KeywordVec {
+    fn rfmt_call_with(&self, _state: FormatState, args: &ExprList) -> String {
+        format!("[{}]", args)
+    }
+}
+
+impl CallableFormals for KeywordVec {}
+
+impl Callable for KeywordVec {
+    fn call(&self, args: ExprList, stack: &mut CallStack) -> EvalResult {
+        // for now just use c()
+        super::primitive::PrimitiveC.call(args, stack)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+#[builtin]
+pub struct KeywordList;
+
+impl Format for KeywordList {
+    fn rfmt_call_with(&self, _state: FormatState, args: &ExprList) -> String {
+        let trailing_comma = if args.len() > 1 { "" } else { "," };
+        format!("({}{})", args, trailing_comma)
+    }
+}
+
+impl CallableFormals for KeywordList {}
+
+impl Callable for KeywordList {
+    fn call(&self, args: ExprList, stack: &mut CallStack) -> EvalResult {
+        super::primitive::PrimitiveList.call(args, stack)
+    }
+}
+
 #[cfg(test)]
 mod test {
     use crate::r;