[switch E annotation to using IdMap's rather than regular Maps.
John Meacham <john@repetae.net>**20060409062329] hunk ./E/Annotate.hs 6
-import qualified Data.Map as Map
hunk ./E/Annotate.hs 12
-import Info.Info as Info
hunk ./E/Annotate.hs 14
+import qualified Info.Info as Info
+import Info.Info(Info)
+import Util.SetLike
+import Util.HasSize
hunk ./E/Annotate.hs 20
-    (Map.Map Id (Maybe E))
+    (IdMap (Maybe E))
hunk ./E/Annotate.hs 32
-    (Map.Map Id (Maybe E))
+    (IdMap (Maybe E))
hunk ./E/Annotate.hs 44
-    (Map.Map Id (Maybe E))
+    (IdMap (Maybe E))
hunk ./E/Annotate.hs 51
-    -- f :: Monad m => E -> ReaderT (Map.Map Int (Maybe E)) m E
hunk ./E/Annotate.hs 53
-        case Map.lookup i mp of
+        case mlookup i mp of
hunk ./E/Annotate.hs 97
-        e' <- local (Map.insert n Nothing) $ f e
+        e' <- local (minsert n Nothing) $ f e
hunk ./E/Annotate.hs 110
-    -- ntvr :: Monad m => Info -> [Int] -> TVr -> ReaderT (Map.Map Int (Maybe E)) m (TVr, (Map.Map Int (Maybe E)) -> (Map.Map Int (Maybe E)))
hunk ./E/Annotate.hs 124
-            True -> return (nvr,Map.insert i (Just $ EVar nvr))
-            False -> return (nvr,Map.insert i (Just $ EVar nvr) . Map.insert i' Nothing)
+            True -> return (nvr,minsert i (Just $ EVar nvr))
+            False -> return (nvr,minsert i (Just $ EVar nvr) . minsert i' Nothing)
hunk ./E/Annotate.hs 129
-            return (tvr { tvrInfo = nfo },Map.insert (tvrIdent tvr) (Just $ EVar tvr))
+            return (tvr { tvrInfo = nfo },minsert (tvrIdent tvr) (Just $ EVar tvr))
hunk ./E/Annotate.hs 142
-    | i <= 0 || i `Map.member` ss = nv (Map.fromList [ (x,undefined) | x <- xs ] `mappend` ss)
+    | i <= 0 || i `mmember` ss = nv (fromList [ (x,undefined) | x <- xs ] `mappend` ss)
hunk ./E/Annotate.hs 146
-nv ss = v (2 * (Map.size ss + 1)) where
-    v n | n `Map.member` ss = v (n + 2)
+nv ss = v (2 * (size ss + 1)) where
+    v n | n `mmember` ss = v (n + 2)
hunk ./E/Annotate.hs 150
-nv' ss = v (2 * (Map.size ss + 1)) where
-    v n | (Just Nothing) <- Map.lookup n ss = v (n + 2)
+nv' ss = v (2 * (size ss + 1)) where
+    v n | (Just Nothing) <- mlookup n ss = v (n + 2)
hunk ./E/Inline.hs 12
-import Data.FunctorM
hunk ./E/Inline.hs 13
-import qualified Data.Set as Set
-import qualified Data.Map as Map
hunk ./E/Inline.hs 16
+import E.Annotate
hunk ./E/Inline.hs 20
-import E.Annotate
hunk ./E/Inline.hs 23
-import Info.Info as Info
+import qualified Info.Info as Info
+import Info.Info(Info)
hunk ./E/Inline.hs 26
+import Name.Id
hunk ./E/Inline.hs 32
-import Util.HasSize
-import Name.Id
+import Util.SetLike
hunk ./E/Inline.hs 47
-
-
-
hunk ./E/Inline.hs 51
-    | Properties p <- Info.fetch (tvrInfo x) = Set.member prop_INLINE p  || Set.member prop_WRAPPER p || Set.member prop_SUPERINLINE p
+    | Properties p <- Info.fetch (tvrInfo x) = member prop_INLINE p  || member prop_WRAPPER p || member prop_SUPERINLINE p
hunk ./E/Inline.hs 56
-    | Properties p <- Info.fetch (tvrInfo x) =  Set.member prop_SUPERINLINE p
+    | Properties p <- Info.fetch (tvrInfo x) =  member prop_SUPERINLINE p
hunk ./E/Inline.hs 60
-    | Properties p <- Info.fetch (tvrInfo x) = Set.member prop_NOINLINE p || Set.member prop_PLACEHOLDER p
+    | Properties p <- Info.fetch (tvrInfo x) = member prop_NOINLINE p || member prop_PLACEHOLDER p
hunk ./E/Inline.hs 97
-    Map.Map Id (Maybe E)        -- ^ initial map to apply
+    IdMap (Maybe E)        -- ^ initial map to apply
hunk ./E/Inline.hs 113
-            let smap = substMap'' $ Map.fromList [ (tvrIdent x,EVar x) | (x,y) <- nds]
+            let smap = substMap'' $ fromList [ (tvrIdent x,EVar x) | (x,y) <- nds]
hunk ./E/Inline.hs 117
-        bm xs imap = Map.fromList [ (tvrIdent t,Just $ EVar t) | (t,_) <- xs ] `Map.union` imap
+        bm xs imap = fromList [ (tvrIdent t,Just $ EVar t) | (t,_) <- xs ] `union` imap
hunk ./Main.hs 235
-    let initMap' = Map.fromList [ (tvrIdent tvr,EVar tvr) | tvr <- fsts $ Map.elems (hoEs ho)]
-
hunk ./Main.hs 261
-    let initMap = Map.fromList [ (tvrIdent t, Just (EVar t)) | (t,_) <- (Map.elems (hoEs ho))]
+    let initMap = fromList [ (tvrIdent t, Just (EVar t)) | (t,_) <- (Map.elems (hoEs ho))]
hunk ./Main.hs 388
-                    let sopt = mempty { SS.so_exports = inscope, SS.so_boundVars = Map.fromList [ (tvrIdent v,lc) | (v,lc) <- ds] `Map.union` smap, SS.so_rules = allRules, SS.so_dataTable = fullDataTable }
+                    let sopt = mempty { SS.so_exports = inscope, SS.so_boundVars = fromList [ (tvrIdent v,lc) | (v,lc) <- ds] `union` smap, SS.so_rules = allRules, SS.so_dataTable = fullDataTable }
hunk ./Main.hs 405
-        let uidMap = Map.fromAscList [  (id,Nothing :: Maybe E) | id <- idSetToList usedids ]
hunk ./Main.hs 407
-        return (nvls ++ retds, (Map.fromList [ (tvrIdent v,lc) | (v,lc) <- nvls] `Map.union` smap, Map.fromList [ (tvrIdent v,(Just (EVar v))) | (v,_) <- nvls] `Map.union` annmap , idHist' ))
+        return (nvls ++ retds, (fromList [ (tvrIdent v,lc) | (v,lc) <- nvls] `union` smap, fromList [ (tvrIdent v,(Just (EVar v))) | (v,_) <- nvls] `union` annmap , idHist' ))
hunk ./Main.hs 415
-    (ds,_) <- foldM f ([],(Map.fromList [ (tvrIdent v,e) | (v,e) <- Map.elems (hoEs ho)], initMap, Set.empty)) (map fscc $ scc graph)
+    (ds,_) <- foldM f ([],(fromList [ (tvrIdent v,e) | (v,e) <- Map.elems (hoEs ho)], initMap, Set.empty)) (map fscc $ scc graph)
hunk ./Main.hs 432
-        (ds,_) <- foldM f ([],(Map.fromList [ (tvrIdent v,e) | (v,e) <- Map.elems (hoEs ho)], initMap, Set.empty)) (map fscc $ scc graph)
+        (ds,_) <- foldM f ([],(fromList [ (tvrIdent v,e) | (v,e) <- Map.elems (hoEs ho)], initMap, Set.empty)) (map fscc $ scc graph)
hunk ./Main.hs 512
-        let initMap = Map.fromList [ (tvrIdent t, Just (EVar t)) | (t,_) <- programDs prog, not $ t `Set.member` tmap]
+        let initMap = fromList [ (tvrIdent t, Just (EVar t)) | (t,_) <- programDs prog, not $ t `Set.member` tmap]