[changes for compatability with ghc 6.6
John Meacham <john@repetae.net>**20061012081038] hunk ./Binary.hs 59
+import Data.Array.Base
hunk ./Binary.hs 512
-        let sz = rangeSize (Data.Array.IO.bounds ua)
+        let sz = rangeSize (Data.Array.Base.bounds ua)
hunk ./DataConstructors.hs 27
-import Control.Monad.Writer
+import Control.Monad.Writer(tell,execWriter)
+import Data.Monoid hiding(getProduct)
hunk ./E/CPR.hs 3
-import Control.Monad.Writer
+import Control.Monad.Writer hiding(Product(..))
hunk ./E/Demand.hs 15
-import Control.Monad.Writer
+import Control.Monad.Writer hiding(Product(..))
hunk ./E/Demand.hs 17
-import Data.Monoid
+import Data.Monoid hiding(Product(..))
hunk ./E/E.hs 285
-
----------------------------
--- | compatable approximation
----------------------------
-
-eCompat :: E -> E -> Bool
-eCompat x y | x == y = True
-eCompat (EAp e1 e2) (EAp ea eb) = eCompat e1 ea && eCompat e2 eb
-eCompat (ELam (TVr { tvrType =  e1 }) e2) (ELam (TVr { tvrType =  ea }) eb) = eCompat e1 ea && eCompat e2 eb
-eCompat (EPi (TVr { tvrType = e1 }) e2) (EPi (TVr { tvrType = ea }) eb) = eCompat e1 ea && eCompat e2 eb
-eCompat (EVar _) _ = True
-eCompat _ (EVar _) = True
-eCompat (ELetRec _ e1) (ELetRec _ e2) = eCompat e1 e2
-eCompat (ELit LitCons { litName = n, litArgs = es, litType = t }) (ELit LitCons { litName = n', litArgs = es', litType = t' }) = n == n' && all (uncurry eCompat) (zip es es') && eCompat t t'
-eCompat x y = x == y
hunk ./E/WorkerWrapper.hs 3
-import Control.Monad.Writer
-import Data.Monoid
+import Control.Monad.Writer hiding(Product(..))
+import Data.Monoid hiding(Product(..))
hunk ./FrontEnd/Rename.hs 71
-import Data.FiniteMap
hunk ./FrontEnd/Rename.hs 105
-type SubTable = FiniteMap HsName HsName
+type SubTable = Map.Map HsName HsName
hunk ./FrontEnd/Rename.hs 116
-    globalSubTable :: FiniteMap HsName HsName,  -- Current substition
-    typeSubTable   :: FiniteMap HsName HsName,  -- type substition table
-    errorTable     :: FiniteMap HsName String,  -- special error message. else it's just unknown.
+    globalSubTable :: Map.Map HsName HsName,  -- Current substition
+    typeSubTable   :: Map.Map HsName HsName,  -- type substition table
+    errorTable     :: Map.Map HsName String,  -- special error message. else it's just unknown.
hunk ./FrontEnd/Rename.hs 167
-        nm = listToFM $ foldl f [] (fsts ns)
-        tm = listToFM $ foldl f [] (fsts ts)
+        nm = Map.fromList $ foldl f [] (fsts ns)
+        tm = Map.fromList $ foldl f [] (fsts ts)
hunk ./FrontEnd/Rename.hs 177
-    modify (\s -> s { globalSubTable = nm `plusFM` globalSubTable s })
-    modify (\s -> s { typeSubTable = tm `plusFM` typeSubTable s })
+    modify (\s -> s { globalSubTable = nm `Map.union` globalSubTable s })
+    modify (\s -> s { typeSubTable = tm `Map.union` typeSubTable s })
hunk ./FrontEnd/Rename.hs 189
-    initialGlobalSubTable = listToFM [ (x,y) | ((typ,x),[y]) <- ns', typ == Val || typ == DataConstructor ]
-    initialTypeSubTable = listToFM [ (x,y) | ((typ,x),[y]) <- ns', typ == TypeConstructor || typ == ClassName ]
+    initialGlobalSubTable = Map.fromList [ (x,y) | ((typ,x),[y]) <- ns', typ == Val || typ == DataConstructor ]
+    initialTypeSubTable = Map.fromList [ (x,y) | ((typ,x),[y]) <- ns', typ == TypeConstructor || typ == ClassName ]
hunk ./FrontEnd/Rename.hs 194
-    errorTab =  listToFM [ (x,ambig x ys) | ((typ,x),ys@(_:_:_)) <- ns' ]
+    errorTab =  Map.fromList [ (x,ambig x ys) | ((typ,x),ys@(_:_:_)) <- ns' ]
hunk ./FrontEnd/Rename.hs 213
-    initialGlobalSubTable = listToFM [ (x,y) | ((typ,x),[y]) <- ns', typ == Val || typ == DataConstructor ]
-    initialTypeSubTable = listToFM [ (x,y) | ((typ,x),[y]) <- ns', typ == TypeConstructor || typ == ClassName ]
+    initialGlobalSubTable = Map.fromList [ (x,y) | ((typ,x),[y]) <- ns', typ == Val || typ == DataConstructor ]
+    initialTypeSubTable = Map.fromList [ (x,y) | ((typ,x),[y]) <- ns', typ == TypeConstructor || typ == ClassName ]
hunk ./FrontEnd/Rename.hs 218
-    errorTab =  listToFM [ (x,ambig x ys) | ((typ,x),ys@(_:_:_)) <- ns' ]
+    errorTab =  Map.fromList [ (x,ambig x ys) | ((typ,x),ys@(_:_:_)) <- ns' ]
hunk ./FrontEnd/Rename.hs 246
-        let subTable' = subTable `plusFM` subTable'a
+        let subTable' = subTable `Map.union` subTable'a
hunk ./FrontEnd/Rename.hs 869
-renameHsName hsName subTable = case lookupFM subTable  hsName of
+renameHsName hsName subTable = case Map.lookup hsName subTable of
hunk ./FrontEnd/Rename.hs 877
-            let err = case lookupFM et hsName of {
+            let err = case Map.lookup hsName et of {
hunk ./FrontEnd/Rename.hs 893
-renameTypeHsName hsName subTable  =  gets typeSubTable  >>= \t -> case lookupFM t hsName of
+renameTypeHsName hsName subTable  =  gets typeSubTable  >>= \t -> case Map.lookup hsName t of
hunk ./FrontEnd/Rename.hs 944
-          subTable'   = addToFM subTable hsName hsName'
+          subTable'   = Map.insert hsName hsName' subTable
hunk ./FrontEnd/Rename.hs 1205
-  | lookupFM subTable hsName == Nothing = [hsName]
+  | Map.lookup hsName subTable == Nothing = [hsName]
hunk ./FrontEnd/Tc/Main.hs 524
-    (mvs,ds,rs) <- splitReduce (Set.toList fs) (Set.toList $ foldr1 Set.intersect vss) ps'
+    (mvs,ds,rs) <- splitReduce (Set.toList fs) (Set.toList $ foldr1 Set.intersection vss) ps'
hunk ./Grin/Noodle.hs 33
-    g lf (p :-> e) | flint && not (Set.null $ Set.intersect (freeVars p) lamFV) = error "modifyTail: lam floated inside bad scope"
+    g lf (p :-> e) | flint && not (Set.null $ Set.intersection (freeVars p) lamFV) = error "modifyTail: lam floated inside bad scope"
hunk ./Grin/Simplify.hs 382
-    f lt@Let { expDefs = defs, expBody = e :>>= l :-> r } | Set.null (freeVars r `Set.intersect` (Set.fromList $ map funcDefName defs)) = do
+    f lt@Let { expDefs = defs, expBody = e :>>= l :-> r } | Set.null (freeVars r `Set.intersection` (Set.fromList $ map funcDefName defs)) = do
hunk ./Grin/Simplify.hs 388
-    f lt@Let { expDefs = defs, expBody = e :>>= l :-> r } | Set.null (freeVars e `Set.intersect` (Set.fromList $ map funcDefName defs)) = do
+    f lt@Let { expDefs = defs, expBody = e :>>= l :-> r } | Set.null (freeVars e `Set.intersection` (Set.fromList $ map funcDefName defs)) = do
hunk ./Interactive.hs 6
+import Control.Exception as CE
hunk ./Interactive.hs 15
-import Text.Regex.Posix(regcomp,regExtended)
+--import Text.Regex.Posix(regcomp,regExtended)
hunk ./Interactive.hs 139
-        rx <- catch ( Just `fmap` regcomp reg regExtended) (\_ -> return Nothing)
+        rx <- CE.catch ( Just `fmap` evaluate (mkRegex reg)) (\_ -> return Nothing)
hunk ./Interactive.hs 154
-            catch (runIn isStart { stateInteract = act } $ executeStatement e) $ (\e -> putStrLn $ ioeGetErrorString e)
+            CE.catch (runIn isStart { stateInteract = act } $ executeStatement e) $ (\e -> putStrLn $ show e)