122 lines
2.5 KiB
Rust
122 lines
2.5 KiB
Rust
use std::rc::Rc;
|
|
|
|
use crate::ast::*;
|
|
use crate::util::ScopeStack;
|
|
|
|
pub type TypeName = Rc<String>;
|
|
|
|
pub struct TypeContext<'a> {
|
|
variable_map: ScopeStack<'a, Rc<String>, ()>,
|
|
evar_count: u32
|
|
}
|
|
|
|
/// `InferResult` is the monad in which type inference takes place.
|
|
type InferResult<T> = Result<T, TypeError>;
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct TypeError { msg: String }
|
|
|
|
impl TypeError {
|
|
fn new<A>(msg: &str) -> InferResult<A> {
|
|
Err(TypeError { msg: msg.to_string() })
|
|
}
|
|
}
|
|
|
|
/*
|
|
/// `Type` is parameterized by whether the type variables can be just universal, or universal or
|
|
/// existential.
|
|
#[derive(Debug, Clone)]
|
|
enum Type<A> {
|
|
Var(A),
|
|
Const(TConst),
|
|
Arrow(Box<Type<A>>, Box<Type<A>>),
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
enum TVar {
|
|
Univ(UVar),
|
|
Exist(ExistentialVar)
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct UVar(Rc<String>);
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct ExistentialVar(u32);
|
|
|
|
impl Type<UVar> {
|
|
fn to_tvar(&self) -> Type<TVar> {
|
|
match self {
|
|
Type::Var(UVar(name)) => Type::Var(TVar::Univ(UVar(name.clone()))),
|
|
Type::Const(ref c) => Type::Const(c.clone()),
|
|
Type::Arrow(a, b) => Type::Arrow(
|
|
Box::new(a.to_tvar()),
|
|
Box::new(b.to_tvar())
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Type<TVar> {
|
|
fn skolemize(&self) -> Type<UVar> {
|
|
match self {
|
|
Type::Var(TVar::Univ(uvar)) => Type::Var(uvar.clone()),
|
|
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()),
|
|
Box::new(b.skolemize())
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TypeIdentifier {
|
|
fn to_monotype(&self) -> Type<UVar> {
|
|
match self {
|
|
TypeIdentifier::Tuple(_) => Type::Const(TConst::Nat),
|
|
TypeIdentifier::Singleton(TypeSingletonName { name, .. }) => {
|
|
match &name[..] {
|
|
"Nat" => Type::Const(TConst::Nat),
|
|
"Int" => Type::Const(TConst::Int),
|
|
"Float" => Type::Const(TConst::Float),
|
|
"Bool" => Type::Const(TConst::Bool),
|
|
"String" => Type::Const(TConst::StringT),
|
|
_ => Type::Const(TConst::Nat),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
enum TConst {
|
|
User(Rc<String>),
|
|
Unit,
|
|
Nat,
|
|
Int,
|
|
Float,
|
|
StringT,
|
|
Bool,
|
|
}
|
|
|
|
impl TConst {
|
|
fn user(name: &str) -> TConst {
|
|
TConst::User(Rc::new(name.to_string()))
|
|
}
|
|
}
|
|
*/
|
|
|
|
impl<'a> TypeContext<'a> {
|
|
pub fn new() -> TypeContext<'a> {
|
|
TypeContext {
|
|
variable_map: ScopeStack::new(None),
|
|
evar_count: 0
|
|
}
|
|
}
|
|
|
|
pub fn typecheck(&mut self, ast: &AST) -> Result<String, String> {
|
|
Ok(format!("UNIT"))
|
|
}
|
|
}
|