Ticket #3999: intmap-folding.patch

Wed Apr 21 17:59:32 CDT 2010  wasserman.louis@gmail.com
  * foldrWithKey, foldlWithKey, an improved Foldable instance, and folding rewrite rules for Data.IntMap

New patches:

[foldrWithKey, foldlWithKey, an improved Foldable instance, and folding rewrite rules for Data.IntMap
wasserman.louis@gmail.com**20100421225932
 Ignore-this: d1d53c1d56e4e118076cc19a01d53524
] {
hunk ./Data/IntMap.hs 104
             -- ** Fold
             , fold
             , foldWithKey
+            , foldrWithKey
+            , foldlWithKey
 
             -- * Conversion
             , elems
hunk ./Data/IntMap.hs 170
 import Prelude hiding (lookup,map,filter,foldr,foldl,null)
 import Data.Bits 
 import qualified Data.IntSet as IntSet
+import qualified Data.List as List
 import Data.Monoid (Monoid(..))
 import Data.Maybe (fromMaybe)
 import Data.Typeable
hunk ./Data/IntMap.hs 174
-import Data.Foldable (Foldable(foldMap))
+import Data.Foldable (Foldable(foldMap,foldr,foldl))
 import Data.Traversable (Traversable(traverse))
 import Control.Applicative (Applicative(pure,(<*>)),(<$>))
 import Control.Monad ( liftM )
hunk ./Data/IntMap.hs 260
     foldMap _ Nil = mempty
     foldMap f (Tip _k v) = f v
     foldMap f (Bin _ _ l r) = foldMap f l `mappend` foldMap f r
+    foldr f = foldrWithKey (const f)
+    foldl f = foldlWithKey (const . f)
 
 instance Traversable IntMap where
     traverse _ Nil = pure Nil
hunk ./Data/IntMap.hs 1367
 
 foldWithKey :: (Key -> a -> b -> b) -> b -> IntMap a -> b
 foldWithKey f z t
-  = foldr f z t
+  = foldrWithKey f z t
 
hunk ./Data/IntMap.hs 1369
-foldr :: (Key -> a -> b -> b) -> b -> IntMap a -> b
-foldr f z t
+-- | /O(n)/. Fold the keys and values in the map, such that
+-- @'foldrWithKey' f z == 'Prelude.foldr' ('uncurry' f) z . 'toAscList'@.
+-- For example,
+--
+-- > keys map = foldrWithKey (\k x ks -> k:ks) [] map
+--
+-- > let f k a result = result ++ "(" ++ (show k) ++ ":" ++ a ++ ")"
+-- > foldrWithKey f "Map: " (fromList [(5,"a"), (3,"b")]) == "Map: (5:a)(3:b)"
+foldrWithKey :: (Key -> a -> b -> b) -> b -> IntMap a -> b
+foldrWithKey f z t 
   = case t of
       Bin 0 m l r | m < 0 -> foldr' f (foldr' f z l) r  -- put negative numbers before.
       Bin _ _ _ _ -> foldr' f z t
hunk ./Data/IntMap.hs 1385
       Tip k x     -> f k x z
       Nil         -> z
 
+-- | /O(n)/.  Fold the keys and values in the map, such that
+-- @'foldlWithKey' f z == 'Prelude.foldl' ('uncurry' . f) z . 'toAscList'@.
+foldlWithKey :: (b -> Key -> a -> b) -> b -> IntMap a -> b
+foldlWithKey f z t
+  = case t of
+      Bin 0 m l r | m < 0 -> foldl' f (foldl' f z r) l
+      Bin _ _ _ _ -> foldl' f z t
+      Tip k x     -> f z k x
+      Nil         -> z
+
 foldr' :: (Key -> a -> b -> b) -> b -> IntMap a -> b
 foldr' f z t
   = case t of
hunk ./Data/IntMap.hs 1402
       Tip k x     -> f k x z
       Nil         -> z
 
-
+foldl' :: (b -> Key -> a -> b) -> b -> IntMap a -> b
+foldl' f z t
+  = case t of
+      Bin _ _ l r -> foldl' f (foldl' f z l) r
+      Tip k x     -> f z k x
+      Nil         -> z
 
 {--------------------------------------------------------------------
   List variations 
hunk ./Data/IntMap.hs 1460
 
 toList :: IntMap a -> [(Key,a)]
 toList t
-  = foldWithKey (\k x xs -> (k,x):xs) [] t
+  = toAscList t
 
hunk ./Data/IntMap.hs 1462
+{-# NOINLINE [0] toAscList #-}
 -- | /O(n)/. Convert the map to a list of key\/value pairs where the
 -- keys are in ascending order.
 --
hunk ./Data/IntMap.hs 1470
 
 toAscList :: IntMap a -> [(Key,a)]
 toAscList t   
-  = -- NOTE: the following algorithm only works for big-endian trees
-    let (pos,neg) = span (\(k,_) -> k >=0) (foldr (\k x xs -> (k,x):xs) [] t) in neg ++ pos
+       = foldWithKey (\k x xs -> (k,x):xs) [] t
+--   = -- NOTE: the following algorithm only works for big-endian trees
+--     let (pos,neg) = span (\(k,_) -> k >=0) (foldrWithKey (\k x xs -> (k,x):xs) [] t) in neg ++ pos
+--     QuickCheck indicates that these are equivalent, and really, if foldrWithKey doesn't fold negative
+--     to positive, then that's a problem with foldrWithKey, not with toAscList...
 
 -- | /O(n*min(n,W))/. Create a map from a list of key\/value pairs.
 --
hunk ./Data/IntMap.hs 1951
 
 -}
 
+{-# RULES
+       "foldr/Data.IntMap.elems" forall f z m . List.foldr f z (elems m) = foldr f z m;
+       "foldl/Data.IntMap.elems" forall f z m . List.foldl f z (elems m) = foldl f z m;
+       "foldr/Data.IntMap.keys" forall f z m . List.foldr f z (keys m) = foldrWithKey (\ k _ -> f k) z m;
+       "foldl/Data.IntMap.keys" forall f z m . List.foldl f z (keys m) = foldlWithKey (\ z k _ -> f z k) z m;
+       "foldr/Data.IntMap.toAscList" forall f z m . List.foldr f z (toAscList m) = foldrWithKey (curry f) z m;
+       "foldl/Data.IntMap.toAscList" forall f z m . List.foldl f z (toAscList m) = foldlWithKey (curry . f) z m;
+       #-}
}

Context:

[Tweak layout to work with the alternative layout rule
Ian Lynagh <igloo@earth.li>**20091129154519] 
[Disable building Data.Sequence (and dependents) for nhc98.
Malcolm.Wallace@cs.york.ac.uk**20091124025653
 There is some subtlety of polymorphically recursive datatypes and
 type-class defaulting that nhc98's type system barfs over.
] 
[Fix another instance of non-ghc breakage.
Malcolm.Wallace@cs.york.ac.uk**20091123092637] 
[Add #ifdef around ghc-only (<$) as member of Functor class.
Malcolm.Wallace@cs.york.ac.uk**20091123085155] 
[Fix broken code in non-GHC branch of an ifdef.
Malcolm.Wallace@cs.york.ac.uk**20091123084824] 
[doc bugfix: correct description of index argument
Ross Paterson <ross@soi.city.ac.uk>**20091028105532
 Ignore-this: 9790e7bf422c4cb528722c03cfa4fed9
 
 As noted by iaefai on the libraries list.
 
 Please merge to STABLE.
] 
[Bump version to 0.3.0.0
Ian Lynagh <igloo@earth.li>**20090920141847] 
[update base dependency
Ross Paterson <ross@soi.city.ac.uk>**20090916073125
 Ignore-this: ad382ffc6c6a18c15364e6c072f19edb
 
 The package uses mkNoRepType and Data.Functor, which were not in the
 stable branch of base-4.
] 
[add fast version of <$ for Seq
Ross Paterson <ross@soi.city.ac.uk>**20090916072812
 Ignore-this: 5a39a7d31d39760ed589790b1118d240
] 
[new methods for Data.Sequence (proposal #3271)
Ross Paterson <ross@soi.city.ac.uk>**20090915173324
 Ignore-this: cf17bedd709a6ab3448fd718dcdf62e7
 
 Adds a lot of new methods to Data.Sequence, mostly paralleling those
 in Data.List.  Several of these are significantly faster than versions
 implemented with the previous public interface.  In particular, replicate
 takes O(log n) time and space instead of O(n).
 (by Louis Wasserman)
] 
[Fix "Cabal check" warnings
Ian Lynagh <igloo@earth.li>**20090811215900] 
[TAG 2009-06-25
Ian Lynagh <igloo@earth.li>**20090625160202] 
Patch bundle hash:
2ea0d9855a86353654bdf26435a803d38b64164c