Start reducing ASTs

Start writing code to reduce AST nodes
q

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()
     }
 }