import AST
-
:: Scheme = Forall [TVar] Type
:: Gamma :== 'Map'.Map String Scheme //map from Variables! to types
:: Typing a :== StateT (Gamma, [TVar]) (Either SemError) a
>>| hasMain fd
>>| evalStateT (type fd) (zero, variableStream) of
Left e = Left [e]
- Right fds = Right (AST fds)
+ Right (_,fds) = Right (AST fds)
where
hasNoDups :: [FunDecl] FunDecl -> Either SemError ()
hasNoDups fds (FunDecl p n _ _ _ _)
generalize t = gamma >>= \g-> pure $ Forall (difference (ftv t) (ftv g)) t
lookup :: String -> Typing Type
+lookup "isEmpty" = ListType <$> fresh
lookup k = gamma >>= \g-> case 'Map'.member k g of
False = liftT (Left $ UndeclaredVariableError zero k)
True = instantiate $ 'Map'.find k g
pure (compose s3 $ compose s2 s1, subst s3 wht)
AssStmt (VarDef k fs) e =
- infer e >>= \(s1, et)->
- applySubst s1 >>|
- changeGamma (extend k (Forall [] et)) >>| //todo: fieldselectors
- pure (s1, VoidType)
+ lookup k >>= \expected ->
+ infer e >>= \(s1, given)->
+ lift (unify expected given) >>= \s2->
+ let s = compose s2 s1 in
+ applySubst s >>|
+ changeGamma (extend k (Forall [] given)) >>| //todo: fieldselectors
+ pure (s, VoidType)
FunStmt f es = undef //what is this?
//the type class inferes the type of an AST element (VarDecl or FunDecl)
//and adds it to the AST element
-class type a :: a -> Typing a
+class type a :: a -> Typing (Substitution, a)
instance type VarDecl where
type (VarDecl p expected k e) =
let vtype = subst (compose s2 s1) given in
generalize vtype >>= \t ->
changeGamma (extend k t) >>|
- pure (VarDecl p (Just vtype) k e)
+ pure (compose s2 s1, VarDecl p (Just vtype) k e)
instance type FunDecl where
type (FunDecl p f args expected vds stmts) =
+ gamma >>= \outerScope-> //functions are infered in their own scopde
introduce f >>|
mapM introduce args >>= \argTs->
- type vds >>= \tVds->
- infer stmts >>= \(s1, result)->
- let given = foldr (->>) result argTs in
+ type vds >>= \(s1, tVds)->
applySubst s1 >>|
+ infer stmts >>= \(s2, result)->
+ applySubst s1 >>|
+ let argTs_ = map (subst $ compose s2 s1) argTs in
+ //abort (concat $ intersperse "\n" $ map toString argTs_) >>|
+ let given = foldr (->>) result argTs_ in
(case expected of
Nothing = pure zero
Just expected_ = lift (unify expected_ given))
- >>= \s2 ->
- let ftype = subst (compose s2 s1) given in
+ >>= \s3 ->
+ let ftype = subst (compose s3 $ compose s2 s1) given in
generalize ftype >>= \t->
+ putGamma outerScope >>|
changeGamma (extend f t) >>|
- pure (FunDecl p f args (Just ftype) tVds stmts)
-
-instance toString (Maybe a) | toString a where
- toString Nothing = "Nothing"
- toString (Just e) = concat ["Just ", toString e]
+ pure (compose s3 $ compose s2 s1, FunDecl p f args (Just ftype) tVds stmts)
instance type [a] | type a where
- type dcls = mapM type dcls
+ type [] = pure (zero, [])
+ type [v:vs] =
+ type v >>= \(s1, v_)->
+ applySubst s1 >>|
+ type vs >>= \(s2, vs_)->
+ applySubst (compose s2 s1) >>|
+ pure (compose s2 s1, [v_:vs_])
introduce :: String -> Typing Type
introduce k =
toString (Error e) = concat ["Unknown error during semantical",
"analysis: ", e]
+instance toString (Maybe a) | toString a where
+ toString Nothing = "Nothing"
+ toString (Just e) = concat ["Just ", toString e]
+
instance MonadTrans (StateT (Gamma, [TVar])) where
liftT m = StateT \s-> m >>= \a-> return (a, s)