From 51095f77ede02d3758f02dee0d30a2c083647f6a Mon Sep 17 00:00:00 2001
From: Roman Godmaire <godmaire@twilit.io>
Date: Sat, 4 May 2024 15:23:06 -0400
Subject: [PATCH] refactor: Extract Node enum to module

---
 src/evaluator/env.rs |  2 +-
 src/evaluator/mod.rs |  4 ++-
 src/main.rs          |  1 +
 src/node.rs          | 79 ++++++++++++++++++++++++++++++++++++++++++++
 src/parser/mod.rs    | 17 ++--------
 5 files changed, 86 insertions(+), 17 deletions(-)
 create mode 100644 src/node.rs

diff --git a/src/evaluator/env.rs b/src/evaluator/env.rs
index 4a60d99..58d5a9d 100644
--- a/src/evaluator/env.rs
+++ b/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)]
diff --git a/src/evaluator/mod.rs b/src/evaluator/mod.rs
index 683e266..6744bda 100644
--- a/src/evaluator/mod.rs
+++ b/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)
diff --git a/src/main.rs b/src/main.rs
index 0e9bdd3..8d71a83 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,6 +1,7 @@
 use std::io::{self, Write};
 
 mod evaluator;
+mod node;
 mod parser;
 
 fn main() {
diff --git a/src/node.rs b/src/node.rs
new file mode 100644
index 0000000..f79dbdc
--- /dev/null
+++ b/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:?}"),
+        }
+    }
+}
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
index 57eadc5..b6f0444 100644
--- a/src/parser/mod.rs
+++ b/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();