[remove refereces to FunctorM
John Meacham <john@repetae.net>**20080206191737] hunk ./DerivingDrift/Drift.hs 6
-import Data.FunctorM
+import qualified Data.Traversable as T
hunk ./DerivingDrift/Drift.hs 44
-        Identity fns = fmapM (return . f) sFuncNames
+        Identity fns = T.mapM (return . f) sFuncNames
hunk ./E/LambdaLift.hs 5
-import Data.FunctorM
hunk ./E/Rules.hs 23
-import Data.FunctorM
+import qualified Data.Traversable as T
hunk ./E/Rules.hs 87
-    mp' <- fmapM (mapM f) mp
+    mp' <- T.mapM (mapM f) mp
hunk ./E/SSimplify.hs 15
-import Data.FunctorM
hunk ./E/SSimplify.hs 22
+import qualified Data.Traversable as T
hunk ./E/SSimplify.hs 166
-        (d',fvb) <- grump (fmapM f d)
+        (d',fvb) <- grump (T.mapM f d)
hunk ./E/SSimplify.hs 181
-        l <- arg (fmapM f l)
+        l <- arg (T.mapM f l)
hunk ./E/SSimplify.hs 589
-                d'' <- fmapM g d
+                d'' <- T.mapM g d
hunk ./E/SSimplify.hs 685
-                d' <- fmapM dd d
+                d' <- T.mapM dd d
hunk ./E/Subst.hs 16
-import Data.FunctorM
hunk ./E/Subst.hs 17
+import qualified Data.Traversable as T
hunk ./E/Subst.hs 102
-        d <- local r $ fmapM f $ eCaseDefault ec
+        d <- local r $ T.mapM f $ eCaseDefault ec
hunk ./E/Subst.hs 109
-                l' <- fmapM f l
+                l' <- T.mapM f l
hunk ./E/Subst.hs 222
-        d <- local r $ fmapM f $ eCaseDefault ec
+        d <- local r $ T.mapM f $ eCaseDefault ec
hunk ./E/ToHs.hs 9
-import Data.FunctorM
hunk ./E/ToHs.hs 12
+import qualified Data.Traversable as T
hunk ./E/ToHs.hs 276
-    md <- fmapM transE md
+    md <- T.mapM transE md
hunk ./E/Traverse.hs 16
-import Data.FunctorM
hunk ./E/Traverse.hs 17
+import qualified Data.Traversable as T
hunk ./E/Traverse.hs 57
-    z (ELit aa) = do aa <- fmapM g aa; return $ ELit aa
+    z (ELit aa) = do aa <- T.mapM g aa; return $ ELit aa
hunk ./E/Traverse.hs 61
-        b' <- fmapM g (eCaseBind ec)
+        b' <- T.mapM g (eCaseBind ec)
hunk ./E/Traverse.hs 63
-        d' <- fmapM f (eCaseDefault ec)
+        d' <- T.mapM f (eCaseDefault ec)
hunk ./E/Traverse.hs 66
-    --    aa ab) = do aa <- f aa;ab <- mapM (\(x,y) -> do x <- fmapM f x; y <- f y; return (x,y)) ab; return $ ECase aa ab
+    --    aa ab) = do aa <- f aa;ab <- mapM (\(x,y) -> do x <- T.mapM f x; y <- f y; return (x,y)) ab; return $ ECase aa ab
hunk ./E/Traverse.hs 69
-    mapmTvr = fmapM
+    mapmTvr = T.mapM
hunk ./E/Traverse.hs 72
-        xs' <- mapM (fmapM g) xs
+        xs' <- mapM (T.mapM g) xs
hunk ./E/Traverse.hs 77
-        l' <- fmapM g l
+        l' <- T.mapM g l
hunk ./E/Traverse.hs 127
-            d' <- fmapM f d
+            d' <- T.mapM f d
hunk ./E/TypeAnalysis.hs 12
-import Data.FunctorM
hunk ./E/TypeAnalysis.hs 14
+import qualified Data.Foldable as T
hunk ./E/TypeAnalysis.hs 168
-    fmapM_ (calcE env) (eCaseDefault ec)
+    T.mapM_ (calcE env) (eCaseDefault ec)
hunk ./FrontEnd/KindInfer.hs 21
-import Data.FunctorM
+import qualified Data.Traversable as T
hunk ./FrontEnd/KindInfer.hs 254
-    kindEnv <- fmapM flattenKind (kindEnv ke)
-    kindEnvClasses <- fmapM (mapM flattenKind) (kindEnvClasses ke)
+    kindEnv <- T.mapM flattenKind (kindEnv ke)
+    kindEnvClasses <- T.mapM (mapM flattenKind) (kindEnvClasses ke)
hunk ./FrontEnd/KindInfer.hs 259
-    kindEnv <- fmapM flattenKind kindEnv
-    kindEnvClasses <- fmapM (mapM flattenKind) kindEnvClasses
+    kindEnv <- T.mapM flattenKind kindEnv
+    kindEnvClasses <- T.mapM (mapM flattenKind) kindEnvClasses
hunk ./FrontEnd/ParseUtils.hs 37
-import Data.FunctorM
hunk ./FrontEnd/ParseUtils.hs 39
+import qualified Data.Traversable as T
hunk ./FrontEnd/ParseUtils.hs 155
-			      p <- fmapM checkPattern e
+			      p <- T.mapM checkPattern e
hunk ./FrontEnd/Rename.hs 70
-import Data.FunctorM
+import qualified Data.Traversable as T
hunk ./FrontEnd/Rename.hs 644
-Identity uqFuncNames = fmapM (return . nameName . toUnqualified) sFuncNames
+Identity uqFuncNames = T.mapM (return . nameName . toUnqualified) sFuncNames
hunk ./FrontEnd/SrcLoc.hs 9
-import Data.FunctorM
hunk ./FrontEnd/SrcLoc.hs 66
---instance FunctorM Located where
---    fmapM f (Located l x) = Located l `liftM` f x
-
hunk ./FrontEnd/Tc/Monad.hs 53
-import Data.FunctorM
+import qualified Data.Traversable as T
+
hunk ./FrontEnd/Tc/Monad.hs 156
-    r <- fmapM flattenType r
+    r <- T.mapM flattenType r
hunk ./FrontEnd/Tc/Monad.hs 163
-    r <- fmapM flattenType r
+    r <- T.mapM flattenType r
hunk ./FrontEnd/TypeSyns.hs 5
-import Data.FunctorM
+import qualified Data.Traversable as T
hunk ./FrontEnd/TypeSyns.hs 162
-    fvs' <- sequence [ fmapM (`renameHsType` subTable) t  >>= return . (,) n | (n,t) <- fvs]
+    fvs' <- sequence [ T.mapM (`renameHsType` subTable) t  >>= return . (,) n | (n,t) <- fvs]
hunk ./Util/Histogram.hs 55
-{-
-instance Functor Histogram where
-    fmap f (Histogram m) = Histogram $ Map.fromList [ (f k,i) | (k,i) <- Map.toList m ]
-
-instance FunctorM Histogram where
-    fmapM f (Histogram m) = do
-        ds <- sequence [ do f k >>= return . flip (,) i  | (k,i) <- Map.toList m ]
-        return $ Histogram (Map.fromList ds)
-    fmapM_ f (Histogram m) = sequence_ [ do f k >>= return . flip (,) i  | (k,i) <- Map.toList m ]
-
--}
hunk ./Util/Inst.hs 28
-{-
-instance Ord a => FunctorM (Map.Map a) where
-    fmapM_ f mp = mapM_ f (Map.elems mp)
-    fmapM f mp = sequence [ f y >>= return . (,) x | (x,y) <- Map.toAscList mp] >>= return . Map.fromDistinctAscList
-
-instance FunctorM IM.IntMap where
-    fmapM_ f mp = mapM_ f (IM.elems mp)
-    fmapM f mp = sequence [ f y >>= return . (,) x | (x,y) <- IM.toAscList mp] >>= return . IM.fromDistinctAscList
-
-
-instance Foldable IM.IntMap where
-    foldMap f m = foldMap f (IM.elems m)
-
--}