Mark fold explicitely as INLINE.
authorMilan Straka <fox@ucw.cz>
Sat, 16 Oct 2010 22:21:50 +0000 (22:21 +0000)
committerMilan Straka <fox@ucw.cz>
Sat, 16 Oct 2010 22:21:50 +0000 (22:21 +0000)
The INLINABLE does not work well in this case. Benchmarks
show memory savings (due to unboxing) and nearly no GHC binary
size increase.

Data/IntMap.hs
Data/IntSet.hs
Data/Map.hs
Data/Set.hs

index 9a2fb8c..bebca26 100644 (file)
@@ -1592,9 +1592,7 @@ splitLookup' k t
 
 fold :: (a -> b -> b) -> b -> IntMap a -> b
 fold f = foldWithKey (\_ x y -> f x y)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE fold #-}
-#endif
+{-# INLINE fold #-}
 
 -- | /O(n)/. Fold the keys and values in the map, such that
 -- @'foldWithKey' f z == 'Prelude.foldr' ('uncurry' f) z . 'toAscList'@.
@@ -1608,30 +1606,21 @@ fold f = foldWithKey (\_ x y -> f x y)
 foldWithKey :: (Key -> a -> b -> b) -> b -> IntMap a -> b
 foldWithKey
   = foldr
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE foldWithKey #-}
-#endif
+{-# INLINE foldWithKey #-}
 
 foldr :: (Key -> a -> b -> b) -> b -> IntMap a -> b
 foldr 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
+      Bin 0 m l r | m < 0 -> go f (go f z l) r  -- put negative numbers before.
+      Bin _ _ _ _ -> go f z t
       Tip k x     -> f k x z
       Nil         -> z
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE foldr #-}
-#endif
-
-foldr' :: (Key -> a -> b -> b) -> b -> IntMap a -> b
-foldr' = go
   where
     go f z (Bin _ _ l r) = go f (go f z r) l
     go f z (Tip k x)     = f k x z
     go f z Nil           = z
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE foldr' #-}
-#endif
+{-# INLINE foldr #-}
+
 
 {--------------------------------------------------------------------
   List variations 
index 6555e41..db84318 100644 (file)
@@ -751,24 +751,15 @@ map f = fromList . List.map f . toList
 fold :: (Int -> b -> b) -> b -> IntSet -> b
 fold 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
+      Bin 0 m l r | m < 0 -> go f (go f z l) r  -- put negative numbers before.
+      Bin _ _ _ _ -> go f z t
       Tip x       -> f x z
       Nil         -> z
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE fold #-}
-#endif
-
-foldr :: (Int -> b -> b) -> b -> IntSet -> b
-foldr f z t
-  = case t of
-      Bin _ _ l r -> foldr f (foldr f z r) l
-      Tip x       -> f x z
-      Nil         -> z
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE foldr #-}
-#endif
+  where
+    go f z (Bin _ _ l r) = go f (go f z r) l
+    go f z (Tip x)       = f x z
+    go f z Nil           = z
+{-# INLINE fold #-}
 
 {--------------------------------------------------------------------
   List variations 
index df622ff..9f81ade 100644 (file)
@@ -1657,9 +1657,7 @@ mapKeysMonotonic f (Bin sz k x l r) =
 -- > fold f 0 (fromList [(5,"a"), (3,"bbb")]) == 4
 fold :: (a -> b -> b) -> b -> Map k a -> b
 fold f = foldWithKey (\_ x' z' -> f x' z')
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE fold #-}
-#endif
+{-# INLINE fold #-}
 
 -- | /O(n)/. Fold the keys and values in the map, such that
 -- @'foldWithKey' f z == 'Prelude.foldr' ('uncurry' f) z . 'toAscList'@.
@@ -1675,9 +1673,7 @@ fold f = foldWithKey (\_ x' z' -> f x' z')
 foldWithKey :: (k -> a -> b -> b) -> b -> Map k a -> b
 foldWithKey = foldrWithKey
 {-# DEPRECATED foldWithKey "Use foldrWithKey instead" #-}
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE foldWithKey #-}
-#endif
+{-# INLINE foldWithKey #-}
 
 -- | /O(n)/. Post-order fold.  The function will be applied from the lowest
 -- value to the highest.
@@ -1686,9 +1682,7 @@ foldrWithKey = go
   where
     go f z Tip              = z
     go f z (Bin _ kx x l r) = go f (f kx x (go f z r)) l
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE foldrWithKey #-}
-#endif
+{-# INLINE foldrWithKey #-}
 
 -- | /O(n)/. Pre-order fold.  The function will be applied from the highest
 -- value to the lowest.
@@ -1697,9 +1691,7 @@ foldlWithKey = go
   where
     go f z Tip              = z
     go f z (Bin _ kx x l r) = go f (f (go f z l) kx x) r
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE foldlWithKey #-}
-#endif
+{-# INLINE foldlWithKey #-}
 
 {-
 -- | /O(n)/. A strict version of 'foldlWithKey'.
index 25c74dc..5ed227f 100644 (file)
@@ -537,9 +537,7 @@ mapMonotonic f = go
 -- | /O(n)/. Fold over the elements of a set in an unspecified order.
 fold :: (a -> b -> b) -> b -> Set a -> b
 fold = foldr
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE fold #-}
-#endif
+{-# INLINE fold #-}
 
 -- | /O(n)/. Post-order fold.
 foldr :: (a -> b -> b) -> b -> Set a -> b
@@ -547,9 +545,7 @@ foldr = go
   where
     go f z Tip           = z
     go f z (Bin _ x l r) = go f (f x (go f z r)) l
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE foldr #-}
-#endif
+{-# INLINE foldr #-}
 
 {--------------------------------------------------------------------
   List variations