diff --git a/schala-lang/src/eval.rs b/schala-lang/src/eval.rs
index d6f2b00..bef1051 100644
--- a/schala-lang/src/eval.rs
+++ b/schala-lang/src/eval.rs
@@ -44,246 +44,6 @@ enum ValueEntry {
 
 type EvalResult<T> = Result<T, String>;
 
-
-/*
-#[derive(Debug, PartialEq, Clone)]
-enum FullyEvaluatedExpr {
-  UnsignedInt(u64),
-  SignedInt(i64),
-  Float(f64),
-  Str(String),
-  Bool(bool),
-  FuncLit(Rc<String>),
-  Custom {
-    string_rep: Rc<String>,
-  },
-  Tuple(Vec<FullyEvaluatedExpr>),
-  List(Vec<FullyEvaluatedExpr>)
-}
-
-impl FullyEvaluatedExpr {
-  fn to_string(&self) -> String {
-    use self::FullyEvaluatedExpr::*;
-    match self {
-      &UnsignedInt(ref n) => format!("{}", n),
-      &SignedInt(ref n) => format!("{}", n),
-      &Float(ref f) => format!("{}", f),
-      &Str(ref s) => format!("\"{}\"", s),
-      &Bool(ref b) => format!("{}", b),
-      &Custom { ref string_rep } => format!("{}", string_rep),
-      &Tuple(ref items) => {
-        let mut buf = String::new();
-        write!(buf, "(").unwrap();
-        for term in items.iter().map(|e| Some(e)).intersperse(None) {
-          match term {
-            Some(e) => write!(buf, "{}", e.to_string()).unwrap(),
-            None => write!(buf, ", ").unwrap(),
-          };
-        }
-        write!(buf, ")").unwrap();
-        buf
-      },
-      &FuncLit(ref name) => format!("<function {}>", name),
-      &List(ref items) => {
-        let mut buf = String::new();
-        write!(buf, "[").unwrap();
-        for term in items.iter().map(|e| Some(e)).intersperse(None) {
-          match term {
-            Some(e) => write!(buf, "{}", e.to_string()).unwrap(),
-            None => write!(buf, ", ").unwrap()
-          }
-        }
-        write!(buf, "]").unwrap();
-        buf
-      }
-    }
-  }
-}
-*/
-
-  /*
-
-  pub fn new_with_parent(parent: &'a State<'a>) -> State<'a> {
-    State { parent_frame: Some(parent), values: HashMap::new() }
-  }
-
-  pub fn evaluate(&mut self, ast: AST) -> Vec<Result<String, String>> {
-    let mut acc = vec![];
-    for statement in ast.0 {
-      match self.eval_statement(statement) {
-        Ok(output) => {
-          if let Some(fully_evaluated) = output {
-            acc.push(Ok(fully_evaluated.to_string()));
-          }
-        },
-        Err(error) => {
-          acc.push(Err(format!("Eval error: {}", error)));
-          return acc;
-        },
-      }
-    }
-    acc
-  }
-}
-
-impl<'a> State<'a> {
-  fn eval_statement(&mut self, statement: Statement) -> EvalResult<Option<FullyEvaluatedExpr>> {
-    Ok(match statement {
-      Statement::ExpressionStatement(expr) => Some(self.eval_expr(expr)?),
-      Statement::Declaration(decl) => { self.eval_decl(decl)?; None }
-    })
-  }
-
-  fn eval_decl(&mut self, decl: Declaration) -> EvalResult<()> {
-    use self::Declaration::*;
-    use self::Variant::*;
-
-    match decl {
-      FuncDecl(signature, statements) => {
-        let name = signature.name;
-        let param_names: Vec<Rc<String>> = signature.params.iter().map(|fp| fp.0.clone()).collect();
-        self.insert(name, ValueEntry::Function { body: statements.clone(), param_names });
-      },
-      TypeDecl(_name, body) => {
-        for variant in body.0.iter() {
-          match variant {
-            &UnitStruct(ref name) => self.insert(name.clone(),
-              ValueEntry::Binding { val: FullyEvaluatedExpr::Custom { string_rep: name.clone() } }),
-            &TupleStruct(ref _name, ref _args) =>  unimplemented!(),
-            &Record(ref _name, ref _fields) => unimplemented!(),
-          };
-        }
-      },
-      Binding { name, expr, ..} => {
-        let val = self.eval_expr(expr)?;
-        self.insert(name.clone(), ValueEntry::Binding { val });
-      },
-      _ => return Err(format!("Declaration evaluation not yet implemented"))
-    }
-    Ok(())
-  }
-
-  fn eval_expr(&mut self, expr: Expression) -> EvalResult<FullyEvaluatedExpr> {
-    use self::ExpressionType::*;
-    use self::FullyEvaluatedExpr::*;
-
-    let expr_type = expr.0;
-    match expr_type {
-      IntLiteral(n) => Ok(UnsignedInt(n)),
-      FloatLiteral(f) => Ok(Float(f)),
-      StringLiteral(s) => Ok(Str(s.to_string())),
-      BoolLiteral(b) => Ok(Bool(b)),
-      PrefixExp(op, expr) => self.eval_prefix_exp(op, expr),
-      BinExp(op, lhs, rhs) => self.eval_binexp(op, lhs, rhs),
-      Value(name) => self.eval_value(name),
-      TupleLiteral(expressions) => {
-        let mut evals = Vec::new();
-        for expr in expressions {
-          match self.eval_expr(expr) {
-            Ok(fully_evaluated) => evals.push(fully_evaluated),
-            error => return error,
-          }
-        }
-        Ok(Tuple(evals))
-      }
-      Call { f, arguments } => {
-        let mut evaled_arguments = Vec::new();
-        for arg in arguments.into_iter() {
-          evaled_arguments.push(self.eval_expr(arg)?);
-        }
-        self.eval_application(*f, evaled_arguments)
-      },
-      Index { box indexee, indexers } => {
-        let evaled = self.eval_expr(indexee)?;
-        match evaled {
-          Tuple(mut exprs) => {
-            let len = indexers.len();
-            if len == 1 {
-              let idx = indexers.into_iter().nth(0).unwrap();
-              match self.eval_expr(idx)? {
-                UnsignedInt(n) if (n as usize) < exprs.len() => Ok(exprs.drain(n as usize..).next().unwrap()),
-                UnsignedInt(n) => Err(format!("Index {} out of range", n)),
-                other => Err(format!("{:?} is not an unsigned integer", other)),
-              }
-            } else {
-              Err(format!("Tuple index must be one integer"))
-            }
-          },
-          _ => Err(format!("Bad index expression"))
-        }
-      },
-      ListLiteral(items) => Ok(List(items.into_iter().map(|item| self.eval_expr(item)).collect::<Result<Vec<_>,_>>()?)),
-      x => Err(format!("Unimplemented thing {:?}", x)),
-    }
-  }
-
-  fn eval_application(&mut self, f: Expression, arguments: Vec<FullyEvaluatedExpr>) -> EvalResult<FullyEvaluatedExpr> {
-    use self::ExpressionType::*;
-    match f {
-      Expression(Value(ref identifier), _) if self.is_builtin(identifier) =>  self.eval_builtin(identifier, arguments),
-      Expression(Value(identifier), _) => {
-        match self.lookup(&identifier) {
-          Some(&ValueEntry::Function { ref body, ref param_names }) => {
-            if arguments.len() != param_names.len() {
-              return Err(format!("Wrong number of arguments for the function"));
-            }
-            let mut new_state = State::new_with_parent(self);
-            let sub_ast = body.clone();
-            for (param, val) in param_names.iter().zip(arguments.into_iter()) {
-              new_state.insert(param.clone(), ValueEntry::Binding { val });
-            }
-            let mut ret: Option<FullyEvaluatedExpr> = None;
-            for statement in sub_ast.into_iter() {
-              ret = new_state.eval_statement(statement)?;
-            }
-            Ok(ret.unwrap_or(FullyEvaluatedExpr::Custom { string_rep: Rc::new("()".to_string()) }))
-          },
-          _ => Err(format!("Function {} not found", identifier)),
-        }
-      },
-      x => Err(format!("Trying to apply {:?} which is not a function", x)),
-    }
-  }
-  fn is_builtin(&self, name: &Rc<String>) -> bool {
-    match &name.as_ref()[..] {
-      "print" | "println" => true,
-      _ => false
-    }
-  }
-  fn eval_builtin(&mut self, name: &Rc<String>, args: Vec<FullyEvaluatedExpr>) -> EvalResult<FullyEvaluatedExpr> {
-    use self::FullyEvaluatedExpr::*;
-    match &name.as_ref()[..] {
-      "print" => {
-        for arg in args {
-          print!("{}", arg.to_string());
-        }
-        Ok(Tuple(vec![]))
-      },
-      "println" => {
-        for arg in args {
-          println!("{}", arg.to_string());
-        }
-        Ok(Tuple(vec![]))
-      },
-      _ => unreachable!()
-    }
-  }
-  fn eval_value(&mut self, name: Rc<String>) -> EvalResult<FullyEvaluatedExpr> {
-    use self::ValueEntry::*;
-    match self.lookup(&name) {
-      None => return Err(format!("Value {} not found", *name)),
-      Some(lookup) => match lookup {
-        &Binding { ref val } => Ok(val.clone()),
-        &Function { .. } =>  Ok(FullyEvaluatedExpr::FuncLit(name.clone()))
-      }
-    }
-  }
-
-}
-*/
-
-/* BELOW HERE NEW STUFF */
-
 impl Expr {
   fn to_repl(&self) -> String {
     use self::Lit::*;