Merge branch 'EnvMonad'

Switch naar monad transformer Either (State)

diff --combined examples/varEx.spl
index c400caf,f987631..2336e05
--- 1/examples/varEx.spl
--- 2/examples/varEx.spl
+++ b/examples/varEx.spl
@@@ -1,10 -1,11 +1,11 @@@
+ Int a = 1 + 1;
+ var b = True;
+ var c = 2 + 2;
  
 -Int f = 4 + True;
+ var d = True;
+ var e = 4;
++//Int f = 4 + True;
  
- Int t = 1 + 1;
- var t = True;
- var x = 2 + 2;
- 
- var x = True;
- var z = 4;
- //Int y = 4 + True;
- 
+ facR(n) :: Int -> Int {
+     return 5;
+ }

diff --combined sem.icl
index 4038c0f,fc8614b..202f2ad
--- 1/sem.icl
--- 2/sem.icl
+++ b/sem.icl
@@@ -9,11 -9,10 +9,12 @@@ import Control.Applicativ
  import Control.Monad
  import Control.Monad.State
  import Control.Monad.Identity
 +import Math.Random
+ import Control.Monad.Trans
  import StdMisc
 -from StdFunc import id, const
 +from StdFunc import id, const, o
  import StdString
 +import StdTuple
  import StdList
  
  from Text import class Text(concat), instance Text String
@@@ -21,71 -20,60 +22,72 @@@
  import AST
  from parse import :: ParserOutput, :: Error
  
 -:: Gamma :== 'Map'.Map String Type
 +:: Gamma :== ('Map'.Map String Type, [String])
- :: Env a :== (State Gamma (Either SemError a))
+ :: Env a :== StateT Gamma (Either SemError) a
  
- get = state $ \s -> (s,s)
+ //we need to redefine this even though it is in Control.Monad.State
+ instance MonadTrans (StateT Gamma) where
+     liftT m = StateT \s-> m >>= \a-> return (a, s)
+ 
+ get = gets id
  
 -instance toString SemError where
 -    toString (ParseError p e) = concat [
 -        toString p,"SemError: ParseError: ", e]
 -    toString (Error e) = "SemError: " +++ e
 -    toString (UnifyErrorStub t1 t2) = toString (UnifyError {line=0,col=0} t1 t2)
 -    toString (UnifyError p t1 t2) = concat [
 -        toString p,
 -        "SemError: Cannot unify types. Expected: ",
 -        toString t1, ". Given: ", toString t2]
 +getRandomStream :: Int -> [String]
 +getRandomStream i = genIdents $ filter (isAlpha o toChar) (genRandInt i)
 +      where
 +              genIdents r = let (ic, r) = splitAt 5 r in [toString ic: genIdents r]
 +
 +freshIdent :: Gamma -> (String, Gamma)
 +freshIdent (st, [ident:rest]) = case 'Map'.get ident st of
 +      Nothing = (ident, (st, rest))
 +      _ = freshIdent (st, rest)
  
  putIdent :: String Type -> Env Void
 -putIdent i t = gets ('Map'.get i) >>= \mt -> case mt of
 -    Nothing = modify ('Map'.put i t)
 -    Just t2 = unify t t2 >>= \t3-> modify ('Map'.put i t3)
 +putIdent i t = gets (\(st, r)->'Map'.get i st) >>= \mt -> case mt of
-     Nothing = pure <$> modify (\(st, r)->('Map'.put i t st, r))
-     Just t2 = unify t t2 >>= \r -> case r of
-         Left e  = pure $ Left e
-         Right t3 = pure <$> modify (\(st, r)->('Map'.put i t3 st, r))
++    Nothing = modify (\(st, r)->('Map'.put i t st, r))
++    Just t2 = unify t t2 >>= \t3-> modify (\(st, r)->('Map'.put i t3 st, r))
 +
 +instance toString SemError where
 +      toString (ParseError p e) = concat [
 +              toString p,"SemError: ParseError: ", e]
 +      toString (Error e) = "SemError: " +++ e
 +      toString (UnifyErrorStub t1 t2) = toString (UnifyError {line=0,col=0} t1 t2)
 +      toString (UnifyError p t1 t2) = concat [
 +              toString p,
 +              "SemError: Cannot unify types. Expected: ",
 +              toString t1, ". Given: ", toString t2]
  
  sem :: AST -> SemOutput
- sem (AST vd fd)
- # (eithervds, gamma) = runState (mapM semVarDecl vd) ('Map'.newMap, getRandomStream 0)
- # (eitherfds, gamma) = runState (mapM semFunDecl fd) gamma
- = case splitEithers eithervds of
-       (Left errs) = Left $ errs ++ [x\\(Left x)<-eitherfds]
-       (Right vds) = case splitEithers eitherfds of
-               (Left errs) = Left errs
-               (Right fds) = Right $ AST vds fds
 -sem (AST vd fd) = case evalStateT m 'Map'.newMap of
++sem (AST vd fd) = case evalStateT m ('Map'.newMap, getRandomStream 0) of
+     Left e = Left [e]
+     Right (vds, fds) = Right (AST vds fds)
+ where 
+     m :: Env (([VarDecl], [FunDecl]))
+     m = (mapM semVarDecl vd) >>= \vds -> 
+         mapM semFunDecl fd >>= \fds -> 
+         pure (vds, fds)
+ 
++
 +
  splitEithers :: [Either a b] -> Either [a] [b]
  splitEithers [] = Right []
  splitEithers [Right x:xs] = splitEithers xs >>= \rest->Right [x:rest]
  splitEithers xs = Left $ [x\\(Left x)<-xs]
  
  semFunDecl :: FunDecl -> Env FunDecl
- semFunDecl f = pure $ Right f
+ semFunDecl f = pure f
  
  semVarDecl :: VarDecl -> Env VarDecl
- semVarDecl vd=:(VarDecl pos type ident ex) = unify type ex
-       >>= \et->case et of
-               Left err = pure $ Left err
-               Right t = putIdent ident t >>| pure (Right $ VarDecl pos t ident ex)
+ semVarDecl (VarDecl pos type ident ex) = unify type ex
+     >>= \t-> putIdent ident t >>| (pure $ VarDecl pos t ident ex)
  
  typeExpr :: Expr -> Env Type
- typeExpr (IntExpr _ _) = pure $ Right IntType
- typeExpr (CharExpr _ _) = pure $ Right CharType
- typeExpr (BoolExpr _ _) = pure $ Right BoolType
+ typeExpr (IntExpr _ _) = pure IntType
+ typeExpr (CharExpr _ _) = pure CharType
+ typeExpr (BoolExpr _ _) = pure BoolType
  typeExpr (Op1Expr p UnNegation expr) = unify BoolType expr
  typeExpr (Op1Expr p UnMinus expr) = unify IntType expr
  typeExpr (TupleExpr p (e1, e2)) = typeExpr e1 
-       >>= \ete1->typeExpr e2 >>= \ete2->pure (
-               ete1 >>= \te1->ete2 >>= \te2->Right $ TupleType (te1, te2))
+     >>= \t1-> typeExpr e2 >>= \t2-> pure $ TupleType (t1, t2)
  //Int
  typeExpr (Op2Expr p e1 BiPlus e2) = unify IntType e1 >>| unify IntType e2
  typeExpr (Op2Expr p e1 BiMinus e2) = unify IntType e1 >>| unify IntType e2
@@@ -107,32 -95,30 +109,31 @@@ typeExpr (Op2Expr p e1 BiOr e2) = unde
  typeExpr (Op2Expr p e1 BiCons e2) = undef
  //typeExpr (FunExpr Pos FunCall) = undef
  //typeExpr (EmptyListExpr Pos) = undef
 -//typeExpr (VarExpr Pos VarDef) = undef //when checking var-expr, be sure to put the infered type
 +//typeExpr (VarExpr Pos VarDef) = undef //when checking var-expr, be sure to
 +//put the infered type
                                          //in the context
  
  class unify a :: Type a -> Env Type
  
  instance unify Expr where
-       unify (_ ->> _) e = pure $ Left $ ParseError (extrPos e)
+       unify (_ ->> _) e = liftT $ Left $ ParseError (extrPos e)
                        "Expression cannot be a higher order function. Yet..."
-       unify VoidType e = pure $ Left $ ParseError (extrPos e)
+       unify VoidType e = liftT $ Left $ ParseError (extrPos e)
                        "Expression cannot be a Void type."
-       unify (IdType _) e = pure $ Left $ ParseError (extrPos e)
+       unify (IdType _) e = liftT $ Left $ ParseError (extrPos e)
                        "Expression cannot be an polymorf type."
      unify VarType e = typeExpr e
-       unify t e = typeExpr e
-               >>= \eithertype->case eithertype of
-                       Left e = pure $ Left e
-                       Right tex = unify t tex >>= \eitherun->case eitherun of
-                               Left err = pure $ Left $ decErr e err
-                               Right t = pure $ Right t
+     //we have to cheat to decorate the error, can be done nicer?
+     unify t e = StateT $ \s0 -> let res = runStateT m s0 in case res of
+         Left err = Left $ decErr e err
+         Right t = Right t //note, t :: (Type, Gamma) 
+     where m = typeExpr e >>= \tex-> unify t tex 
  
  instance unify Type where
-       unify IntType IntType = pure $ Right IntType
-       unify BoolType BoolType = pure $ Right BoolType
-       unify CharType CharType = pure $ Right CharType
-       unify t1 t2 = pure $ Left $ UnifyError zero t1 t2
+       unify IntType IntType = pure IntType
+       unify BoolType BoolType = pure BoolType
+       unify CharType CharType = pure CharType
+       unify t1 t2 = liftT $ Left $ UnifyError zero t1 t2
  
  instance zero Pos where
        zero = {line=0,col=0}
@@@ -142,6 -128,10 +143,10 @@@ decErr e (UnifyError _ t1 t2) = UnifyEr
  decErr e (ParseError _ s) = ParseError (extrPos e) s
  decErr e err = err
  
+ dc2 :: Expr (Either SemError a) -> Either SemError a
+ dc2 e (Right t) = Right t
+ dc2 e (Left err) = Left err
+ 
  extrPos :: Expr -> Pos
  extrPos (VarExpr p _) = p
  extrPos (Op2Expr p _ _ _) = p
@@@ -151,4 -141,4 +156,4 @@@ extrPos (CharExpr p _) = 
  extrPos (BoolExpr p _) = p
  extrPos (FunExpr p _) = p
  extrPos (EmptyListExpr p) = p
 -extrPos (TupleExpr p _) = p
 +extrPos (TupleExpr p _) = p