Starting over with types

src/schala_lang/mod.rs

@@ -2,10 +2,11 @@ use itertools::Itertools;
 use schala_lib::{ProgrammingLanguageInterface, EvalOptions, TraceArtifact, ReplOutput};
 
 mod parsing;
-mod type_check;
+//mod type_check;
+mod typechecking;
 mod eval;
 
-use self::type_check::{TypeContext};
+use self::typechecking::{TypeContext};
 
 pub struct Schala {
   state: eval::ReplState,
@@ -61,6 +62,18 @@ impl ProgrammingLanguageInterface for Schala {
       }
     };
 
+    match self.type_context.type_check_ast(&ast) {
+      Ok(ty) => {
+        output.add_artifact(TraceArtifact::new("type_check", format!("{:?}", ty)));
+      },
+      Err(msg) => {
+        output.add_artifact(TraceArtifact::new("type_check", msg));
+        output.add_output(format!("Type error"));
+        return output;
+      }
+    }
+
+    /*
     self.type_context.add_symbols(&ast);
 
     if options.debug_symbol_table {
@@ -78,6 +91,7 @@ impl ProgrammingLanguageInterface for Schala {
         return output;
       }
     }
+    */
 
     let evaluation_outputs = self.state.evaluate(ast);
     let text_output: String = evaluation_outputs.into_iter().intersperse(format!("\n")).collect();

src/schala_lang/typechecking.rs

@@ -0,0 +1,43 @@
+use std::rc::Rc;
+
+use schala_lang::parsing;
+
+pub struct TypeContext { }
+
+#[derive(Debug, PartialEq)]
+pub enum Type {
+  Unit,
+  Void
+}
+
+type TypeResult<T> = Result<T, String>;
+
+impl TypeContext {
+  pub fn new() -> TypeContext {
+    TypeContext { }
+  }
+  pub fn type_check_ast(&mut self, ast: &parsing::AST) -> TypeResult<Type> {
+    use self::Type::*;
+    let mut ret_type = Unit;
+    for statement in ast.0.iter() {
+      ret_type = self.type_check_statement(statement)?;
+    }
+    Ok(ret_type)
+  }
+  fn type_check_statement(&mut self, statement: &parsing::Statement) -> TypeResult<Type> {
+    use self::parsing::Statement::*;
+    match statement {
+      &ExpressionStatement(ref expr) => self.type_check_expression(expr),
+      &Declaration(ref decl) => self.type_check_declaration(decl),
+    }
+  }
+  fn type_check_declaration(&mut self, decl: &parsing::Declaration) -> TypeResult<Type> {
+    use self::Type::*;
+    Ok(Unit)
+  }
+  fn type_check_expression(&mut self, expr: &parsing::Expression) -> TypeResult<Type> {
+    use self::Type::*;
+    Ok(Void)
+  }
+}
+