refactor: Extract Node enum to module

src/evaluator/env.rs

@@ -2,7 +2,7 @@ use std::{borrow::Borrow, cell::RefCell, collections::HashMap, rc::Rc};
 
 use super::macros::arg_count;
 use super::{eval_ast_node, Error, Expression};
-use crate::parser::Node;
+use crate::node::Node;
 
 pub type RawEnvironment = HashMap<String, Rc<Expression>>;
 #[derive(Debug, Clone)]

src/evaluator/mod.rs

@@ -3,7 +3,7 @@ use std::{borrow::Borrow, collections::HashMap, rc::Rc};
 use anyhow::Result;
 use thiserror::Error;
 
-use crate::parser::Node;
+use crate::node::Node;
 
 mod env;
 mod macros;
@@ -169,6 +169,8 @@ fn eval_ast_node(env: Rc<Environment>, ast_node: Node) -> Result<Rc<Expression>>
 
         Node::Vector(vec) => todo!(),
         Node::Map(map) => todo!(),
+        Node::Function { params, env, body } => todo!(),
+        Node::NativeFunc(_) => todo!(),
     };
 
     Ok(expr)

src/main.rs

@@ -1,6 +1,7 @@
 use std::io::{self, Write};
 
 mod evaluator;
+mod node;
 mod parser;
 
 fn main() {

src/node.rs

@@ -0,0 +1,79 @@
+use std::collections::HashMap;
+
+use anyhow::Result;
+
+use crate::evaluator::Environment;
+
+#[derive(Debug, Clone)]
+pub enum Node {
+    List(Vec<Node>),
+
+    Symbol(String),
+    Keyword(String),
+    Int(i64),
+    String(String),
+    Boolean(bool),
+    Nil,
+
+    Vector(Vec<Node>),
+    Map(HashMap<String, Node>),
+    Function {
+        params: Vec<String>,
+        env: Environment,
+        body: Box<Node>,
+    },
+    NativeFunc(fn(env: Environment, args: Vec<Node>) -> Result<Node>),
+}
+
+impl std::fmt::Display for Node {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Node::List(list) => {
+                let s = list
+                    .iter()
+                    .map(|elem| elem.to_string())
+                    .reduce(|lhs, rhs| format!("{lhs} {rhs}"))
+                    .unwrap_or_default();
+
+                write!(f, "({s})")
+            }
+
+            Node::Int(val) => write!(f, "{}", val),
+            Node::Boolean(true) => write!(f, "true"),
+            Node::Boolean(false) => write!(f, "false"),
+            Node::Symbol(val) => write!(f, "{}", val),
+            Node::Keyword(val) => write!(f, ":{}", val),
+            Node::String(val) => write!(f, "{}", val),
+            Node::Nil => write!(f, "()"),
+
+            Node::Vector(vec) => {
+                let s = vec
+                    .iter()
+                    .map(|elem| elem.to_string())
+                    .reduce(|lhs, rhs| format!("{lhs} {rhs}"))
+                    .unwrap_or_default();
+
+                write!(f, "[{s}]")
+            }
+            Node::Map(map) => {
+                let res = map
+                    .iter()
+                    .map(|(k, v)| format!("{k}: {v}"))
+                    .reduce(|lhs, rhs| format!("{lhs}, {rhs}"))
+                    .unwrap_or_default();
+
+                write!(f, "{{{res}}}")
+            }
+
+            Node::Function {
+                params: _,
+                env: _,
+                body: _,
+            } => {
+                write!(f, "#<function>")
+            }
+
+            Node::NativeFunc(func) => write!(f, "{func:?}"),
+        }
+    }
+}

src/parser/mod.rs

@@ -1,24 +1,11 @@
-use std::{collections::HashMap, iter::Peekable, vec::IntoIter};
+use std::{iter::Peekable, vec::IntoIter};
 
 use anyhow::{bail, Result};
 
 mod lexer;
 use lexer::Token;
 
-#[derive(Debug, Clone)]
-pub enum Node {
-    List(Vec<Node>),
-
-    Symbol(String),
-    Keyword(String),
-    Int(i64),
-    String(String),
-    Boolean(bool),
-    Nil,
-
-    Vector(Vec<Node>),
-    Map(HashMap<String, Node>),
-}
+use crate::node::Node;
 
 pub fn parse_str(input: &str) -> Result<Vec<Node>> {
     let mut tokens = lexer::read(input)?.into_iter().peekable();