greg/schala
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Got typechecker unused errors down to one

Browse Source
This commit is contained in:
greg 2018-11-13 02:39:02 -08:00
parent 7c46a29141
commit 955c073174
1 changed files with 18 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
schala-lang/language/src/typechecking.rs
View File

@ -60,7 +60,7 @@ impl Type<TVar> {
fn skolemize(&self) -> Type<UVar> {
match self {
Type::Var(TVar::Univ(uvar)) => Type::Var(uvar.clone()),
Type::Var(TVar::Exist(evar)) => Type::Var(UVar(Rc::new(format!("sk")))),
Type::Var(TVar::Exist(_)) => Type::Var(UVar(Rc::new(format!("sk")))),
Type::Const(ref c) => Type::Const(c.clone()),
Type::Arrow(a, b) => Type::Arrow(
Box::new(a.skolemize()),
@ -73,7 +73,7 @@ impl Type<TVar> {
impl TypeIdentifier {
fn to_monotype(&self) -> Type<UVar> {
match self {
TypeIdentifier::Tuple(items) => unimplemented!(),
TypeIdentifier::Tuple(_) => Type::Const(TConst::Nat),
TypeIdentifier::Singleton(TypeSingletonName { name, .. }) => {
match &name[..] {
"Nat" => Type::Const(TConst::Nat),
@ -81,7 +81,7 @@ impl TypeIdentifier {
"Float" => Type::Const(TConst::Float),
"Bool" => Type::Const(TConst::Bool),
"String" => Type::Const(TConst::StringT),
_ => unimplemented!()
_ => Type::Const(TConst::Nat),
}
}
}
@ -105,12 +105,6 @@ impl TConst {
}
}
#[derive(Debug, Clone)]
struct PolyType {
vars: Vec<Rc<String>>,
ty: Type<()>
}
impl<'a> TypeContext<'a> {
pub fn new() -> TypeContext<'a> {
TypeContext {
@ -129,11 +123,7 @@ impl<'a> TypeContext<'a> {
impl<'a> TypeContext<'a> {
fn infer_ast(&mut self, ast: &AST) -> InferResult<Type<UVar>> {
let mut output = Type::Const(TConst::Unit);
for statement in ast.0.iter() {
output = self.infer_statement(statement)?;
}
Ok(output)
self.infer_block(&ast.0)
}
fn infer_statement(&mut self, stmt: &Statement) -> InferResult<Type<UVar>> {
@ -154,7 +144,7 @@ impl<'a> TypeContext<'a> {
}
}
fn infer_decl(&mut self, expr: &Declaration) -> InferResult<Type<UVar>> {
fn infer_decl(&mut self, _decl: &Declaration) -> InferResult<Type<UVar>> {
Ok(Type::Const(TConst::user("unimplemented")))
}
@ -186,29 +176,33 @@ impl<'a> TypeContext<'a> {
}
},
Lambda { params, type_anno, body } => {
Lambda { params, .. } => {
let arg_type = unimplemented!();
let result_type = unimplemented!();
let _arg_type = match &params[0] {
(_, Some(type_anno)) => type_anno.to_monotype().to_tvar(),
(_, None) => self.allocate_existential(),
};
//let _result_type = unimplemented!();
return TypeError::new("Unimplemented");
Type::Arrow(Box::new(arg_type), Box::new(result_type))
//Type::Arrow(Box::new(arg_type), Box::new(result_type))
}
_ => Type::Const(TConst::user("unimplemented"))
})
}
fn infer_if_expr(&mut self, discriminator: &Discriminator, body: &IfExpressionBody) -> InferResult<Type<UVar>> {
let test = match discriminator {
let _test = match discriminator {
Discriminator::Simple(expr) => expr,
_ => return TypeError::new("Dame desu")
};
let (then_clause, maybe_else_clause) = match body {
let (_then_clause, _maybe_else_clause) = match body {
IfExpressionBody::SimpleConditional(a, b) => (a, b),
_ => return TypeError::new("Dont work")
};
unimplemented!()
TypeError::new("Not implemented")
}
fn infer_block(&mut self, block: &Block) -> InferResult<Type<UVar>> {
@ -219,8 +213,8 @@ impl<'a> TypeContext<'a> {
Ok(output)
}
fn unify(&mut self, t1: &Type<TVar>, t2: &Type<TVar>) -> InferResult<Type<TVar>> {
unimplemented!()
fn unify(&mut self, _t1: &Type<TVar>, _t2: &Type<TVar>) -> InferResult<Type<TVar>> {
TypeError::new("not implemented")
}
fn allocate_existential(&mut self) -> Type<TVar> {