feat: add name to function

src/eval.rs

@@ -27,6 +27,7 @@ pub struct Frame {
 /// Closure function.
 #[derive(Clone)]
 pub struct Fun {
+    pub name: Expr,
     pub parameters: Vec<Keyword>,
     pub body: Expr,
 }
@@ -207,6 +208,7 @@ fn apply_expand(apply: crate::Apply, environment: &Environment) -> Result<Value,
 /// Expand fun expressions.
 fn fun_expand(fun: crate::Fun, environment: &Environment) -> Result<Value, Expr> {
     Ok(Value::Fun(Fun {
+        name: fun.name()?,
         parameters: fun
             .parameters()?
             .elements()?
@@ -230,7 +232,8 @@ impl Expr {
             // Base cases for expansion when it will just walk the tree. These
             // are the cases where the expansion is recursive.
             Expr::List(list) => Ok(Value::List(
-                /* elements: */ list.elements()?
+                /* elements: */
+                list.elements()?
                     .into_iter()
                     .map(|expr| expr.expand(environment))
                     .collect::<Result<Vec<_>, _>>()?,
@@ -240,7 +243,8 @@ impl Expr {
                 /* value: */ def.value()?.expand(environment)?.into(),
             )),
             Expr::Recur(recur) => Ok(Value::Recur(
-                /* arguments: */ recur
+                /* arguments: */
+                recur
                     .spine()?
                     .into_iter()
                     .map(|expr| expr.expand(environment))

src/lib.rs

@@ -52,7 +52,7 @@ define_ast!(Expr, {
 define_builtin!(DefMacro, "defmacro*", 2);
 define_builtin!(Def, "def*", 2);
 define_builtin!(Recur, "recur");
-define_builtin!(Fun, "fun*", 2);
+define_builtin!(Fun, "fun*", 3);
 define_builtin!(Quote, "'", 2);
 define_builtin!(Apply, "apply");
 
@@ -219,17 +219,25 @@ pub mod fun {
     use super::*;
 
     impl Fun {
+        /// Returns the name of the function.
+        pub fn name(&self) -> Result<Expr> {
+            self.0
+                .at(1)
+                .ok_or(SemanticError::InvalidExpression)?
+                .try_into()
+        }
+
         /// Returns a list of parameters that are in the spine of the function.
         pub fn parameters(&self) -> Result<List> {
             self.0
-                .at(1)
+                .at(2)
                 .map(List)
                 .ok_or(SemanticError::MissingParameters)
         }
 
         /// Returns the body of the function.
         pub fn body(&self) -> Result<Expr> {
-            self.0.at(2).ok_or(SemanticError::MissingBody)?.try_into()
+            self.0.at(3).ok_or(SemanticError::MissingBody)?.try_into()
         }
     }
 }