From 785c916ece93f15e1a197ca3eb9dfdc47b42447a Mon Sep 17 00:00:00 2001
From: greg <greg.shuflin@protonmail.com>
Date: Wed, 20 Jan 2016 02:26:46 -0800
Subject: [PATCH] Start reducing ASTs

Start writing code to reduce AST nodes
q
---
 src/eval.rs | 68 +++++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 55 insertions(+), 13 deletions(-)

diff --git a/src/eval.rs b/src/eval.rs
index 4e9f23a..ac778fc 100644
--- a/src/eval.rs
+++ b/src/eval.rs
@@ -1,4 +1,4 @@
-use parser::{AST, ASTNode};
+use parser::{AST, ASTNode, Expression};
 
 pub struct Evaluator {
     data: bool,
@@ -23,12 +23,60 @@ trait Evaluable {
     fn reduce(self) -> Self::Output;
 }
 
+impl Evaluable for ASTNode {
+    type Output = ASTNode;
+
+    fn is_reducible(&self) -> bool {
+        use parser::ASTNode::*;
+        match self {
+            &ExprNode(ref expr) => expr.is_reducible(),
+            _ => unimplemented!(),
+        }
+    }
+
+    fn reduce(self) -> Self::Output {
+        use parser::ASTNode::*;
+        match self {
+            ExprNode(expr) => {
+                if expr.is_reducible() {
+                    ExprNode(expr.reduce())
+                } else {
+                    ExprNode(expr)
+                }
+            },
+            _ => unimplemented!(),
+        }
+    }
+}
+
+impl Evaluable for Expression {
+    type Output = Expression;
+
+    fn is_reducible(&self) -> bool {
+        use parser::Expression::*;
+        match *self {
+            StringLiteral(_) => false,
+            Number(_) => false,
+            _ => true,
+        }
+    }
+
+    fn reduce(self) -> Self::Output {
+        use parser::Expression::*;
+        match self {
+            e@StringLiteral(_) => e,
+            e@Number(_) => e,
+            Variable(var) => Number(20.0),
+            _ => unimplemented!(),
+        }
+    }
+}
+
 impl Evaluator {
     fn reduce_node(&mut self, mut node: ASTNode) -> String {
         loop {
-            let (newnode, finished)  = self.step(node);
-            node = newnode;
-            if finished {
+            node = self.step(node);
+            if !node.is_reducible() {
                 break
             }
         }
@@ -36,14 +84,8 @@ impl Evaluator {
         format!("{:?}", node) //TODO make better
     }
 
-    fn step(&mut self, node: ASTNode) -> (ASTNode, bool) {
-        use parser::ASTNode::*;
-        use parser::Expression::*;
-        println!("Doing one step");
-        match node {
-            n@ExprNode(StringLiteral(_)) => (n, true),
-            n@ExprNode(Number(_)) => (n, true),
-            _ => unimplemented!(),
-        }
+    fn step(&mut self, node: ASTNode) -> ASTNode {
+        println!("Doing one step, current node is {:?}", node);
+        node.reduce()
     }
 }