Revert "Starting to split project into multiple crates"

This reverts commit e3b0f4a51e.
Bah, this was a bad idea, wrong way to do it

Cargo.toml

@@ -22,9 +22,5 @@ rocket_contrib = "*"
 phf = "0.7.12"
 includedir = "0.2.0"
 
-schala-lang = { path = "schala-lang" }
-
 [build-dependencies]
 includedir_codegen = "0.2.0"
-
-[workspace]

src/main.rs

@@ -16,17 +16,13 @@ extern crate rocket_contrib;
 extern crate includedir;
 extern crate phf;
 
-
-extern crate schala_lang;
-
 use std::path::Path;
 use std::fs::File;
 use std::io::{Read, Write};
 use std::process::exit;
 use std::default::Default;
 
-
-mod schala_language;
+mod schala_lang;
 mod maaru_lang;
 mod robo_lang;
 
@@ -370,6 +366,3 @@ fn program_options() -> getopts::Options {
   options
 }
 
-
-
-

src/schala_lang/eval.rs

@@ -1,8 +1,7 @@
+use schala_lang::parsing::{AST, Statement, Declaration, Expression, Variant, ExpressionType, Operation};
 use std::collections::HashMap;
 use std::rc::Rc;
 
-use parsing::{AST, Statement, Declaration, Expression, Variant, ExpressionType, Operation};
-
 pub struct ReplState {
   values: HashMap<Rc<String>, ValueEntry>,
 }

src/schala_lang/mod.rs

@@ -0,0 +1,95 @@
+use itertools::Itertools;
+use language::{ProgrammingLanguageInterface, EvalOptions, TraceArtifact, ReplOutput};
+
+mod parsing;
+mod type_check;
+mod eval;
+
+use self::type_check::{TypeContext};
+
+pub struct Schala {
+  state: eval::ReplState,
+  type_context: TypeContext
+}
+
+impl Schala {
+  pub fn new() -> Schala {
+    Schala {
+      state: eval::ReplState::new(),
+      type_context: TypeContext::new(),
+    }
+  }
+}
+
+impl ProgrammingLanguageInterface for Schala {
+  fn get_language_name(&self) -> String {
+    "Schala".to_string()
+  }
+
+  fn get_source_file_suffix(&self) -> String {
+    format!("schala")
+  }
+
+  fn evaluate_in_repl(&mut self, input: &str, options: &EvalOptions) -> ReplOutput {
+    let mut output = ReplOutput::default();
+    let tokens = parsing::tokenize(input);
+    if options.debug_tokens {
+      let token_string = tokens.iter().map(|t| format!("{:?}<{}>", t.token_type, t.offset)).join(", ");
+      output.add_artifact(TraceArtifact::new("tokens", format!("{:?}", token_string)));
+
+    }
+
+    {
+      let token_errors: Vec<&String> = tokens.iter().filter_map(|t| t.get_error()).collect();
+      if token_errors.len() != 0 {
+        output.add_output(format!("Tokenization error: {:?}\n", token_errors));
+        return output;
+      }
+    }
+
+    let ast = match parsing::parse(tokens) {
+      (Ok(ast), trace) => {
+        if options.debug_parse {
+          output.add_artifact(TraceArtifact::new_parse_trace(trace));
+          output.add_artifact(TraceArtifact::new("ast", format!("{:?}", ast)));
+        }
+        ast
+      },
+      (Err(err), trace) => {
+        output.add_artifact(TraceArtifact::new_parse_trace(trace));
+        output.add_output(format!("Parse error: {:?}\n", err.msg));
+        return output;
+      }
+    };
+
+    self.type_context.add_symbols(&ast);
+
+    if options.debug_symbol_table {
+      let text = self.type_context.debug_symbol_table();
+      output.add_artifact(TraceArtifact::new("symbol_table", text));
+    }
+
+    match self.type_context.type_check(&ast) {
+      Ok(ty) => {
+        output.add_artifact(TraceArtifact::new("type_check", format!("type: {:?}", ty)));
+      },
+      Err(msg) => {
+        output.add_artifact(TraceArtifact::new("type_check", msg));
+        output.add_output(format!("Type error"));
+        return output;
+      }
+    }
+
+    let evaluation_output = self.state.evaluate(ast);
+    let mut acc = String::new();
+    let mut iter = evaluation_output.iter().peekable();
+    while let Some(s) = iter.next() {
+      acc.push_str(&s);
+      if let Some(_) = iter.peek() {
+        acc.push_str("\n");
+      }
+    }
+    output.add_output(acc);
+    return output;
+  }
+}

src/schala_lang/type_check.rs

@@ -1,10 +1,9 @@
 use std::collections::HashMap;
 use std::rc::Rc;
 
-use parsing::{AST, Statement, Declaration, Signature, Expression, ExpressionType, Operation, Variant, TypeName};
-
 //SKOLEMIZATION - how you prevent an unassigned existential type variable from leaking!
 
+use schala_lang::parsing::{AST, Statement, Declaration, Signature, Expression, ExpressionType, Operation, Variant, TypeName};
 
 // from Niko's talk
 /* fn type_check(expression, expected_ty) -> Ty {