X-Git-Url: https://git.martlubbers.net/?a=blobdiff_plain;f=sem.icl;h=0ffcdd282015af67631b0cd926d3042b01650379;hb=24472f94b2af1d2c01db24c4ddfe61143dda1459;hp=24943fea9eb6623a397af11756045d165ea1d896;hpb=1233630930a7767b46ddc91b83c6463dce84dce0;p=cc1516.git

diff --git a/sem.icl b/sem.icl
index 24943fe..0ffcdd2 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 [] (IntType ->> (ListType 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
@@ -144,12 +130,12 @@ 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->
@@ -161,8 +147,6 @@ 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 ()
@@ -207,9 +191,9 @@ class infer a :: a -> Typing (Substitution, Type)
 
 instance infer Expr where 
  infer e = case e of
-    VarExpr _ (VarDef k fs) = (\t->(zero,t)) <$> lookup k
-    //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) -> 
@@ -242,12 +226,20 @@ instance infer Expr where
         fresh >>= \tv->
         let given = foldr (->>) tv argTs in
         lift (unify expected given) >>= \s2->
-        pure (compose s2 s1, 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
@@ -291,23 +283,35 @@ instance infer Stmt where
         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)->
+        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 = undef //what is this? 
+    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
@@ -317,50 +321,97 @@ instance infer [a] | infer a where
 
 //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) = 
-        infer e >>= \(s, given) ->
-        applySubst s >>| 
+        infer e >>= \(s1, given) ->
+        applySubst s1 >>| 
         case expected of
             Nothing = pure zero
             Just expected_ = lift (unify expected_ given)
-        >>|
-        generalize given >>= \t ->
+        >>= \s2->
+        applySubst s2 >>|
+        let vtype = subst (compose s2 s1) given in
+        generalize vtype >>= \t ->
         changeGamma (extend k t) >>| 
-        pure (VarDecl p (Just given) k e)
+        pure (compose s2 s1, VarDecl p (Just vtype) k e)
 
 instance type FunDecl where
     type (FunDecl p f args expected vds stmts) = 
-        type vds >>= \tVds->
-        infer stmts >>= \(s, given)->
-        applySubst s >>|
+        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))
-        >>|
-        generalize given >>= \t->
+        >>= \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 given) tVds stmts)
+        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 = 
+    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)
@@ -370,98 +421,3 @@ 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)
-
-//// ------------------------
-//// 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