[make compatable with ghc 6.8, remove FunctorM, needs new version of DrIFT
John Meacham <john@repetae.net>**20080206184421] hunk ./E/Annotate.hs 4
-import Data.FunctorM
hunk ./E/Annotate.hs 5
+import qualified Data.Traversable as T
hunk ./E/Annotate.hs 79
-        d <- local r $ fmapM f $ eCaseDefault ec
+        d <- local r $ T.mapM f $ eCaseDefault ec
hunk ./E/Annotate.hs 86
-                l' <- fmapM f l
+                l' <- T.mapM f l
hunk ./E/E.hs 13
-import Data.FunctorM
+import qualified Data.Traversable as T
hunk ./E/E.hs 112
-    d' <- fmapM f d
+    d' <- T.mapM f d
hunk ./E/FromHs.hs 13
-import Data.FunctorM
+import qualified Data.Traversable as T
hunk ./E/FromHs.hs 162
-  let funcs = runIdentity $ fmapM (\n -> return . EVar . fst $ runEither (show n) $ Map.lookup n ds) sFuncNames
+  let funcs = runIdentity $ T.mapM (\n -> return . EVar . fst $ runEither (show n) $ Map.lookup n ds) sFuncNames
hunk ./E/FromHs.hs 358
-    Identity funcs = fmapM (return . EVar . toTVr assumps dataTable) sFuncNames
+    Identity funcs = T.mapM (return . EVar . toTVr assumps dataTable) sFuncNames
hunk ./E/Type.hs 3
-import Data.FunctorM
hunk ./E/Type.hs 5
+import Data.Traversable
+import Data.Foldable hiding(concat)
+import Control.Applicative
hunk ./E/Type.hs 13
-import Doc.DocLike
+import Doc.DocLike hiding((<$>))
hunk ./E/Type.hs 46
-        {-!derive: is !-}
+        {-!derive: is, Functor, Foldable, Traversable !-}
hunk ./E/Type.hs 92
-instance Functor (Lit e) where
-    fmap f x = runIdentity $ fmapM (return . f) x
+--instance Functor (Lit e) where
+--    fmap f x = runIdentity $ fmapM (return . f) x
hunk ./E/Type.hs 95
-instance FunctorM (Lit e) where
-    fmapM f x = case x of
-        LitCons { litName = a, litArgs = es, litType = e, litAliasFor = af } -> do  e <- f e; return LitCons { litName = a, litArgs = es, litType = e, litAliasFor = af }
-        LitInt i t -> do t <- f t; return $ LitInt i t
+--instance FunctorM (Lit e) where
+--    fmapM f x = case x of
+--        LitCons { litName = a, litArgs = es, litType = e, litAliasFor = af } -> do  e <- f e; return LitCons { litName = a, litArgs = es, litType = e, litAliasFor = af }
+--        LitInt i t -> do t <- f t; return $ LitInt i t
hunk ./E/Type.hs 122
-    {-! derive: update !-}
+        {-!derive: update, Functor, Foldable, Traversable !-}
hunk ./E/Type.hs 127
-instance FunctorM TVr' where
-    fmapM f t = do e <- f (tvrType t); return t { tvrType = e }
-instance Functor TVr' where
-    fmap f t = runIdentity (fmapM (return . f) t)
+--instance FunctorM TVr' where
+--    fmapM f t = do e <- f (tvrType t); return t { tvrType = e }
+--instance Functor TVr' where
+--    fmap f t = runIdentity (fmapM (return . f) t)
hunk ./FrontEnd/SrcLoc.hs 6
+import Control.Applicative
+import Data.Traversable
+import Data.Foldable
hunk ./FrontEnd/SrcLoc.hs 66
-instance FunctorM Located where
-    fmapM f (Located l x) = Located l `liftM` f x
+
+--instance FunctorM Located where
+--    fmapM f (Located l x) = Located l `liftM` f x
+
+instance Foldable Located where
+    foldMap f (Located l x) = f x
+
+instance Traversable Located where
+    traverse f (Located l x) = Located l <$> f x
hunk ./Ho/Build.hs 23
-import qualified Data.ByteString.Base as L
hunk ./Ho/Build.hs 315
-    let hh = decode (decompress $ L.LPS [rhh])
-    let ho = decode (decompress $ L.LPS [rho])
+    let hh = decode (decompress $ L.fromChunks [rhh])
+    let ho = decode (decompress $ L.fromChunks [rho])
hunk ./Name/Id.hs 26
-import Data.FunctorM
+import Data.Traversable
+import Data.Foldable
hunk ./Name/Id.hs 64
-    deriving(Typeable,Monoid,HasSize,SetLike,BuildSet (Id,a),MapLike Id a,Functor,FunctorM,IsEmpty,Eq,Ord)
+    deriving(Typeable,Monoid,HasSize,SetLike,BuildSet (Id,a),MapLike Id a,Functor,Traversable,Foldable,IsEmpty,Eq,Ord)
hunk ./Name/VConsts.hs 3
-import Data.FunctorM
+import Data.Traversable
+import Data.Foldable
+import Control.Applicative
+import Data.Monoid
hunk ./Name/VConsts.hs 110
-    {-! derive: FunctorM !-}
+    {-! derive: Functor, Traversable, Foldable !-}
hunk ./Util/Inst.hs 8
-import Data.FunctorM
hunk ./Util/Inst.hs 10
+import Data.Foldable  hiding(or)
+import Data.Traversable
hunk ./Util/Inst.hs 28
+{-
hunk ./Util/Inst.hs 38
+instance Foldable IM.IntMap where
+    foldMap f m = foldMap f (IM.elems m)
+
+-}
+instance Traversable IM.IntMap where
+    traverse f mp = (IM.fromAscList . Map.toAscList) `fmap`  (traverse f . Map.fromAscList . IM.toAscList $ mp)