Separated match arms in the interpreter into their own functions.

src/interpreter.rs

@@ -63,18 +63,44 @@ impl Unit {
 impl<'a> Visitor<f64, f64> for Interpreter<'a> {
     fn visit_stmt(&mut self, stmt: &Stmt) -> f64 {
         match stmt {
-            Stmt::VarDecl(identifier, _) => {
+            Stmt::VarDecl(identifier, _) => self.eval_var_decl_stmt(stmt, identifier),
-                self.symbol_table.insert(&identifier, stmt.clone());
+            Stmt::FnDecl(_, _, _) => self.eval_fn_decl_stmt(),
-                0f64
+            Stmt::Expr(expr) => self.eval_expr_stmt(&expr),
-            }
-            Stmt::FnDecl(_, _, _) => 0f64, // Nothing needs to happen here, since the parser will already have added the FnDecl's to the symbol table.
-            Stmt::Expr(expr) => self.visit_expr(&expr),
         }
     }
 
     fn visit_expr(&mut self, expr: &Expr) -> f64 {
         match expr {
-            Expr::Binary(left, op, right) => {
+            Expr::Binary(left, op, right) => self.eval_binary_expr(&left, op, &right),
+            Expr::Unary(_, expr) => self.eval_unary_expr(expr),
+            Expr::Unit(expr, kind) => self.eval_unit_expr(expr, kind),
+            Expr::Var(identifier) => self.eval_var_expr(identifier),
+            Expr::Literal(value) => self.eval_literal_expr(value),
+            Expr::Group(expr) => self.eval_group_expr(&expr),
+            Expr::FnCall(identifier, expressions) => {
+                self.eval_fn_call_expr(identifier, expressions)
+            }
+        }
+    }
+}
+
+impl<'a> Interpreter<'a> {
+    fn eval_var_decl_stmt(&mut self, stmt: &Stmt, identifier: &str) -> f64 {
+        self.symbol_table.insert(&identifier, stmt.clone());
+        0f64
+    }
+
+    fn eval_fn_decl_stmt(&mut self) -> f64 {
+        0f64 // Nothing needs to happen here, since the parser will already have added the FnDecl's to the symbol table.
+    }
+
+    fn eval_expr_stmt(&mut self, expr: &Expr) -> f64 {
+        self.visit_expr(&expr)
+    }
+}
+
+impl<'a> Interpreter<'a> {
+    fn eval_binary_expr(&mut self, left: &Expr, op: &TokenKind, right: &Expr) -> f64 {
         let left = self.visit_expr(&left);
         let right = self.visit_expr(&right);
 
@@ -87,8 +113,12 @@ impl<'a> Visitor<f64, f64> for Interpreter<'a> {
             _ => 0f64,
         }
     }
-            Expr::Unary(_, expr) => self.visit_expr(&expr).clone(),
+
-            Expr::Unit(expr, kind) => {
+    fn eval_unary_expr(&mut self, expr: &Expr) -> f64 {
+        self.visit_expr(&expr).clone()
+    }
+
+    fn eval_unit_expr(&mut self, expr: &Expr, kind: &TokenKind) -> f64 {
         let x = self.visit_expr(&expr);
 
         // Don't do any angle conversions if the defauly angle unit is the same as the unit kind
@@ -104,7 +134,8 @@ impl<'a> Visitor<f64, f64> for Interpreter<'a> {
             _ => panic!("Invalid unit."),
         }
     }
-            Expr::Var(identifier) => {
+
+    fn eval_var_expr(&mut self, identifier: &str) -> f64 {
         let value = self
             .symbol_table
             .get(identifier)
@@ -116,9 +147,16 @@ impl<'a> Visitor<f64, f64> for Interpreter<'a> {
 
         panic!("Unknown error.");
     }
-            Expr::Literal(value) => value.parse().unwrap(),
+
-            Expr::Group(expr) => self.visit_expr(&expr),
+    fn eval_literal_expr(&mut self, value: &str) -> f64 {
-            Expr::FnCall(identifier, expressions) => {
+        value.parse().unwrap()
+    }
+
+    fn eval_group_expr(&mut self, expr: &Expr) -> f64 {
+        self.visit_expr(expr)
+    }
+
+    fn eval_fn_call_expr(&mut self, identifier: &str, expressions: &Vec<Expr>) -> f64 {
         let prelude_func = match expressions.len() {
             1 => {
                 let x = self.visit_expr(&expressions[0]);
@@ -133,8 +171,9 @@ impl<'a> Visitor<f64, f64> for Interpreter<'a> {
         };
 
         if let Some(result) = prelude_func {
-                    result
+            return result;
-                } else {
+        }
+
         let stmt = self
             .symbol_table
             .get(&format!("{}()", identifier))
@@ -159,7 +198,4 @@ impl<'a> Visitor<f64, f64> for Interpreter<'a> {
 
         panic!("Unexpected error.");
     }
-            }
-        }
-    }
 }

src/parser.rs

@@ -50,17 +50,6 @@ impl TokenKind {
     }
 }
 
-/*impl Parser {
-    pub fn new() -> Parser {
-        Parser {
-            tokens: Vec::new(),
-            pos: 0,
-            symbol_table: SymbolTable::new(),
-            angle_unit: prelude::DEFAULT_ANGLE_UNIT,
-        }
-    }
-}*/
-
 impl ParserContext {
     pub fn new() -> Self {
         ParserContext {