schala/schala-lang/language/src/typechecking.rs

use std::rc::Rc;

use ast::*;

pub type TypeName = Rc<String>;

pub struct TypeContext {

}

type TypeResult<T> = Result<T, TypeError>;

#[derive(Debug, Clone)]
struct TypeError { }

enum MonoType {
  Var(Rc<String>),
  Const(Rc<String>),
  Arrow(Rc<String>)
}

struct PolyType {
  vars: Vec<Rc<String>>,
  ty: MonoType
}

impl TypeContext {
  pub fn new() -> TypeContext {
    TypeContext { }
  }

  pub fn typecheck(&mut self, ast: &AST) -> Result<(), String> {
    match self.infer_ast(ast) {
      Ok(_) => Ok(()),
      Err(err) => Err(format!("Type error: {:?}", err))
    }
  }
}

impl TypeContext {
  fn infer_ast(&mut self, ast: &AST) -> TypeResult<MonoType> {
    let mut output = MonoType::Const(Rc::new("Unit".to_string()));
    for statement in ast.0.iter() {
      match statement {
        Statement::ExpressionStatement(ref expr) => self.infer_expr(expr)?,
        Statement::Declaration(ref decl) => self.infer_decl(decl)?,
      };
    }
    Ok(output)
  }

  fn infer_expr(&mut self, expr: &Expression) -> TypeResult<MonoType> {
    match expr {
      Expression(expr_type, Some(type_anno)) => unimplemented!(),
      Expression(expr_type, None) => self.infer_expr_type(expr_type)
    }
  }

  fn infer_decl(&mut self, expr: &Declaration) -> TypeResult<MonoType> {
    unimplemented!()
  }

  fn infer_expr_type(&mut self, expr_type: &ExpressionType) -> TypeResult<MonoType> {
    use self::ExpressionType::*;
    match expr_type {
      NatLiteral(_) => Ok(MonoType::Const(Rc::new("Nat".to_string()))),
      _ => unimplemented!()
    }
  }
}

#[cfg(test)]
mod tests {
  use super::*;
  #[test]
  fn basic_inference() {

  }
}