[Switch Data.FiniteMap to Data.Map and get rid of FrontEnd.Env
John Meacham <john@repetae.net>**20050422105027] hunk ./FrontEnd/Env.hs 1
-{------------------------------------------------------------------------------
-
-        Copyright:              The Hatchet Team (see file Contributors)
-
-        Module:                 Env
-
-        Description:            A generic environment that supports mappings 
-                                from names to values.
-
-        Primary Authors:        Bernie Pope
-
-        Notes:                  See the file License for license information
-                                
-                                Based on FiniteMaps
-
--------------------------------------------------------------------------------}
-
-module FrontEnd.Env (Env, 
-            emptyEnv, 
-            unitEnv, 
-            lookupEnv,
-            addToEnv,
-            joinEnv, 
-            joinListEnvs, 
-            listToEnv,
-            envToList,
-            getNamesFromEnv,
-            showEnv,
-            pprintEnv,
-            addToCombFM,
-            mapEnv,
-            zeroFM,
-            joinFM,lookupDftFM,
-            toListFM,
-            -- use these plus monoid routines when possible
-            fromList,
-            single,
-            FrontEnd.Env.find,
-            toList
-           ) where
-
-
-import Data.FiniteMap 
-import HsSyn   
-import PPrint  
-import Utils
-import Char
-import List
-import Data.Monoid
-
-
---------------------------------------------------------------------------------
-
-{-# INLINE joinFM #-}
-{-# INLINE emptyEnv #-}
-{-# INLINE zeroFM #-}
-{-# INLINE addToCombFM #-}
-{-# INLINE lookupDftFM #-}
-zeroFM = emptyFM
-joinFM x y = plusFM y x
-toListFM  = fmToList
-addToCombFM c k v m = addToFM_C (flip c) m k v 
-lookupDftFM x = lookupWithDefaultFM x
---addToFM x y = Data.FiniteMap.addToFM y x
-
---instance (Show a, Show b) => Show (FiniteMap a b) where
---    show fm = show (fmToList fm)
-
-type Env a = FiniteMap HsName a 
-
-instance Ord a => Monoid (FiniteMap a b) where
-    mempty = emptyFM
-    mappend = plusFM
-
-
-emptyEnv :: Env a
-emptyEnv = zeroFM
-
-
-single k v = unitFM k v
-
-unitEnv :: (HsName, a) -> Env a 
-unitEnv (name, val) = unitFM name val
-
-lookupEnv :: HsName -> Env a -> Maybe a 
-lookupEnv name env
-   = lookupFM env name
-
-
-find :: HsName -> Env a -> a 
-find name env = case lookupFM env name of
-    Just x -> x
-    Nothing -> error $ "Env.find: " ++ fromHsName name 
-
-
-addToEnv :: (HsName, a) -> Env a -> Env a
-addToEnv (name, val) env = addToFM env name val 
-
--- this might be expensive!
-joinEnv :: Env a -> Env a -> Env a 
-joinEnv env1 env2 
-   = joinFM env1 env2
-
-joinListEnvs :: [Env a] -> Env a 
-joinListEnvs = foldr joinEnv emptyEnv
-
-listToEnv :: [(HsName, a)] -> Env a 
-listToEnv = foldr addToEnv emptyEnv  
-
-fromList = listToEnv
-toList = toListFM 
-
-envToList :: Env a -> [(HsName, a)]
-envToList env
-   = toListFM env 
-
--- just get all the names out of the Env (added by Bryn)
-getNamesFromEnv :: Env a -> [HsName]
-getNamesFromEnv env = map fst (toListFM env)
-
-showEnv :: Show a => Env a -> String
-showEnv env = unlines $ map show $ toListFM env 
-
--- pretty print the environment
-
-pprintEnv :: PPrint Doc a => Env a -> Doc
-pprintEnv env = pl global $+$ pl local_norm $+$ pl local_sys  where
-    es = fmToList env
-    (local,global) = partition (\(x,_) -> isDigit $ head (hsIdentString (hsNameIdent x)) ) es
-    (local_sys,local_norm) = partition (\(x,_) -> last (hsIdentString (hsNameIdent x)) == '@' ) local
-    pl es = vcat [((pprint a) <+> (text "::") <+> (pprint b)) | (a, b) <- es]
-
---   = vcat [((pprint a) <+> (text "::") <+> (pprint b)) | (a, b) <- toListFM env]
-
--- map a function over the elements of the environment
-mapEnv :: (HsName -> e -> e') -> Env e -> Env e'
-mapEnv f map = mapFM f map
-
---------------------------------------------------------------------------------
-
---instance (Ord a, Term a, Term b) => Term (FiniteMap a b) where
---    explode (x::(FiniteMap a b)) = TermRep (dx, tl, rb x) where
---        dx = toDyn x
---        tl = map explode $ fmToList x
---        rb (_::FiniteMap a b) l = toDyn $ listToFM ((map (\(TermRep (x,_,_)) -> fDyn x) l):: [(a,b)])
-
-
-
---_tc_FiniteMapTc = mkTyCon "FiniteMap"
---instance (Typeable a,Typeable b) => Typeable (FiniteMap a b) where
---    typeOf x = mkAppTy _tc_FiniteMapTc [ typeOf (geta x),typeOf (getb x) ]
---      where
---        geta :: FiniteMap a b -> a
---        geta = undefined
---        getb :: FiniteMap a b -> b
---        getb = undefined
-
-
rmfile ./FrontEnd/Env.hs
hunk ./FrontEnd/Class.hs 57
-import Data.FiniteMap  
hunk ./FrontEnd/Class.hs 85
+listToFM = Map.fromList
hunk ./FrontEnd/DataConsAssump.hs 36
-import FrontEnd.Env              
+import qualified Data.Map as Map
hunk ./FrontEnd/DataConsAssump.hs 40
-dataConsEnv :: Module -> KindEnv -> [HsDecl] -> Env Scheme 
+dataConsEnv :: Module -> KindEnv -> [HsDecl] -> Map.Map HsName Scheme 
hunk ./FrontEnd/DataConsAssump.hs 42
-   = joinListEnvs $ map (dataDeclEnv modName kt) decls 
+   = Map.unions $ map (dataDeclEnv modName kt) decls 
hunk ./FrontEnd/DataConsAssump.hs 48
-dataDeclEnv :: Module -> KindEnv -> (HsDecl) -> Env Scheme 
+dataDeclEnv :: Module -> KindEnv -> (HsDecl) -> Map.Map HsName Scheme 
hunk ./FrontEnd/DataConsAssump.hs 50
-   = joinListEnvs $ map (conDeclType modName kt preds resultType) $ condecls 
+   = Map.unions $ map (conDeclType modName kt preds resultType) $ condecls 
hunk ./FrontEnd/DataConsAssump.hs 76
-   = emptyEnv
+   = Map.empty
hunk ./FrontEnd/DataConsAssump.hs 82
-conDeclType :: Module -> KindEnv -> [Pred] -> Type -> HsConDecl -> Env Scheme 
+unitEnv (x,y) = Map.singleton x y 
+
+conDeclType :: Module -> KindEnv -> [Pred] -> Type -> HsConDecl -> Map.Map HsName Scheme 
hunk ./FrontEnd/Representation.hs 37
-import Data.FiniteMap
+import qualified Data.Map as Map
hunk ./FrontEnd/Representation.hs 281
-type Subst  = FiniteMap Atom Type
+type Subst  = Map.Map Atom Type
hunk ./FrontEnd/TIMain.hs 57
-import FrontEnd.Env                     
-import Data.FiniteMap
hunk ./FrontEnd/TIMain.hs 70
-type TypeEnv = Env Scheme
+type TypeEnv = Map.Map HsName Scheme
hunk ./FrontEnd/TIMain.hs 77
-   apply s = mapFM (\k e -> apply s e)
-   tv env = tv $ map snd $ toListFM env
+   apply s = Map.map (\e -> apply s e)
+   tv env = tv $ map snd $ Map.toList env
hunk ./FrontEnd/TIMain.hs 83
-tiExpr env (HsVar v) | Just sc <- lookupEnv v env = do
+tiExpr env (HsVar v) | Just sc <- Map.lookup v env = do
hunk ./FrontEnd/TIMain.hs 86
-          return (ps, emptyEnv, t)
-tiExpr env (HsVar v) = error $ "tiExpr: could not find type scheme for: " ++ show v ++ " " ++ showEnv env        
+          return (ps, Map.empty, t)
+tiExpr env (HsVar v) = error $ "tiExpr: could not find type scheme for: " ++ show v ++ " " ++ show env        
hunk ./FrontEnd/TIMain.hs 97
-      return (ps, emptyEnv, t)
+      return (ps, Map.empty, t)
hunk ./FrontEnd/TIMain.hs 105
-      return (ps, emptyEnv, t)
+      return (ps, Map.empty, t)
hunk ./FrontEnd/TIMain.hs 109
-      return (ps, emptyEnv, t)
+      return (ps, Map.empty, t)
hunk ./FrontEnd/TIMain.hs 115
-    let newEnv = addToEnv (n,toScheme t) nenv
+    let newEnv = Map.insert n (toScheme t) nenv
hunk ./FrontEnd/TIMain.hs 128
-       return (ps ++ qs ++ rs, env1 `joinEnv` env2 `joinEnv` env3, tout)
+       return (ps ++ qs ++ rs, env1 `Map.union` env2 `Map.union` env3, tout)
hunk ./FrontEnd/TIMain.hs 138
-      return (ps++qs, env1 `joinEnv` env2, t)
+      return (ps++qs, env1 `Map.union` env2, t)
hunk ./FrontEnd/TIMain.hs 156
-        (qs, envE, t)  <- tiExpr (envP `joinEnv` env) e
-        return (ps++qs, envP `joinEnv` envE, foldr fn t ts)  -- Boba
+        (qs, envE, t)  <- tiExpr (envP `Map.union` env) e
+        return (ps++qs, envP `Map.union` envE, foldr fn t ts)  -- Boba
hunk ./FrontEnd/TIMain.hs 166
-         (qs, env2, t) <- tiExpr (env1 `joinEnv` env) e
+         (qs, env2, t) <- tiExpr (env1 `Map.union` env) e
hunk ./FrontEnd/TIMain.hs 168
-         return (ps ++ qs, env1 `joinEnv` env2, t) 
+         return (ps ++ qs, env1 `Map.union` env2, t) 
hunk ./FrontEnd/TIMain.hs 179
-         return (ps++ps1++ps2, env1 `joinEnv` env2 `joinEnv` env3, t1)
+         return (ps++ps1++ps2, env1 `Map.union` env2 `Map.union` env3, t1)
hunk ./FrontEnd/TIMain.hs 195
-        let envAlts  = joinListEnvs $ map snd3 psastsAlts
+        let envAlts  = Map.unions $ map snd3 psastsAlts
hunk ./FrontEnd/TIMain.hs 200
-        return (pse ++ psPats ++ psEs, env1 `joinEnv` envAlts, head tsEs)
+        return (pse ++ psPats ++ psEs, env1 `Map.union` envAlts, head tsEs)
hunk ./FrontEnd/TIMain.hs 217
-           let env1 = joinListEnvs $ map snd3 psasts
+           let env1 = Map.unions $ map snd3 psasts
hunk ./FrontEnd/TIMain.hs 224
-        return ([], emptyEnv, TAp tList v)
+        return ([], Map.empty, TAp tList v)
hunk ./FrontEnd/TIMain.hs 234
-        let env1 = joinListEnvs $ map snd3 psasts
+        let env1 = Map.unions $ map snd3 psasts
hunk ./FrontEnd/TIMain.hs 253
-        return (e1Ps ++ e2Ps, envE1 `joinEnv` envE2, tv) 
+        return (e1Ps ++ e2Ps, envE1 `Map.union` envE2, tv) 
hunk ./FrontEnd/TIMain.hs 268
-        return (e1Ps ++ e2Ps, envE1 `joinEnv` envE2, tv1 `fn` tv2) 
+        return (e1Ps ++ e2Ps, envE1 `Map.union` envE2, tv1 `fn` tv2) 
hunk ./FrontEnd/TIMain.hs 287
-                e1Env `joinEnv` e2Env, 
+                e1Env `Map.union` e2Env, 
hunk ./FrontEnd/TIMain.hs 296
-                e1Env `joinEnv` e2Env, 
+                e1Env `Map.union` e2Env, 
hunk ./FrontEnd/TIMain.hs 306
-                e1Env `joinEnv` e2Env `joinEnv` e3Env, 
+                e1Env `Map.union` e2Env `Map.union` e3Env, 
hunk ./FrontEnd/TIMain.hs 314
-        (ePs, eEnv, eT) <- tiExpr (stmtsEnv `joinEnv` env) e
-        return (stmtsPs ++ ePs, eEnv `joinEnv` stmtsEnv, TAp tList eT)
+        (ePs, eEnv, eT) <- tiExpr (stmtsEnv `Map.union` env) e
+        return (stmtsPs ++ ePs, eEnv `Map.union` stmtsEnv, TAp tList eT)
hunk ./FrontEnd/TIMain.hs 329
-tiStmts = tiStmtsAcc [] emptyEnv 
+tiStmts = tiStmtsAcc [] Map.empty 
hunk ./FrontEnd/TIMain.hs 337
-        (newPs, newEnv) <- tiStmt (envAcc `joinEnv` env) s
-        tiStmtsAcc (newPs ++ predAcc) (newEnv `joinEnv` envAcc) env ss
+        (newPs, newEnv) <- tiStmt (envAcc `Map.union` env) s
+        tiStmtsAcc (newPs ++ predAcc) (newEnv `Map.union` envAcc) env ss
hunk ./FrontEnd/TIMain.hs 354
-        return (ePs ++ patPs, eEnv `joinEnv` patEnv)
+        return (ePs ++ patPs, eEnv `Map.union` patEnv)
hunk ./FrontEnd/TIMain.hs 381
-        (wheresPs, wheresEnv) <- tiSeq tiBindGroup (envPat `joinEnv` env) wheresBgs
-        (psAlt, envAlt, tAlt) <- tiGuardedAlts (wheresEnv `joinEnv` envPat  `joinEnv` env) gAlts
+        (wheresPs, wheresEnv) <- tiSeq tiBindGroup (envPat `Map.union` env) wheresBgs
+        (psAlt, envAlt, tAlt) <- tiGuardedAlts (wheresEnv `Map.union` envPat  `Map.union` env) gAlts
hunk ./FrontEnd/TIMain.hs 384
-        return ((psPat, patT), envPat `joinEnv` envAlt `joinEnv` wheresEnv, (wheresPs ++ psAlt, tAlt)) --Boba
+        return ((psPat, patT), envPat `Map.union` envAlt `Map.union` wheresEnv, (wheresPs ++ psAlt, tAlt)) --Boba
hunk ./FrontEnd/TIMain.hs 401
-        let guardEnv   = joinListEnvs $ map snd3 guardsPsEnvTs
-        let rhsEnv      = joinListEnvs $ map snd3 rhsPsEnvTs 
+        let guardEnv   = Map.unions $ map snd3 guardsPsEnvTs
+        let rhsEnv      = Map.unions $ map snd3 rhsPsEnvTs 
hunk ./FrontEnd/TIMain.hs 405
-        return (guardPs ++ rhsPs, guardEnv `joinEnv` rhsEnv, head rhsTs)
+        return (guardPs ++ rhsPs, guardEnv `Map.union` rhsEnv, head rhsTs)
hunk ./FrontEnd/TIMain.hs 434
-        (qs, env2, t)  <- tiRhs (env1 `joinEnv` env) rhs
-        return (ps ++ qs, env1 `joinEnv` env2, t)
+        (qs, env2, t)  <- tiRhs (env1 `Map.union` env) rhs
+        return (ps ++ qs, env1 `Map.union` env2, t)
hunk ./FrontEnd/TIMain.hs 442
-        let matchesEnv = joinListEnvs $ map snd3 psEnvts
+        let matchesEnv = Map.unions $ map snd3 psEnvts
hunk ./FrontEnd/TIMain.hs 475
-        (wheresPs, wheresEnv) <- tiSeq tiBindGroup (patsEnv `joinEnv` env) wheresBgs  
-        (rhsPs, rhsEnv, rhsT)   <- tiRhs (wheresEnv `joinEnv` patsEnv `joinEnv` env) rhs
-        return (wheresPs++patsPs++rhsPs, patsEnv `joinEnv` rhsEnv `joinEnv` wheresEnv, foldr fn rhsT patsTs)  --Boba
+        (wheresPs, wheresEnv) <- tiSeq tiBindGroup (patsEnv `Map.union` env) wheresBgs  
+        (rhsPs, rhsEnv, rhsT)   <- tiRhs (wheresEnv `Map.union` patsEnv `Map.union` env) rhs
+        return (wheresPs++patsPs++rhsPs, patsEnv `Map.union` rhsEnv `Map.union` wheresEnv, foldr fn rhsT patsTs)  --Boba
hunk ./FrontEnd/TIMain.hs 495
-        let guardEnv    = joinListEnvs $ map snd3 guardsPsEnvTs
-        let rhsEnv      = joinListEnvs $ map snd3 rhsPsEnvTs 
+        let guardEnv    = Map.unions $ map snd3 guardsPsEnvTs
+        let rhsEnv      = Map.unions $ map snd3 rhsPsEnvTs 
hunk ./FrontEnd/TIMain.hs 499
-        return (guardPs ++ rhsPs, guardEnv `joinEnv` rhsEnv, head rhsTs)
+        return (guardPs ++ rhsPs, guardEnv `Map.union` rhsEnv, head rhsTs)
hunk ./FrontEnd/TIMain.hs 571
-          newEnv1 = listToEnv $ zip is scs -- map assumpToPair $ zipWith makeAssump is scs 
-          env'    = newEnv1 `joinEnv` env 
+          newEnv1 = Map.fromList $ zip is scs -- map assumpToPair $ zipWith makeAssump is scs 
+          env'    = newEnv1 `Map.union` env 
hunk ./FrontEnd/TIMain.hs 589
-              newEnv2 = listToEnv $ zip is scs' -- map assumpToPair $ zipWith makeAssump is scs'
-          in return (ds++rs,  (joinListEnvs envs) `joinEnv` newEnv2)
+              newEnv2 = Map.fromList $ zip is scs' -- map assumpToPair $ zipWith makeAssump is scs'
+          in return (ds++rs,  (Map.unions envs) `Map.union` newEnv2)
hunk ./FrontEnd/TIMain.hs 593
-              newEnv3 = listToEnv $ zip is scs' -- map assumpToPair $ zipWith makeAssump is scs'
-          in return (ds,  (joinListEnvs envs) `joinEnv` newEnv3)  
+              newEnv3 = Map.fromList $ zip is scs' -- map assumpToPair $ zipWith makeAssump is scs'
+          in return (ds,  (Map.unions envs) `Map.union` newEnv3)  
hunk ./FrontEnd/TIMain.hs 612
-     --let env1 = listToEnv [assumpToPair $ getDeclName decl :>: sc | (sc,decl) <- es ]
-     let env1 = listToEnv [(getDeclName decl, sc) | (sc,decl) <- es ]
-     (implPs, implEnv) <- tiImpls (env1 `joinEnv` env) is
-     explPsEnv   <- mapM (tiExpl (implEnv `joinEnv` env1 `joinEnv` env)) es 
+     --let env1 = Map.fromList [assumpToPair $ getDeclName decl :>: sc | (sc,decl) <- es ]
+     let env1 = Map.fromList [(getDeclName decl, sc) | (sc,decl) <- es ]
+     (implPs, implEnv) <- tiImpls (env1 `Map.union` env) is
+     explPsEnv   <- mapM (tiExpl (implEnv `Map.union` env1 `Map.union` env)) es 
hunk ./FrontEnd/TIMain.hs 617
-     let explEnv = joinListEnvs $ [ x | (_,_,x) <- explPsEnv]
-     --let env2 = listToEnv [ assumpToPair (getDeclName decl :>: sc) | (sc,_,_) <- explPsEnv | (_,decl) <- es ]
-     let env2 = listToEnv [ (getDeclName decl,sc) | (sc,_,_) <- explPsEnv | (_,decl) <- es ]
-     return (implPs ++ explPs, env2 `joinEnv` explEnv `joinEnv` implEnv)
+     let explEnv = Map.unions $ [ x | (_,_,x) <- explPsEnv]
+     --let env2 = Map.fromList [ assumpToPair (getDeclName decl :>: sc) | (sc,_,_) <- explPsEnv | (_,decl) <- es ]
+     let env2 = Map.fromList [ (getDeclName decl,sc) | (sc,_,_) <- explPsEnv | (_,decl) <- es ]
+     return (implPs ++ explPs, env2 `Map.union` explEnv `Map.union` implEnv)
hunk ./FrontEnd/TIMain.hs 623
- = return ([],emptyEnv)
+ = return ([],Map.empty)
hunk ./FrontEnd/TIMain.hs 626
-      (qs,env2) <- tiSeq ti (env1 `joinEnv` env) bss
-      return (ps++qs, env2 `joinEnv` env1)
+      (qs,env2) <- tiSeq ti (env1 `Map.union` env) bss
+      return (ps++qs, env2 `Map.union` env1)
hunk ./FrontEnd/TIMain.hs 707
-tiPat :: HsPat -> TI ([Pred], Env Scheme, Type)
+tiPat :: HsPat -> TI ([Pred], Map.Map HsName Scheme, Type)
hunk ./FrontEnd/TIMain.hs 712
-        let newAssump = (i,toScheme v)
-        return ([], unitEnv newAssump, v)
+        --let newAssump = (i,toScheme v)
+        return ([], Map.singleton i (toScheme v), v)
hunk ./FrontEnd/TIMain.hs 718
-        return (ps, emptyEnv, t)
+        return (ps, Map.empty, t)
hunk ./FrontEnd/TIMain.hs 736
-        return (psLeft ++ psRight, envLeft `joinEnv` envRight, t')
+        return (psLeft ++ psRight, envLeft `Map.union` envRight, t')
hunk ./FrontEnd/TIMain.hs 755
-        return ([], emptyEnv, TAp tList v)
+        return ([], Map.empty, TAp tList v)
hunk ./FrontEnd/TIMain.hs 765
-      return ([], emptyEnv, v)
+      return ([], Map.empty, v)
hunk ./FrontEnd/TIMain.hs 771
-      let newEnv = addToEnv (i,toScheme t) env
+      let newEnv = Map.insert  i (toScheme t) env
hunk ./FrontEnd/TIMain.hs 780
-tiPats :: [HsPat] -> TI ([Pred], Env Scheme, [Type])
+tiPats :: [HsPat] -> TI ([Pred], Map.Map HsName Scheme, [Type])
hunk ./FrontEnd/TIMain.hs 784
-         env = joinListEnvs $ map snd3 psEnvts
+         env = Map.unions $ map snd3 psEnvts
hunk ./FrontEnd/TIModule.hs 12
-import FrontEnd.Env  as Env    
hunk ./FrontEnd/TIModule.hs 25
-import Name(toName)
hunk ./FrontEnd/TIModule.hs 30
-import qualified Name
hunk ./FrontEnd/TIModule.hs 39
+import PPrint
hunk ./FrontEnd/TIModule.hs 41
-trimEnv env = (listToEnv [ n | n@(name,_) <- envToList env,  isGlobal name ])
+trimEnv env = (Map.fromList [ n | n@(name,_) <- Map.toList env,  isGlobal name ])
hunk ./FrontEnd/TIModule.hs 65
+pprintEnv :: PPrint Doc a => Map.Map HsName a -> Doc
+pprintEnv env = pl global $+$ pl local_norm $+$ pl local_sys  where
+    es = Map.toList env
+    (local,global) = partition (\(x,_) -> isDigit $ head (hsIdentString (hsNameIdent x)) ) es
+    (local_sys,local_norm) = partition (\(x,_) -> last (hsIdentString (hsNameIdent x)) == '@' ) local
+    pl es = vcat [((pprint a) <+> (text "::") <+> (pprint b)) | (a, b) <- es]
hunk ./FrontEnd/TIModule.hs 122
-    let importVarEnv = Env.fromList [ (n,y) | (x,y) <- Map.toList $ hoAssumps me, let (t,n) = fromName x, t == Name.Val ]
-        importDConsEnv = Env.fromList [ (n,y) | (x,y) <- Map.toList $ hoAssumps me, let (t,n) = fromName x, t == Name.DataConstructor ]
+    let importVarEnv = Map.fromList [ (n,y) | (x,y) <- Map.toList $ hoAssumps me, let (t,n) = fromName x, t == Name.Val ]
+        importDConsEnv = Map.fromList [ (n,y) | (x,y) <- Map.toList $ hoAssumps me, let (t,n) = fromName x, t == Name.DataConstructor ]
hunk ./FrontEnd/TIModule.hs 165
-    let globalDConsEnv = localDConsEnv `joinEnv` importDConsEnv
+    let globalDConsEnv = localDConsEnv `Map.union` importDConsEnv
hunk ./FrontEnd/TIModule.hs 219
-        noDefaultSigs = Env.fromList [ (n,maybe (error $ "sigEnv:"  ++ show n) id $ Map.lookup n sigEnv) | n <- classNoDefaults ]
-        fakeForeignDecls = [ [HsForeignDecl bogusASrcLoc ForeignPrimitive "" x (HsUnQualType $ HsTyTuple []) ] | (x,_) <- Env.toList noDefaultSigs]
+        noDefaultSigs = Map.fromList [ (n,maybe (error $ "sigEnv:"  ++ show n) id $ Map.lookup n sigEnv) | n <- classNoDefaults ]
+        fakeForeignDecls = [ [HsForeignDecl bogusASrcLoc ForeignPrimitive "" x (HsUnQualType $ HsTyTuple []) ] | (x,_) <- Map.toList noDefaultSigs]
hunk ./FrontEnd/TIModule.hs 254
-    let externalEnv = Env.fromList [ v | v@(x@(Qual m i) ,s) <- Env.toList localVarEnv, isGlobal x, m `elem` map modInfoName ms ]  `joinFM` noDefaultSigs
-    localVarEnv <- return $  localVarEnv `joinFM` noDefaultSigs
+    let externalEnv = Map.fromList [ v | v@(x@(Qual m i) ,s) <- Map.toList localVarEnv, isGlobal x, m `elem` map modInfoName ms ]  `Map.union` noDefaultSigs
+    localVarEnv <- return $  localVarEnv `Map.union` noDefaultSigs
hunk ./FrontEnd/TIModule.hs 260
-    let allAssumps = M.fromList $ [ (toName Name.DataConstructor x,y) | (x,y) <- Env.toList localDConsEnv ] ++ [ (toName Name.Val x,y) | (x,y) <- Env.toList localVarEnv ]
+    let allAssumps = M.fromList $ [ (toName Name.DataConstructor x,y) | (x,y) <- Map.toList localDConsEnv ] ++ [ (toName Name.Val x,y) | (x,y) <- Map.toList localVarEnv ]
hunk ./FrontEnd/TIModule.hs 262
-        expAssumps = M.fromList $ [ (toName Name.DataConstructor x,y) | (x,y) <- Env.toList localDConsEnv ] ++ [ (toName Name.Val x,y) | (x,y) <- Env.toList $ externalEnv ]
+        expAssumps = M.fromList $ [ (toName Name.DataConstructor x,y) | (x,y) <- Map.toList localDConsEnv ] ++ [ (toName Name.Val x,y) | (x,y) <- Map.toList $ externalEnv ]
hunk ./FrontEnd/TIMonad.hs 43
-import HsSyn    
-import Diagnostic
-import Representation
-import Type                  ((@@), Types (..), Instantiate (..), nullSubst, mgu)
+import Atom
hunk ./FrontEnd/TIMonad.hs 45
-import FrontEnd.Env
+import Control.Monad.State hiding(State(..))
+import Data.IORef
+import Diagnostic
+import HsSyn    
hunk ./FrontEnd/TIMonad.hs 50
-import TypeSigs              (SigEnv)
-import PPrint                (pretty)
hunk ./FrontEnd/TIMonad.hs 51
-import Control.Monad.State hiding(State(..))
-import Atom
+import PPrint                (pretty)
+import qualified Data.Map as Map
+import Representation
+import TypeSigs              (SigEnv)
+import Type                  ((@@), Types (..), Instantiate (..), nullSubst, mgu)
hunk ./FrontEnd/TIMonad.hs 57
-import Data.IORef
hunk ./FrontEnd/TIMonad.hs 59
---import Control.Monad.Reader
hunk ./FrontEnd/TIMonad.hs 72
-      tcDConsEnv          :: Env Scheme,
+      tcDConsEnv          :: Map.Map HsName Scheme,
hunk ./FrontEnd/TIMonad.hs 131
-runTI     :: Env Scheme-> ClassHierarchy -> KindEnv -> SigEnv -> Module -> TI a -> IO a
+runTI     :: Map.Map HsName Scheme-> ClassHierarchy -> KindEnv -> SigEnv -> Module -> TI a -> IO a
hunk ./FrontEnd/TIMonad.hs 167
-getDConsTypeEnv :: TI (Env Scheme) 
+getDConsTypeEnv :: TI (Map.Map HsName Scheme) 
hunk ./FrontEnd/TIMonad.hs 187
-        case lookupEnv conName env of
+        case Map.lookup conName env of
hunk ./FrontEnd/Type.hs 48
-import Data.FiniteMap
-import FrontEnd.Env
+import qualified Data.Map as Map
hunk ./FrontEnd/Type.hs 111
-nullSubst   = zeroFM 
+nullSubst   = Map.empty
hunk ./FrontEnd/Type.hs 114
-Tyvar u _ _ +-> t     = unitFM u t
+Tyvar u _ _ +-> t     = Map.singleton u t
hunk ./FrontEnd/Type.hs 127
-     = case lookupFM s var of
+     = case Map.lookup var s of
hunk ./FrontEnd/Type.hs 149
-   =(joinFM s1OverS2 s1)
+   =(Map.union s1OverS2 s1)
hunk ./FrontEnd/Type.hs 156
- s = joinFM s1 s2
- agree = all (\v -> lookupFM s1 (v) == lookupFM s2 (v)) $ map fst $ toListFM $ s1 `intersectFM` s2
+ s = Map.union s1 s2
+ agree = all (\v -> (Map.lookup v s1 :: Maybe Type) == Map.lookup v s2 ) $ map fst $ Map.toList $ s1 `Map.intersection` s2
hunk ./FrontEnd/Type.hs 182
-mapSubstitution s fm =(mapFM (\_ v -> apply s v) fm)
+mapSubstitution s fm =(Map.map (\v -> apply s v) fm)
hunk ./FrontEnd/Type.hs 184
-rnfFM fm = foldFM (\k e a -> k `seq` e `seq` a) () fm `seq` fm
+--rnfFM fm = Map.fold (\k e a -> k `seq` e `seq` a) () fm `seq` fm
hunk ./FrontEnd/Type.hs 276
-       s   = listToFM $ map (\(a@(Tyvar x _ _),b) -> (x,b a)) $ zip vs' (map TGen [0..])
+       s   = Map.fromList $ map (\(a@(Tyvar x _ _),b) -> (x,b a)) $ zip vs' (map TGen [0..])
hunk ./FrontEnd/TypeSigs.hs 19
---import FrontEnd.Env              (Env,
---                         listToEnv)
hunk ./FrontEnd/TypeSyns.hs 17
-import FrontEnd.Env