X-Git-Url: https://git.martlubbers.net/?a=blobdiff_plain;f=sem.icl;h=0c5b55273cb8d7fb05f1fe73dc1fa069409ff49c;hb=978dc486bf8c83cf9cad0925e3128574639656e0;hp=fa4b3ae6cacc2a04762d533fe3330bfb6b314704;hpb=86511734bd44fb9025eb63db027aefb1bb465c10;p=cc1516.git

diff --git a/sem.icl b/sem.icl
index fa4b3ae..0c5b552 100644
--- a/sem.icl
+++ b/sem.icl
@@ -26,9 +26,9 @@ from Text import class Text(concat), instance Text String
 
 import AST
 
-
 :: Scheme = Forall [TVar] Type
 :: Gamma :== 'Map'.Map String Scheme //map from Variables! to types
+:: Typing a :== StateT (Gamma, [TVar]) (Either SemError) a
 :: Substitution :== 'Map'.Map TVar Type
 :: Constraints :== [(Type, Type)]
 :: SemError
@@ -48,34 +48,20 @@ instance zero Gamma where
 variableStream :: [TVar]
 variableStream = map toString [1..]
 
-sem :: AST -> Either [SemError] Constraints
+defaultGamma :: Gamma //includes all default functions
+defaultGamma = extend "print" (Forall ["a"] ((IdType "a") ->> VoidType))
+                $ extend "isEmpty" (Forall ["a"] ((ListType (IdType "a")) ->> BoolType))
+                $ extend "read" (Forall [] CharType)
+                zero
+
+sem :: AST -> Either [SemError] AST
 sem (AST fd) = case foldM (const $ hasNoDups fd) () fd 
-		>>| foldM (const isNiceMain) () fd
-		>>| hasMain fd of
+            		>>| foldM (const isNiceMain) () fd
+            		>>| hasMain fd
+                    >>| evalStateT (type fd) (defaultGamma, variableStream) of
 	Left e = Left [e]
-    _ = Right []
-	//_ = case execRWST (constraints fd) zero variableStream of
-	//	Left e = Left [e]
-	//	Right (a, b) = Right b
+    Right (_,fds) = Right (AST fds)
 where
-		constraints :: [FunDecl] -> Typing ()
-        constraints _ = pure ()
-        //TODO: fix
-		//constraints fds = mapM_ funconstraint fds >>| pure ()
-
-		funconstraint :: FunDecl -> Typing ()
-		funconstraint fd=:(FunDecl _ ident args mt vardecls stmts) = case mt of
-			Nothing = abort "Cannot infer functions yet"
-            _ = pure ()
-			//Just t = inEnv (ident, (Forall [] t)) (
-			//	mapM_ vardeclconstraint vardecls >>| pure ())
-
-		vardeclconstraint :: VarDecl -> Typing ()
-        vardeclconstraint _ = pure ()
-        //TODO: fix!
-		//vardeclconstraint (VarDecl p mt ident expr) = infer expr
-			//>>= \it->inEnv (ident, (Forall [] it)) (pure ())
-
 		hasNoDups :: [FunDecl] FunDecl -> Either SemError ()
 		hasNoDups fds (FunDecl p n _ _ _ _)
 		# mbs = map (\(FunDecl p` n` _ _ _ _)->if (n == n`) (Just p`) Nothing) fds
@@ -128,25 +114,28 @@ instance Typeable Gamma where
     ftv gamma       = concatMap id $ map ftv ('Map'.elems gamma)
     subst s gamma   = Mapmap (subst s) gamma
 
+extend :: String Scheme Gamma -> Gamma
+extend k t g = 'Map'.put k t g
+
 //// ------------------------
 //// algorithm U, Unification 
 //// ------------------------
 instance zero Substitution where zero = 'Map'.newMap
 
 compose :: Substitution Substitution -> Substitution
-compose s1 s2 = 'Map'.union (Mapmap (subst s2) s1) s2
+compose s1 s2 = 'Map'.union (Mapmap (subst s1) s2) s1
 //Note: just like function compositon compose does snd first
 
 occurs :: TVar a -> Bool | Typeable a
 occurs tvar a = elem tvar (ftv a)
 
 unify :: Type Type -> Either SemError Substitution
-unify t1=:(IdType tv) t2 = unify t2 t1
 unify t1 t2=:(IdType tv)    | t1 == (IdType tv) = Right zero
                             | occurs tv t1 = Left $ InfiniteTypeError zero t1
                             | otherwise = Right $ 'Map'.singleton tv t1
+unify t1=:(IdType tv) t2 = unify t2 t1
 unify (ta1->>ta2) (tb1->>tb2) = unify ta1 tb1 >>= \s1->
-                                unify tb1 tb2 >>= \s2->
+                                unify ta2 tb2 >>= \s2->
                                 Right $ compose s1 s2
 unify (TupleType (ta1,ta2)) (TupleType (tb1,tb2)) = unify ta1 tb1 >>= \s1->
                                                     unify ta2 tb2 >>= \s2->
@@ -158,14 +147,12 @@ unify t1 t2 | t1 == t2  = Right zero
 //// ------------------------
 //// Algorithm M, Inference and Solving
 //// ------------------------
-//The typing monad
-:: Typing a :== StateT (Gamma, [TVar]) (Either SemError) a
 gamma :: Typing Gamma
 gamma = gets fst
 putGamma :: Gamma -> Typing ()
 putGamma g = modify (appFst $ const g) >>| pure ()
-changeGamma :: (Gamma -> Gamma) -> Typing ()
-changeGamma f = modify (appFst f) >>| pure ()
+changeGamma :: (Gamma -> Gamma) -> Typing Gamma
+changeGamma f = modify (appFst f) >>| gamma
 withGamma :: (Gamma -> a) -> Typing a
 withGamma f = f <$> gamma
 fresh :: Typing Type
@@ -190,21 +177,23 @@ instantiate (Forall bound t) =
 generalize :: Type -> Typing Scheme
 generalize t = gamma >>= \g-> pure $ Forall (difference (ftv t) (ftv g)) t
 
-lookup :: String -> Typing Scheme 
+lookup :: String -> Typing Type 
 lookup k = gamma >>= \g-> case 'Map'.member k g of
     False = liftT (Left $ UndeclaredVariableError zero k)
-    True = pure ('Map'.find k g)
+    True = instantiate $ 'Map'.find k g
 
 //The inference class
 //When tying it all together we will treat the program is a big 
 //let x=e1 in let y=e2 in .... 
 class infer a :: a -> Typing (Substitution, Type)
 
+////---- Inference for Expressions ----
+
 instance infer Expr where 
  infer e = case e of
-    VarExpr _ (VarDef k fs) = (\t->(zero,t)) <$> (lookup k >>= instantiate)
-    //instantiate is key for the let polymorphism!
-    //TODO: field selectors
+    VarExpr _ (VarDef k fs) = lookup k >>= \t ->
+        foldM foldFieldSelectors t fs >>= \finalT ->
+        pure (zero, finalT)
 
     Op2Expr _ e1 op e2 =
         infer e1 >>= \(s1, t1) -> 
@@ -213,7 +202,7 @@ instance infer Expr where
         let given = t1 ->> t2 ->> tv in 
         op2Type op >>= \expected ->
         lift (unify expected given) >>= \s3 ->
-        pure ((compose s1 $ compose s2 s3), subst s3 tv)
+        pure ((compose s3 $ compose s2 s1), subst s3 tv)
 
     Op1Expr _ op e1 =
         infer e1 >>= \(s1, t1) -> 
@@ -221,28 +210,36 @@ instance infer Expr where
         let given = t1 ->> tv in 
         op1Type op >>= \expected ->
         lift (unify expected given) >>= \s2 ->
-        pure (compose s1 s2, subst s2 tv)
+        pure (compose s2 s1, subst s2 tv)
 
     EmptyListExpr _ = (\tv->(zero,tv)) <$> fresh
 
     TupleExpr _ (e1, e2) = 
         infer e1 >>= \(s1, t1) -> 
         infer e2 >>= \(s2, t2) ->
-        pure (compose s1 s2, TupleType (t1,t2))
+        pure (compose s2 s1, TupleType (t1,t2))
 
     FunExpr _ f args fs = //todo: fieldselectors
-        lookup f >>= instantiate >>= \expected ->
-        let accTypSub = (\(s,ts) e->infer e >>= \(s_,et)->pure (compose s_ s,ts++[et])) in
-        foldM accTypSub (zero,[]) args >>= \(s1, argTs)->
+        lookup f >>= \expected ->
+        let accST = (\(s,ts) e->infer e >>= \(s_,et)->pure (compose s_ s,ts++[et])) in
+        foldM accST (zero,[]) args >>= \(s1, argTs)->
         fresh >>= \tv->
         let given = foldr (->>) tv argTs in
         lift (unify expected given) >>= \s2->
-        pure (compose s1 s2, subst s2 tv)
+        let fReturnType = subst s2 tv in
+        foldM foldFieldSelectors fReturnType fs >>= \returnType ->
+        pure (compose s2 s1, returnType)
 
     IntExpr _ _ = pure $ (zero, IntType)
     BoolExpr _ _ = pure $ (zero, BoolType)
     CharExpr _ _ = pure $ (zero, CharType)
 
+foldFieldSelectors :: Type FieldSelector -> Typing Type 
+foldFieldSelectors (ListType t) (FieldHd) = pure t
+foldFieldSelectors t=:(ListType _) (FieldTl) = pure t 
+foldFieldSelectors (TupleType (t1, _)) (FieldFst) = pure t1
+foldFieldSelectors (TupleType (_, t2)) (FieldSnd) = pure t2
+foldFieldSelectors t fs = liftT $ Left $ FieldSelectorError zero t fs
 
 op2Type :: Op2 -> Typing Type
 op2Type op
@@ -261,120 +258,166 @@ op1Type :: Op1 -> Typing Type
 op1Type UnNegation = pure $ (BoolType ->> BoolType)
 op1Type UnMinus = pure $ (IntType ->> IntType)
 
-
-Mapmap :: (a->b) ('Map'.Map k a) -> ('Map'.Map k b)
-Mapmap _ 'Map'.Tip = 'Map'.Tip
-Mapmap f ('Map'.Bin sz k v ml mr) = 'Map'.Bin sz k (f v) 
-                                        (Mapmap f ml) 
-                                        (Mapmap f mr)
+////----- Inference for Statements -----
+applySubst :: Substitution -> Typing Gamma
+applySubst s = changeGamma (subst s)
+
+instance infer Stmt where
+ infer s = case s of
+    IfStmt e th el = 
+        infer e >>= \(s1, et)->
+        lift (unify et BoolType) >>= \s2 ->
+        applySubst (compose s2 s1) >>|        
+        infer th >>= \(s3, tht)->
+        applySubst s3 >>|
+        infer el >>= \(s4, elt)->
+        applySubst s4 >>|
+        lift (unify tht elt) >>= \s5-> 
+        pure (compose s5 $ compose s4 $ compose s3 $ compose s2 s1, subst s5 tht)
+
+    WhileStmt e wh = 
+        infer e >>= \(s1, et)->
+        lift (unify et BoolType) >>= \s2 ->
+        applySubst (compose s2 s1) >>|
+        infer wh >>= \(s3, wht)->
+        pure (compose s3 $ compose s2 s1, subst s3 wht)
+
+    AssStmt (VarDef k fs) e =
+        lookup k >>= \expected ->
+        infer e >>= \(s1, given)->
+        foldM reverseFs given (reverse fs) >>= \varType->
+        lift (unify expected varType) >>= \s2->
+        let s = compose s2 s1 in
+        applySubst s >>|
+        changeGamma (extend k (Forall [] (subst s varType))) >>| 
+        pure (s, VoidType)
+
+    FunStmt f es _ = pure (zero, VoidType) 
+
+    ReturnStmt Nothing = pure (zero, VoidType)
+    ReturnStmt (Just e) = infer e
+
+reverseFs :: Type FieldSelector -> Typing Type 
+reverseFs t FieldHd = pure $ ListType t
+reverseFs t FieldTl = pure $ ListType t 
+reverseFs t FieldFst = fresh >>= \tv -> pure $ TupleType (t, tv)
+reverseFs t FieldSnd = fresh >>= \tv -> pure $ TupleType (tv, t)
+
+//The type of a list of statements is either an encountered
+//return, or VoidType
+instance infer [a] | infer a where
+    infer []        = pure (zero, VoidType)
+    infer [stmt:ss] = 
+        infer stmt >>= \(s1, t1) ->
+        applySubst s1 >>|
+        infer ss >>= \(s2, t2) ->
+        applySubst s2 >>|
+        case t1 of
+            VoidType = pure (compose s2 s1, t2)
+            _ = case t2 of
+                VoidType = pure (compose s2 s1, t1)
+                _ = lift (unify t1 t2) >>= \s3 -> 
+                    pure (compose s3 $ compose s2 s1, t1)
+
+//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 (Substitution, a)
+
+instance type VarDecl where
+    type (VarDecl p expected k e) = 
+        infer e >>= \(s1, given) ->
+        applySubst s1 >>| 
+        case expected of
+            Nothing = pure zero
+            Just expected_ = lift (unify expected_ given)
+        >>= \s2->
+        applySubst s2 >>|
+        let vtype = subst (compose s2 s1) given in
+        generalize vtype >>= \t ->
+        changeGamma (extend k t) >>| 
+        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 >>= \(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))
+        >>= \s3 ->
+        let ftype = subst (compose s3 $ compose s2 s1) given in
+        generalize ftype >>= \t->
+        putGamma outerScope >>|
+        changeGamma (extend f t) >>| 
+        pure (compose s3 $ compose s2 s1, FunDecl p f args (Just ftype) tVds stmts)
+
+instance type [a] | type a where
+    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 = 
+    fresh >>= \tv ->
+    changeGamma (extend k (Forall [] tv)) >>|
+    pure tv
 
 instance toString Scheme where
     toString (Forall x t) = 
-        concat ["Forall ": map ((+++) "\n") x] +++ toString t
+        concat ["Forall ": intersperse "," x] +++ concat [". ", toString t];
 
 instance toString Gamma where
     toString mp = 
         concat [concat [k, ": ", toString v, "\n"]\\(k, v)<-'Map'.toList mp]
 
+instance toString Substitution where
+    toString subs = 
+        concat [concat [k, ": ", toString t, "\n"]\\(k, t)<-'Map'.toList subs]
+
 instance toString SemError where
     toString (SanityError p e) = concat [toString p, 
         "SemError: SanityError: ", e]
-    toString se = "SemError: "
+    toString (ParseError p s) = concat [toString p, 
+        "ParseError: ", s]
+    toString (UnifyError p t1 t2) = concat [toString p, 
+        "Can not unify types, expected|given:\n", toString t1,
+        "\n", toString t2]
+    toString (InfiniteTypeError p t) = concat [toString p, 
+        "Infinite type: ", toString t]
+    toString (FieldSelectorError p t fs) = concat [toString p,
+        "Can not run fieldselector '", toString fs, "' on type: ",
+        toString t]
+    toString (OperatorError p op t) = concat [toString p,
+        "Operator error, operator '", toString op, "' can not be",
+        "used on type: ", toString t]
+    toString (UndeclaredVariableError p k) = concat [toString p,
+        "Undeclared identifier: ", k]
+    toString (ArgumentMisMatchError p str) = concat [toString p,
+        "Argument mismatch: ", str]
+    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)
 
-//// ------------------------
-//// First step: Inference
-//// ------------------------//
-
-//unify :: Type Type -> Infer ()
-//unify t1 t2 = tell [(t1, t2)]//
-
-//fresh :: Infer Type
-//fresh = (gets id) >>= \vars-> (put $ tail vars) >>| (pure $ IdType $ head vars)//
-
-//op2Type :: Op2 -> Infer Type
-//op2Type op
-//| elem op [BiPlus, BiMinus, BiTimes, BiDivide, BiMod]
-//	= pure (IntType ->> IntType ->> IntType)
-//| elem op [BiEquals, BiUnEqual]
-//	= fresh >>= \t1-> fresh >>= \t2-> pure (t1 ->> t2 ->> BoolType)
-//| elem op [BiLesser, BiGreater, BiLesserEq, BiGreaterEq]
-//	= pure (IntType ->> IntType ->> BoolType)
-//| elem op [BiAnd, BiOr]
-//	= pure (BoolType ->> BoolType ->> BoolType)
-//| op == BiCons 
-//	= fresh >>= \t1-> pure (t1 ->> ListType t1 ->> ListType t1)//
-
-//op1Type :: Op1 -> Infer Type
-//op1Type UnNegation = pure $ (BoolType ->> BoolType)
-//op1Type UnMinus = pure $ (IntType ->> IntType)//
-
-////instantiate :: Scheme -> Infer Type
-////instantiate (Forall as t) = mapM (const fresh) as//
-
-//lookupEnv :: String -> Infer Type
-//lookupEnv ident = asks ('Map'.get ident)
-//	>>= \m->case m of
-//		Nothing = liftT $ Left $ UndeclaredVariableError zero ident
-//		Just (Forall as t) = pure t //instantiate ???//
-
-//class infer a :: a -> Infer Type
-//instance infer Expr where
-//	infer (VarExpr _ (VarDef ident fs)) = lookupEnv ident
-//    infer (Op2Expr _ e1 op e2) = 
-//        infer e1 >>= \t1 -> 
-//        infer e2 >>= \t2 ->
-//        fresh >>= \frsh -> 
-//        let given = t1 ->> (t2 ->> frsh) in
-//        op2Type op >>= \expected -> 
-//        unify expected given >>| 
-//        return frsh
-//	infer (Op1Expr _ op e) = 
-//        infer e >>= \t1 -> 
-//        fresh >>= \frsh -> 
-//        let given = t1 ->> frsh in
-//        op1Type op >>= \expected -> 
-//        unify expected given >>| 
-//        pure frsh
-//	infer (IntExpr _ _) = pure IntType
-//	infer (CharExpr _ _) = pure CharType
-//	infer (BoolExpr _ _) = pure BoolType
-//	infer (FunExpr _ f args sels) =  //todo, iets met field selectors
-//        lookupEnv f >>= \expected ->
-//        fresh >>= \frsh -> 
-//        mapM infer args >>= \argTypes ->
-//        let given = foldr (->>) frsh argTypes in
-//        unify expected given >>|
-//        pure frsh
-//	infer (EmptyListExpr _) = ListType <$> fresh
-//	infer (TupleExpr _ (e1, e2)) =
-//		infer e1 >>= \et1->infer e2 >>= \et2->pure $ TupleType (et1, et2)//
-
-////:: VarDef = VarDef String [FieldSelector]
-////:: FieldSelector = FieldHd | FieldTl | FieldFst | FieldSnd
-////:: Op1 = UnNegation | UnMinus
-////:: Op2 = BiPlus | BiMinus | BiTimes | BiDivide | BiMod | BiEquals | BiLesser |
-////	BiGreater | BiLesserEq | BiGreaterEq | BiUnEqual | BiAnd | BiOr | BiCons
-////:: FunDecl = FunDecl Pos String [String] (Maybe Type) [VarDecl] [Stmt]
-////:: FunCall = FunCall String [Expr]
-////:: Stmt 
-////	= IfStmt Expr [Stmt] [Stmt]
-////	| WhileStmt Expr [Stmt]
-////	| AssStmt VarDef Expr
-////	| FunStmt FunCall
-////	| ReturnStmt (Maybe Expr)
-////:: Pos = {line :: Int, col :: Int}
-////:: AST = AST [VarDecl] [FunDecl]
-////:: VarDecl = VarDecl Pos Type String Expr
-////:: Type 
-////	= TupleType (Type, Type)
-////	| ListType Type
-////	| IdType String 
-////	| IntType 
-////	| BoolType
-////	| CharType
-////	| VarType
-////    | VoidType
-////    | (->>) infixl 7 Type Type
+Mapmap :: (a->b) ('Map'.Map k a) -> ('Map'.Map k b)
+Mapmap _ 'Map'.Tip = 'Map'.Tip
+Mapmap f ('Map'.Bin sz k v ml mr) = 'Map'.Bin sz k (f v) 
+                                        (Mapmap f ml) 
+                                        (Mapmap f mr)