review_fix.diff

--- code.rs 2017-10-16 10:34:52.866213600 -0600
+++ code_reviewed.rs    2017-10-16 13:46:27.105442600 -0600
@@ -1,5 +1,3 @@
-#![feature(box_syntax)]
-
 use std::fmt;
 use std::str::Chars;
 use std::iter::Peekable;
@@ -40,13 +38,13 @@
         }
     }

-    pub fn err(&mut self) {
+    pub fn err() -> ! {
         panic!("Error parsing input");
     }

     fn read_number(&mut self) -> Token {
         let mut s = String::new();
-        while { let temp = self.input.peek(); temp.is_some() && temp.unwrap().is_digit(10) } {
+        while self.input.peek().map(|t| t.is_digit(10)).unwrap_or(false) {
             let ch = self.input.next().unwrap();
             s.push(ch);
         }
@@ -54,52 +52,52 @@
     }

     fn read_op(&mut self) -> Token {
-        let ch = self.input.next().unwrap();
-        if ch == '+' {
-            Plus(ch)
-        } else {
-            Minus(ch)
+        match self.input.next().unwrap() {
+            c if c == '+' => Plus(c),
+            c => Minus(c)
         }
     }

+    pub fn next(&mut self) -> Token {
+        let read_fn: &Fn(&mut Interpreter<'a>) -> Token;

-    pub fn next(&mut self) ->  Token {
-        let ch = self.input.peek();
-        match ch {
+        match self.input.peek() {
             Some(c) => {
                 self.pos += 1;
+
                 if c.is_digit(10) {
-                    self.read_number()
+                    read_fn = &Interpreter::read_number;
                 } else if *c == '+' || *c == '-' {
-                    self.read_op()
+                    read_fn = &Interpreter::read_op;
                 } else if c.is_whitespace() {
-                    self.next()
+                    read_fn = &Interpreter::next;
                 } else {
-                    self.err();
-                    ERR
+                    Interpreter::err();
                 }
             },
+            None => return EOF
+        };

-            None => EOF
-        }
+        read_fn(self)
     }

     fn eat(&mut self) -> i32 {
-        let tok = self.next();
-        match tok{
+        match self.next() {
             Int(i) => i,
-            _ => { self.err(); 0 }
+            _ => Interpreter::err()
         }
     }

     pub fn expr(&mut self) -> i32 {
-        let mut f: Box<Fn(i32, i32) -> i32> = box |a: i32, b: i32| a + b;
+        let add = |a: i32, b: i32| a + b;
+        let subtract = |a: i32, b: i32| a - b;
+
         let left = self.eat();
-        match self.next() {
-            Plus(_) => f = box |a: i32, b: i32| a + b,
-            Minus(_) => f = box |a: i32, b: i32| a - b,
-            _ => self.err()
-        }
+        let f: &Fn(i32, i32) -> i32 = match self.next() {
+            Plus(_) => &add,
+            Minus(_) => &subtract,
+            _ => Interpreter::err()
+        };
         let right = self.eat();
         f(left, right)
     }