simplify builtins more

src/builtins.rs

···
 use crate::{
     ast,
     eval::{Context, Error, Result, Value},
-    Wrap
+    Wrap,
 };
 
-pub static BUILTINS: LazyLock<HashMap<&'static str, Box<dyn Builtin + Sync + Send>>> =
-    LazyLock::new(|| {
-        [
-            Print.boxed(),
-            IsUpper.boxed(),
-            IsLower.boxed(),
-            Substr.boxed(),
-            Text.boxed(),
-            Parent.boxed(),
-            Children.boxed(),
-            Length.boxed(),
-            Kind.boxed(),
-        ]
-        .into_iter()
-        .map(|b| (b.id(), b))
-        .collect()
-    });
-
-pub(crate) trait Builtin
-where
-    Self: 'static,
-{
-    /// Name of this function
-    fn id(&self) -> &'static str;
-
-    /// Function description
-    fn eval(&self, ctx: &mut Context, args: &[ast::Expr]) -> Result;
-
-    /// Anything that is Builtin can be turned into a trait object
-    fn boxed(self) -> Box<dyn Builtin + Sync + Send>
-    where
-        Self: Sized + Sync + Send,
-    {
-        Box::new(self) as Box<dyn Builtin + Sync + Send>
+macro_rules! builtins {
+    ($($f:ident),* $(,)?) => {
+        pub static BUILTINS: LazyLock<HashMap<&'static str, Box<dyn Fn(&mut Context, &[ast::Expr]) -> Result + Sync + Send>>> =
+            LazyLock::new(|| {
+                [
+                    $((
+                        stringify!($f),
+                        Box::new($f) as Box<dyn Fn(&mut Context, &[ast::Expr]) -> Result + Sync + Send>,
+                    )),*
+                ]
+                    .into_iter()
+                    .collect()
+            });
     }
 }
 
-fn get_args<const N: usize>(args: &[ast::Expr]) -> std::result::Result<&[ast::Expr; N], Error> {
-    args.try_into().map_err(|_| Error::IncorrectArgFormat {
-        wanted: N,
-        got: args.len(),
-    })
-}
-
-struct Print;
-impl Builtin for Print {
-    fn id(&self) -> &'static str {
-        "print"
-    }
+builtins! {
+    print,
 
-    fn eval(&self, ctx: &mut Context, args: &[ast::Expr]) -> Result {
-        for arg in args {
-            let val = ctx.eval_expr(arg)?;
-            print!("{val}");
-        }
-        Ok(Value::Unit)
-    }
-}
+    // string
+    isupper,
+    islower,
+    substr,
 
-struct IsUpper;
-impl Builtin for IsUpper {
-    fn id(&self) -> &'static str {
-        "isupper"
-    }
+    // node
+    text,
+    parent,
+    children,
+    kind,
 
-    fn eval(&self, ctx: &mut Context, args: &[ast::Expr]) -> Result {
-        Ok(ctx
-            .eval_expr(&get_args::<1>(args)?[0])?
-            .as_str()?
-            .chars()
-            .all(|c| c.is_ascii_uppercase())
-            .into())
-    }
+    // list
+    length,
+    member,
 }
 
-struct IsLower;
-impl Builtin for IsLower {
-    fn id(&self) -> &'static str {
-        "islower"
+fn print(ctx: &mut Context, args: &[ast::Expr]) -> Result {
+    for arg in args {
+        let val = ctx.eval_expr(arg)?;
+        print!("{val}");
     }
+    Ok(Value::Unit)
+}
 
-    fn eval(&self, ctx: &mut Context, args: &[ast::Expr]) -> Result {
-        Ok(ctx
-            .eval_expr(&get_args::<1>(args)?[0])?
-            .as_str()?
-            .chars()
-            .all(|c| c.is_ascii_lowercase())
-            .into())
-    }
+fn isupper(ctx: &mut Context, args: &[ast::Expr]) -> Result {
+    Ok(ctx
+        .eval_expr(&get_args::<1>(args)?[0])?
+        .as_str()?
+        .chars()
+        .all(|c| c.is_ascii_uppercase())
+        .into())
 }
 
-struct Substr;
-impl Builtin for Substr {
-    fn id(&self) -> &'static str {
-        "substr"
-    }
+fn islower(ctx: &mut Context, args: &[ast::Expr]) -> Result {
+    Ok(ctx
+        .eval_expr(&get_args::<1>(args)?[0])?
+        .as_str()?
+        .chars()
+        .all(|c| c.is_ascii_lowercase())
+        .into())
+}
 
-    fn eval(&self, ctx: &mut Context, args: &[ast::Expr]) -> Result {
-        if let Ok([string, start, end]) = get_args::<3>(args) {
-            let v = ctx.eval_expr(string)?;
-            let s = v.as_str()?;
-            let start = ctx.eval_expr(start)?.as_int()?;
-            let end = ctx.eval_expr(end)?.as_int()?;
-            if start < 0 || start >= s.len() as i128 || end >= s.len() as i128 || start > end {
-                return Err(Error::InvalidStringSlice {
-                    length: s.len(),
-                    start,
-                    end,
-                });
-            }
-            Ok(s[start as usize..end as usize].into())
-        } else {
-            let [string, end] = get_args::<2>(args)?;
-            let v = ctx.eval_expr(string)?;
-            let s = v.as_str()?;
-            let end = ctx.eval_expr(end)?.as_int()?;
-            if end >= s.len() as i128 {
-                return Err(Error::InvalidStringSlice {
-                    length: s.len(),
-                    start: 0,
-                    end,
-                });
-            }
-            Ok(s[..end as usize].into())
+fn substr(ctx: &mut Context, args: &[ast::Expr]) -> Result {
+    if let Ok([string, start, end]) = get_args::<3>(args) {
+        let v = ctx.eval_expr(string)?;
+        let s = v.as_str()?;
+        let start = ctx.eval_expr(start)?.as_int()?;
+        let end = ctx.eval_expr(end)?.as_int()?;
+        if start < 0 || start >= s.len() as i128 || end >= s.len() as i128 || start > end {
+            return Err(Error::InvalidStringSlice {
+                length: s.len(),
+                start,
+                end,
+            });
         }
+        Ok(s[start as usize..end as usize].into())
+    } else {
+        let [string, end] = get_args::<2>(args)?;
+        let v = ctx.eval_expr(string)?;
+        let s = v.as_str()?;
+        let end = ctx.eval_expr(end)?.as_int()?;
+        if end >= s.len() as i128 {
+            return Err(Error::InvalidStringSlice {
+                length: s.len(),
+                start: 0,
+                end,
+            });
+        }
+        Ok(s[..end as usize].into())
     }
 }
 
-struct Text;
-impl Builtin for Text {
-    fn id(&self) -> &'static str {
-        "text"
-    }
-
-    fn eval(&self, ctx: &mut Context, args: &[ast::Expr]) -> Result {
-        let v = ctx.eval_expr(&get_args::<1>(args)?[0])?;
-        let id = v.as_node()?;
-        let node = ctx.get_node_by_id(id).unwrap();
-        let text = node
-            .utf8_text(ctx.input_src.as_ref().unwrap().as_bytes())
-            .unwrap();
-        text.to_owned().wrap(Value::String).wrap(Ok)
-    }
+fn text(ctx: &mut Context, args: &[ast::Expr]) -> Result {
+    let v = ctx.eval_expr(&get_args::<1>(args)?[0])?;
+    let id = v.as_node()?;
+    let node = ctx.get_node_by_id(id).unwrap();
+    let text = node
+        .utf8_text(ctx.input_src.as_ref().unwrap().as_bytes())
+        .unwrap();
+    text.to_owned().wrap(Value::String).wrap(Ok)
 }
 
-struct Parent;
-impl Builtin for Parent {
-    fn id(&self) -> &'static str {
-        "parent"
-    }
-
-    fn eval(&self, ctx: &mut Context, args: &[ast::Expr]) -> Result {
-        let v = ctx.eval_expr(&get_args::<1>(args)?[0])?;
-        let id = v.as_node()?;
-        let node = ctx.get_node_by_id(id).unwrap();
-        let parent = node.parent();
-        parent
-            .map(|n| Value::Node(n.id()))
-            .ok_or(Error::NoParentNode(node))
-    }
+fn parent(ctx: &mut Context, args: &[ast::Expr]) -> Result {
+    let v = ctx.eval_expr(&get_args::<1>(args)?[0])?;
+    let id = v.as_node()?;
+    let node = ctx.get_node_by_id(id).unwrap();
+    let parent = node.parent();
+    parent
+        .map(|n| Value::Node(n.id()))
+        .ok_or(Error::NoParentNode(node))
 }
 
-struct Children;
-impl Builtin for Children {
-    fn id(&self) -> &'static str {
-        "children"
-    }
-
-    fn eval(&self, ctx: &mut Context, args: &[ast::Expr]) -> Result {
-        let v = ctx.eval_expr(&get_args::<1>(args)?[0])?;
-        let id = v.as_node()?;
-        let node = ctx.get_node_by_id(id).unwrap();
-        let children = node
-            .children(&mut node.walk())
-            .map(|c| Value::Node(c.id()))
-            .collect::<Vec<_>>();
-        Ok(Value::List(children))
-    }
+fn children(ctx: &mut Context, args: &[ast::Expr]) -> Result {
+    let v = ctx.eval_expr(&get_args::<1>(args)?[0])?;
+    let id = v.as_node()?;
+    let node = ctx.get_node_by_id(id).unwrap();
+    let children = node
+        .children(&mut node.walk())
+        .map(|c| Value::Node(c.id()))
+        .collect::<Vec<_>>();
+    Ok(Value::List(children))
 }
 
-struct Length;
-impl Builtin for Length {
-    fn id(&self) -> &'static str {
-        "length"
-    }
+fn length(ctx: &mut Context, args: &[ast::Expr]) -> Result {
+    let v = ctx.eval_expr(&get_args::<1>(args)?[0])?;
+    let l = v.as_list()?;
+    (l.len() as i128).wrap(Value::Integer).wrap(Ok)
+}
 
-    fn eval(&self, ctx: &mut Context, args: &[ast::Expr]) -> Result {
-        let v = ctx.eval_expr(&get_args::<1>(args)?[0])?;
-        let l = v.as_list()?;
-        (l.len() as i128).wrap(Value::Integer).wrap(Ok)
-    }
+fn kind(ctx: &mut Context, args: &[ast::Expr]) -> Result {
+    let v = ctx.eval_expr(&get_args::<1>(args)?[0])?;
+    let id = v.as_node()?;
+    let node = ctx.get_node_by_id(id).unwrap();
+    node.kind().to_owned().wrap(Value::String).wrap(Ok)
 }
 
-struct Kind;
-impl Builtin for Kind {
-    fn id(&self) -> &'static str {
-        "kind"
-    }
+fn member(ctx: &mut Context, args: &[ast::Expr]) -> Result {
+    let [list_expr, element_expr] = get_args::<2>(args)?;
+    let list = ctx.eval_expr(&list_expr)?;
+    let v = list.as_list()?;
+    let element = ctx.eval_expr(&element_expr)?;
+    v.iter()
+        .any(|item| item == &element)
+        .wrap(Value::Boolean)
+        .wrap(Ok)
+}
 
-    fn eval(&self, ctx: &mut Context, args: &[ast::Expr]) -> Result {
-        let v = ctx.eval_expr(&get_args::<1>(args)?[0])?;
-        let id = v.as_node()?;
-        let node = ctx.get_node_by_id(id).unwrap();
-        node.kind().to_owned().wrap(Value::String).wrap(Ok)
-    }
+fn get_args<const N: usize>(args: &[ast::Expr]) -> std::result::Result<&[ast::Expr; N], Error> {
+    args.try_into().map_err(|_| Error::IncorrectArgFormat {
+        wanted: N,
+        got: args.len(),
+    })
 }

src/eval.rs

···
     }
 
     fn eval_call(&mut self, call: &ast::Call) -> Result {
-        (&*crate::builtins::BUILTINS)
-            .get(call.function.as_str())
-            .ok_or_else(|| Error::FailedLookup(call.function.to_owned()))?
-            .eval(self, call.parameters.as_slice())
+        ((&*crate::builtins::BUILTINS)
+         .get(call.function.as_str())
+         .ok_or_else(|| Error::FailedLookup(call.function.to_owned()))?)
+            (self, call.parameters.as_slice())
     }
 
     fn eval_list(&mut self, list: &ast::List) -> Result {