New patches:

[increased folding options for Maps and Sets
sedillard@gmail.com**20081002170452] {
hunk ./Data/IntMap.hs 103
+            , foldr
+            , foldrWithKey
+            , foldl
+            , foldlWithKey
hunk ./Data/IntMap.hs 175
+import qualified Data.Foldable
hunk ./Data/IntMap.hs 260
+    foldr = Data.IntMap.foldr 
+    foldl = Data.IntMap.foldl 
hunk ./Data/IntMap.hs 1337
+
hunk ./Data/IntMap.hs 1342
+
+-- | /O(n)/. Fold the values in the map, such that
+-- @'foldr' f z == 'Prelude.foldr' f z . 'elems'@.
+
+foldr :: (a -> b -> b) -> b -> IntMap a -> b
+foldr f z t 
+  = foldrWithKey (const f) z t
+
+-- | /O(n)/. Fold the values in the map, such that
+-- @'foldl' f z == 'Prelude.foldl' f z . 'elems'@.
+
+foldl :: (a -> b -> a) -> a -> IntMap b -> a
+foldl f z t 
+  = foldlWithKey (\z _ x -> f z x) z t
+
hunk ./Data/IntMap.hs 1368
-  = foldr f z t
+  = foldrWithKey f z t
+
hunk ./Data/IntMap.hs 1371
-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'@.
+
+foldrWithKey :: (Key -> a -> b -> b) -> b -> IntMap a -> b
+foldrWithKey f z t
hunk ./Data/IntMap.hs 1377
-      Bin 0 m l r | m < 0 -> foldr' f (foldr' f z l) r  -- put negative numbers before.
-      Bin _ _ _ _ -> foldr' f z t
+      Bin 0 m l r | m < 0 -> go f (go f z l) r  -- negative keys first
+      Bin _ _ _ _ -> go f z t
hunk ./Data/IntMap.hs 1381
+  where
+    go :: (Key -> a -> b -> b) -> b -> IntMap a -> b
+    go f z t
+      = case t of
+          Bin _ _ l r -> go f (go f z r) l
+          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'@.
hunk ./Data/IntMap.hs 1392
-foldr' :: (Key -> a -> b -> b) -> b -> IntMap a -> b
-foldr' f z t
+foldlWithKey :: (a -> Key -> b -> a) -> a -> IntMap b -> a
+foldlWithKey f z t
hunk ./Data/IntMap.hs 1395
-      Bin _ _ l r -> foldr' f (foldr' f z r) l
-      Tip k x     -> f k x z
+      Bin 0 m l r | m < 0 -> go f (go f z r) l  -- negative keys first
+      Bin _ _ _ _ -> go f z t
+      Tip k x     -> f z k x
hunk ./Data/IntMap.hs 1399
-
+  where
+    go :: (a -> Key -> b -> a) -> a -> IntMap b -> a
+    go f z t
+      = case t of
+          Bin _ _ l r -> go f (go f z l) r
+          Tip k x     -> f z k x
+          Nil         -> z
hunk ./Data/IntMap.hs 1469
-    let (pos,neg) = span (\(k,_) -> k >=0) (foldr (\k x xs -> (k,x):xs) [] t) in neg ++ pos
+    let (pos,neg) = span (\(k,_) -> k >=0) (foldrWithKey (\k x xs -> (k,x):xs) [] t) in neg ++ pos
hunk ./Data/IntMap.hs 1905
-
hunk ./Data/IntSet.hs 86
+            , foldr
+            , foldl
hunk ./Data/IntSet.hs 97
+            , toDescList
hunk ./Data/IntSet.hs 630
+  
+-- | /O(n)/. Fold over the elements of a set in an unspecified order.
+fold :: (Int -> b -> b) -> b -> IntSet -> b
+fold f z t = foldr f z t
+  
hunk ./Data/IntSet.hs 639
-fold :: (Int -> b -> b) -> b -> IntSet -> b
-fold f z t
+foldr :: (Int -> b -> b) -> b -> IntSet -> b
+foldr f z t
hunk ./Data/IntSet.hs 642
-      Bin 0 m l r | m < 0 -> foldr f (foldr f z l) r  
+      Bin 0 m l r | m < 0 -> go f (go f z l) r  
hunk ./Data/IntSet.hs 644
-      Bin _ _ _ _ -> foldr f z t
+      Bin _ _ _ _ -> go f z t
hunk ./Data/IntSet.hs 647
+  where
+    go :: (Int -> b -> b) -> b -> IntSet -> b
+    go f z t
+      = case t of
+          Bin _ _ l r -> go f (go f z r) l
+          Tip x       -> f x z
+          Nil         -> z
hunk ./Data/IntSet.hs 655
-foldr :: (Int -> b -> b) -> b -> IntSet -> b
-foldr f z t
+
+-- | /O(n)/. Pre-order fold.
+foldl :: (b -> Int -> b) -> b -> IntSet -> b
+foldl f z t
hunk ./Data/IntSet.hs 660
-      Bin _ _ l r -> foldr f (foldr f z r) l
-      Tip x       -> f x z
+      Bin 0 m l r | m < 0 -> go f (go f z r) l  
+      -- put negative numbers before.
+      Bin _ _ _ _ -> go f z t
+      Tip x       -> f z x
hunk ./Data/IntSet.hs 665
+  where
+    go :: (b -> Int -> b) -> b -> IntSet -> b
+    go f z t
+      = case t of
+          Bin _ _ l r -> go f (go f z l) r
+          Tip x       -> f z x
+          Nil         -> z
hunk ./Data/IntSet.hs 693
+-- | /O(n)/. Convert the set to a descending list of elements.
+toDescList :: IntSet -> [Int]
+toDescList t 
+  = foldl (flip (:)) [] t
+
hunk ./Data/Map.hs 105
+            , foldr
+            , foldl
hunk ./Data/Map.hs 178
-import Prelude hiding (lookup,map,filter,null)
+import Prelude hiding (lookup,map,filter,null,foldl,foldr)
hunk ./Data/Map.hs 185
+import qualified Data.Foldable 
hunk ./Data/Map.hs 1451
+-- | /O(n)/. Fold the values in the map, such that
+-- @'foldr' f z == 'Prelude.foldr' f z . 'elems'@.
+
+foldr :: (a -> b -> b) -> b -> Map k a -> b
+foldr f z t 
+  = foldrWithKey (const f) z t
+
+-- | /O(n)/. Fold the values in the map, such that
+-- @'foldl' f z == 'Prelude.foldl' f z . 'elems'@.
+
+foldl :: (a -> b -> a) -> a -> Map k b -> a
+foldl f z t 
+  = foldlWithKey (\z _ x -> f z x) z t
+
+
+
hunk ./Data/Map.hs 1996
+  foldr = Data.Map.foldr
+  foldl = Data.Map.foldl
hunk ./Data/Set.hs 74
+            , foldr
+            , foldl
hunk ./Data/Set.hs 105
-import Prelude hiding (filter,foldr,null,map)
+import Prelude hiding (filter,foldr,foldl,null,map)
hunk ./Data/Set.hs 109
+import qualified Data.Foldable 
hunk ./Data/Set.hs 154
+    foldr = Data.Set.foldr
+    foldl = Data.Set.foldl
hunk ./Data/Set.hs 447
+-- | /O(n)/. Pre-order fold.
+foldl :: (a -> b -> a) -> a -> Set b -> a
+foldl _ z Tip           = z
+foldl f z (Bin _ x l r) = foldl f (f (foldl f z l) x) r
+
+
+
hunk ./Data/Set.hs 475
+-- | /O(n)/. Convert the set to a descending list of elements.
+toDescList :: Set a -> [a]
+toDescList t   
+  = foldl (flip (:)) [] t
}

Context:

[export Data.Map.toDescList, foldlWithKey, and foldrWithKey (trac ticket 2580)
qdunkan@gmail.com**20080922213200
 
 toDescList was previously implemented, but not exported.
 
 foldlWithKey was previously implemented, but not exported.  It can be used to
 implement toDescList.
 
 foldrWithKey is already exported as foldWithKey, but foldrWithKey is explicitly
 the mirror of foldlWithKey, and foldWithKey kept for compatibility.
] 
[Bump version number to 0.2.0.0
Ian Lynagh <igloo@earth.li>**20080920160016] 
[TAG 6.10 branch has been forked
Ian Lynagh <igloo@earth.li>**20080919123438] 
Patch bundle hash:
9b72f6db3b85b9ff0fb48beef4c5016eae3ab887