Overhaul INLINE and INLINABLE in Map and Set.
authorMilan Straka <fox@ucw.cz>
Fri, 25 Nov 2011 14:55:06 +0000 (15:55 +0100)
committerMilan Straka <fox@ucw.cz>
Mon, 28 Nov 2011 11:04:06 +0000 (12:04 +0100)
* Rename INLINEABLE -> INLINABLE
  Though both work, the latter is the preferred according the docs.

* Remove INLINABLE on methods not using type classes, as INLINABLE has
  real effect only on functions that use type classes (they get
  specialised in the call-site module).

  It also allows worker-wrapper transform on functions not marked
  INLINABLE (which surprisingly did not happen with INLINABLE).

* In GHC, INLINing the INLINABLE method as in
    update f = updateWithKey (\_ x -> f x)
    {-# INLINE update #-}
    updateWithKey = ...
    {-# INLINABLE updateWithKey #-}
  does not produce wanted result -- the updateWithKey does not get
  specialized in the call-site module.

  The solution is to mark both functions INLINABLE.

* Mark trivial functions as INLINE.

Data/Map/Base.hs
Data/Map/Strict.hs
Data/Set.hs

index 663469e..723003f 100644 (file)
@@ -307,9 +307,7 @@ instance (Data k, Data a, Ord k) => Data (Map k a) where
 null :: Map k a -> Bool
 null Tip      = True
 null (Bin {}) = False
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE null #-}
-#endif
+{-# INLINE null #-}
 
 -- | /O(1)/. The number of elements in the map.
 --
@@ -320,9 +318,7 @@ null (Bin {}) = False
 size :: Map k a -> Int
 size Tip              = 0
 size (Bin sz _ _ _ _) = sz
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE size #-}
-#endif
+{-# INLINE size #-}
 
 
 -- | /O(log n)/. Lookup the value at a key in the map.
@@ -381,7 +377,7 @@ lookupAssoc = go
             GT -> go k r
             EQ -> Just (kx,x)
 #if __GLASGOW_HASKELL__ >= 700
-{-# INLINEABLE lookupAssoc #-}
+{-# INLINABLE lookupAssoc #-}
 #else
 {-# INLINE lookupAssoc #-}
 #endif
@@ -396,7 +392,7 @@ member k m = case lookup k m of
     Nothing -> False
     Just _  -> True
 #if __GLASGOW_HASKELL__ >= 700
-{-# INLINEABLE member #-}
+{-# INLINABLE member #-}
 #else
 {-# INLINE member #-}
 #endif
@@ -408,7 +404,11 @@ member k m = case lookup k m of
 
 notMember :: Ord k => k -> Map k a -> Bool
 notMember k m = not $ member k m
+#if __GLASGOW_HASKELL__ >= 700
+{-# INLINABLE notMember #-}
+#else
 {-# INLINE notMember #-}
+#endif
 
 -- | /O(log n)/. Find the value at a key.
 -- Calls 'error' when the element can not be found.
@@ -450,6 +450,7 @@ findWithDefault def k m = case lookup k m of
 
 empty :: Map k a
 empty = Tip
+{-# INLINE empty #-}
 
 -- | /O(1)/. A map with a single element.
 --
@@ -458,6 +459,7 @@ empty = Tip
 
 singleton :: k -> a -> Map k a
 singleton k x = Bin 1 k x Tip Tip
+{-# INLINE singleton #-}
 
 {--------------------------------------------------------------------
   Insertion
@@ -482,7 +484,7 @@ insert = go
             GT -> balanceR ky y l (go kx x r)
             EQ -> Bin sz kx x l r
 #if __GLASGOW_HASKELL__ >= 700
-{-# INLINEABLE insert #-}
+{-# INLINABLE insert #-}
 #else
 {-# INLINE insert #-}
 #endif
@@ -499,7 +501,11 @@ insert = go
 
 insertWith :: Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
 insertWith f = insertWithKey (\_ x' y' -> f x' y')
+#if __GLASGOW_HASKELL__ >= 700
+{-# INLINABLE insertWith #-}
+#else
 {-# INLINE insertWith #-}
+#endif
 
 -- | /O(log n)/. Insert with a function, combining key, new value and old value.
 -- @'insertWithKey' f key value mp@
@@ -524,7 +530,7 @@ insertWithKey = go
             GT -> balanceR ky y l (go f kx x r)
             EQ -> Bin sy kx (f kx x y) l r
 #if __GLASGOW_HASKELL__ >= 700
-{-# INLINEABLE insertWithKey #-}
+{-# INLINABLE insertWithKey #-}
 #else
 {-# INLINE insertWithKey #-}
 #endif
@@ -559,7 +565,7 @@ insertLookupWithKey = go
                   in (found, balanceR ky y l r')
             EQ -> (Just y, Bin sy kx (f kx x y) l r)
 #if __GLASGOW_HASKELL__ >= 700
-{-# INLINEABLE insertLookupWithKey #-}
+{-# INLINABLE insertLookupWithKey #-}
 #else
 {-# INLINE insertLookupWithKey #-}
 #endif
@@ -586,7 +592,7 @@ delete = go
             GT -> balanceL kx x l (go k r)
             EQ -> glue l r
 #if __GLASGOW_HASKELL__ >= 700
-{-# INLINEABLE delete #-}
+{-# INLINABLE delete #-}
 #else
 {-# INLINE delete #-}
 #endif
@@ -601,7 +607,11 @@ delete = go
 
 adjust :: Ord k => (a -> a) -> k -> Map k a -> Map k a
 adjust f = adjustWithKey (\_ x -> f x)
+#if __GLASGOW_HASKELL__ >= 700
+{-# INLINABLE adjust #-}
+#else
 {-# INLINE adjust #-}
+#endif
 
 -- | /O(log n)/. Adjust a value at a specific key. When the key is not
 -- a member of the map, the original map is returned.
@@ -613,7 +623,11 @@ adjust f = adjustWithKey (\_ x -> f x)
 
 adjustWithKey :: Ord k => (k -> a -> a) -> k -> Map k a -> Map k a
 adjustWithKey f = updateWithKey (\k' x' -> Just (f k' x'))
+#if __GLASGOW_HASKELL__ >= 700
+{-# INLINABLE adjustWithKey #-}
+#else
 {-# INLINE adjustWithKey #-}
+#endif
 
 -- | /O(log n)/. The expression (@'update' f k map@) updates the value @x@
 -- at @k@ (if it is in the map). If (@f x@) is 'Nothing', the element is
@@ -626,7 +640,11 @@ adjustWithKey f = updateWithKey (\k' x' -> Just (f k' x'))
 
 update :: Ord k => (a -> Maybe a) -> k -> Map k a -> Map k a
 update f = updateWithKey (\_ x -> f x)
+#if __GLASGOW_HASKELL__ >= 700
+{-# INLINABLE update #-}
+#else
 {-# INLINE update #-}
+#endif
 
 -- | /O(log n)/. The expression (@'updateWithKey' f k map@) updates the
 -- value @x@ at @k@ (if it is in the map). If (@f k x@) is 'Nothing',
@@ -651,7 +669,7 @@ updateWithKey = go
                    Just x' -> Bin sx kx x' l r
                    Nothing -> glue l r
 #if __GLASGOW_HASKELL__ >= 700
-{-# INLINEABLE updateWithKey #-}
+{-# INLINABLE updateWithKey #-}
 #else
 {-# INLINE updateWithKey #-}
 #endif
@@ -678,7 +696,7 @@ updateLookupWithKey = go
                        Just x' -> (Just x',Bin sx kx x' l r)
                        Nothing -> (Just x,glue l r)
 #if __GLASGOW_HASKELL__ >= 700
-{-# INLINEABLE updateLookupWithKey #-}
+{-# INLINABLE updateLookupWithKey #-}
 #else
 {-# INLINE updateLookupWithKey #-}
 #endif
@@ -710,7 +728,7 @@ alter = go
                        Just x' -> Bin sx kx x' l r
                        Nothing -> glue l r
 #if __GLASGOW_HASKELL__ >= 700
-{-# INLINEABLE alter #-}
+{-# INLINABLE alter #-}
 #else
 {-# INLINE alter #-}
 #endif
@@ -776,9 +794,6 @@ elemAt i (Bin _ kx x l r)
       EQ -> (kx,x)
   where
     sizeL = size l
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE elemAt #-}
-#endif
 
 -- | /O(log n)/. Update the element at /index/. Calls 'error' when an
 -- invalid index is used.
@@ -804,9 +819,6 @@ updateAt f i t = i `seq`
               Nothing -> glue l r
       where
         sizeL = size l
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE updateAt #-}
-#endif
 
 -- | /O(log n)/. Delete the element at /index/.
 -- Defined as (@'deleteAt' i map = 'updateAt' (\k x -> 'Nothing') i map@).
@@ -819,9 +831,6 @@ updateAt f i t = i `seq`
 deleteAt :: Int -> Map k a -> Map k a
 deleteAt i m
   = updateAt (\_ _ -> Nothing) i m
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE deleteAt #-}
-#endif
 
 
 {--------------------------------------------------------------------
@@ -836,9 +845,6 @@ findMin :: Map k a -> (k,a)
 findMin (Bin _ kx x Tip _)  = (kx,x)
 findMin (Bin _ _  _ l _)    = findMin l
 findMin Tip                 = error "Map.findMin: empty map has no minimal element"
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE findMin #-}
-#endif
 
 -- | /O(log n)/. The maximal key of the map. Calls 'error' if the map is empty.
 --
@@ -849,9 +855,6 @@ findMax :: Map k a -> (k,a)
 findMax (Bin _ kx x _ Tip)  = (kx,x)
 findMax (Bin _ _  _ _ r)    = findMax r
 findMax Tip                 = error "Map.findMax: empty map has no maximal element"
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE findMax #-}
-#endif
 
 -- | /O(log n)/. Delete the minimal key. Returns an empty map if the map is empty.
 --
@@ -862,9 +865,6 @@ deleteMin :: Map k a -> Map k a
 deleteMin (Bin _ _  _ Tip r)  = r
 deleteMin (Bin _ kx x l r)    = balanceR kx x (deleteMin l) r
 deleteMin Tip                 = Tip
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE deleteMin #-}
-#endif
 
 -- | /O(log n)/. Delete the maximal key. Returns an empty map if the map is empty.
 --
@@ -875,9 +875,6 @@ deleteMax :: Map k a -> Map k a
 deleteMax (Bin _ _  _ l Tip)  = l
 deleteMax (Bin _ kx x l r)    = balanceL kx x l (deleteMax r)
 deleteMax Tip                 = Tip
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE deleteMax #-}
-#endif
 
 -- | /O(log n)/. Update the value at the minimal key.
 --
@@ -887,9 +884,6 @@ deleteMax Tip                 = Tip
 updateMin :: (a -> Maybe a) -> Map k a -> Map k a
 updateMin f m
   = updateMinWithKey (\_ x -> f x) m
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE updateMin #-}
-#endif
 
 -- | /O(log n)/. Update the value at the maximal key.
 --
@@ -899,9 +893,6 @@ updateMin f m
 updateMax :: (a -> Maybe a) -> Map k a -> Map k a
 updateMax f m
   = updateMaxWithKey (\_ x -> f x) m
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE updateMax #-}
-#endif
 
 
 -- | /O(log n)/. Update the value at the minimal key.
@@ -915,9 +906,6 @@ updateMinWithKey f (Bin sx kx x Tip r) = case f kx x of
                                            Nothing -> r
                                            Just x' -> Bin sx kx x' Tip r
 updateMinWithKey f (Bin _ kx x l r)    = balanceR kx x (updateMinWithKey f l) r
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE updateMinWithKey #-}
-#endif
 
 -- | /O(log n)/. Update the value at the maximal key.
 --
@@ -930,9 +918,6 @@ updateMaxWithKey f (Bin sx kx x l Tip) = case f kx x of
                                            Nothing -> l
                                            Just x' -> Bin sx kx x' l Tip
 updateMaxWithKey f (Bin _ kx x l r)    = balanceL kx x l (updateMaxWithKey f r)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE updateMaxWithKey #-}
-#endif
 
 -- | /O(log n)/. Retrieves the minimal (key,value) pair of the map, and
 -- the map stripped of that element, or 'Nothing' if passed an empty map.
@@ -943,9 +928,6 @@ updateMaxWithKey f (Bin _ kx x l r)    = balanceL kx x l (updateMaxWithKey f r)
 minViewWithKey :: Map k a -> Maybe ((k,a), Map k a)
 minViewWithKey Tip = Nothing
 minViewWithKey x   = Just (deleteFindMin x)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE minViewWithKey #-}
-#endif
 
 -- | /O(log n)/. Retrieves the maximal (key,value) pair of the map, and
 -- the map stripped of that element, or 'Nothing' if passed an empty map.
@@ -956,9 +938,6 @@ minViewWithKey x   = Just (deleteFindMin x)
 maxViewWithKey :: Map k a -> Maybe ((k,a), Map k a)
 maxViewWithKey Tip = Nothing
 maxViewWithKey x   = Just (deleteFindMax x)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE maxViewWithKey #-}
-#endif
 
 -- | /O(log n)/. Retrieves the value associated with minimal key of the
 -- map, and the map stripped of that element, or 'Nothing' if passed an
@@ -970,9 +949,6 @@ maxViewWithKey x   = Just (deleteFindMax x)
 minView :: Map k a -> Maybe (a, Map k a)
 minView Tip = Nothing
 minView x   = Just (first snd $ deleteFindMin x)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE minView #-}
-#endif
 
 -- | /O(log n)/. Retrieves the value associated with maximal key of the
 -- map, and the map stripped of that element, or 'Nothing' if passed an
@@ -983,9 +959,6 @@ minView x   = Just (first snd $ deleteFindMin x)
 maxView :: Map k a -> Maybe (a, Map k a)
 maxView Tip = Nothing
 maxView x   = Just (first snd $ deleteFindMax x)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE maxView #-}
-#endif
 
 -- Update the 1st component of a tuple (special case of Control.Arrow.first)
 first :: (a -> b) -> (a,c) -> (b,c)
@@ -1068,7 +1041,9 @@ hedgeUnionL blo bhi (Bin _ kx x l r) t2
 unionWith :: Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
 unionWith f m1 m2
   = unionWithKey (\_ x y -> f x y) m1 m2
-{-# INLINE unionWith #-}
+#if __GLASGOW_HASKELL__ >= 700
+{-# INLINABLE unionWith #-}
+#endif
 
 -- | /O(n+m)/.
 -- Union with a combining function. The implementation uses the efficient /hedge-union/ algorithm.
@@ -1155,7 +1130,9 @@ hedgeDiff blo bhi t (Bin _ kx _ l r)
 differenceWith :: Ord k => (a -> b -> Maybe a) -> Map k a -> Map k b -> Map k a
 differenceWith f m1 m2
   = differenceWithKey (\_ x y -> f x y) m1 m2
-{-# INLINE differenceWith #-}
+#if __GLASGOW_HASKELL__ >= 700
+{-# INLINABLE differenceWith #-}
+#endif
 
 -- | /O(n+m)/. Difference with a combining function. When two equal keys are
 -- encountered, the combining function is applied to the key and both values.
@@ -1215,7 +1192,9 @@ hedgeDiffWithKey f blo bhi t (Bin _ kx x l r)
 intersection :: Ord k => Map k a -> Map k b -> Map k a
 intersection m1 m2
   = intersectionWithKey (\_ x _ -> x) m1 m2
-{-# INLINE intersection #-}
+#if __GLASGOW_HASKELL__ >= 700
+{-# INLINABLE intersection #-}
+#endif
 
 -- | /O(n+m)/. Intersection with a combining function.
 --
@@ -1224,7 +1203,9 @@ intersection m1 m2
 intersectionWith :: Ord k => (a -> b -> c) -> Map k a -> Map k b -> Map k c
 intersectionWith f m1 m2
   = intersectionWithKey (\_ x y -> f x y) m1 m2
-{-# INLINE intersectionWith #-}
+#if __GLASGOW_HASKELL__ >= 700
+{-# INLINABLE intersectionWith #-}
+#endif
 
 -- | /O(n+m)/. Intersection with a combining function.
 -- Intersection is more efficient on (bigset \``intersection`\` smallset).
@@ -1349,25 +1330,19 @@ isProperSubmapOfBy f t1 t2
 -- > filter (> "x") (fromList [(5,"a"), (3,"b")]) == empty
 -- > filter (< "a") (fromList [(5,"a"), (3,"b")]) == empty
 
-filter :: Ord k => (a -> Bool) -> Map k a -> Map k a
+filter :: (a -> Bool) -> Map k a -> Map k a
 filter p m
   = filterWithKey (\_ x -> p x) m
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE filter #-}
-#endif
 
 -- | /O(n)/. Filter all keys\/values that satisfy the predicate.
 --
 -- > filterWithKey (\k _ -> k > 4) (fromList [(5,"a"), (3,"b")]) == singleton 5 "a"
 
-filterWithKey :: Ord k => (k -> a -> Bool) -> Map k a -> Map k a
+filterWithKey :: (k -> a -> Bool) -> Map k a -> Map k a
 filterWithKey _ Tip = Tip
 filterWithKey p (Bin _ kx x l r)
   | p kx x    = join kx x (filterWithKey p l) (filterWithKey p r)
   | otherwise = merge (filterWithKey p l) (filterWithKey p r)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE filterWithKey #-}
-#endif
 
 -- | /O(n)/. Partition the map according to a predicate. The first
 -- map contains all elements that satisfy the predicate, the second all
@@ -1377,12 +1352,9 @@ filterWithKey p (Bin _ kx x l r)
 -- > partition (< "x") (fromList [(5,"a"), (3,"b")]) == (fromList [(3, "b"), (5, "a")], empty)
 -- > partition (> "x") (fromList [(5,"a"), (3,"b")]) == (empty, fromList [(3, "b"), (5, "a")])
 
-partition :: Ord k => (a -> Bool) -> Map k a -> (Map k a,Map k a)
+partition :: (a -> Bool) -> Map k a -> (Map k a,Map k a)
 partition p m
   = partitionWithKey (\_ x -> p x) m
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE partition #-}
-#endif
 
 -- | /O(n)/. Partition the map according to a predicate. The first
 -- map contains all elements that satisfy the predicate, the second all
@@ -1392,7 +1364,7 @@ partition p m
 -- > partitionWithKey (\ k _ -> k < 7) (fromList [(5,"a"), (3,"b")]) == (fromList [(3, "b"), (5, "a")], empty)
 -- > partitionWithKey (\ k _ -> k > 7) (fromList [(5,"a"), (3,"b")]) == (empty, fromList [(3, "b"), (5, "a")])
 
-partitionWithKey :: Ord k => (k -> a -> Bool) -> Map k a -> (Map k a,Map k a)
+partitionWithKey :: (k -> a -> Bool) -> Map k a -> (Map k a,Map k a)
 partitionWithKey _ Tip = (Tip,Tip)
 partitionWithKey p (Bin _ kx x l r)
   | p kx x    = (join kx x l1 r1,merge l2 r2)
@@ -1400,34 +1372,25 @@ partitionWithKey p (Bin _ kx x l r)
   where
     (l1,l2) = partitionWithKey p l
     (r1,r2) = partitionWithKey p r
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE partitionWithKey #-}
-#endif
 
 -- | /O(n)/. Map values and collect the 'Just' results.
 --
 -- > let f x = if x == "a" then Just "new a" else Nothing
 -- > mapMaybe f (fromList [(5,"a"), (3,"b")]) == singleton 5 "new a"
 
-mapMaybe :: Ord k => (a -> Maybe b) -> Map k a -> Map k b
+mapMaybe :: (a -> Maybe b) -> Map k a -> Map k b
 mapMaybe f = mapMaybeWithKey (\_ x -> f x)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapMaybe #-}
-#endif
 
 -- | /O(n)/. Map keys\/values and collect the 'Just' results.
 --
 -- > let f k _ = if k < 5 then Just ("key : " ++ (show k)) else Nothing
 -- > mapMaybeWithKey f (fromList [(5,"a"), (3,"b")]) == singleton 3 "key : 3"
 
-mapMaybeWithKey :: Ord k => (k -> a -> Maybe b) -> Map k a -> Map k b
+mapMaybeWithKey :: (k -> a -> Maybe b) -> Map k a -> Map k b
 mapMaybeWithKey _ Tip = Tip
 mapMaybeWithKey f (Bin _ kx x l r) = case f kx x of
   Just y  -> join kx y (mapMaybeWithKey f l) (mapMaybeWithKey f r)
   Nothing -> merge (mapMaybeWithKey f l) (mapMaybeWithKey f r)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapMaybeWithKey #-}
-#endif
 
 -- | /O(n)/. Map values and separate the 'Left' and 'Right' results.
 --
@@ -1438,12 +1401,9 @@ mapMaybeWithKey f (Bin _ kx x l r) = case f kx x of
 -- > mapEither (\ a -> Right a) (fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")])
 -- >     == (empty, fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")])
 
-mapEither :: Ord k => (a -> Either b c) -> Map k a -> (Map k b, Map k c)
+mapEither :: (a -> Either b c) -> Map k a -> (Map k b, Map k c)
 mapEither f m
   = mapEitherWithKey (\_ x -> f x) m
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapEither #-}
-#endif
 
 -- | /O(n)/. Map keys\/values and separate the 'Left' and 'Right' results.
 --
@@ -1454,8 +1414,7 @@ mapEither f m
 -- > mapEitherWithKey (\_ a -> Right a) (fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")])
 -- >     == (empty, fromList [(1,"x"), (3,"b"), (5,"a"), (7,"z")])
 
-mapEitherWithKey :: Ord k =>
-  (k -> a -> Either b c) -> Map k a -> (Map k b, Map k c)
+mapEitherWithKey :: (k -> a -> Either b c) -> Map k a -> (Map k b, Map k c)
 mapEitherWithKey _ Tip = (Tip, Tip)
 mapEitherWithKey f (Bin _ kx x l r) = case f kx x of
   Left y  -> (join kx y l1 r1, merge l2 r2)
@@ -1463,9 +1422,6 @@ mapEitherWithKey f (Bin _ kx x l r) = case f kx x of
  where
     (l1,l2) = mapEitherWithKey f l
     (r1,r2) = mapEitherWithKey f r
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapEitherWithKey #-}
-#endif
 
 {--------------------------------------------------------------------
   Mapping
@@ -1476,9 +1432,6 @@ mapEitherWithKey f (Bin _ kx x l r) = case f kx x of
 
 map :: (a -> b) -> Map k a -> Map k b
 map f = mapWithKey (\_ x -> f x)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE map #-}
-#endif
 
 -- | /O(n)/. Map a function over all values in the map.
 --
@@ -1488,9 +1441,6 @@ map f = mapWithKey (\_ x -> f x)
 mapWithKey :: (k -> a -> b) -> Map k a -> Map k b
 mapWithKey _ Tip = Tip
 mapWithKey f (Bin sx kx x l r) = Bin sx kx (f kx x) (mapWithKey f l) (mapWithKey f r)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapWithKey #-}
-#endif
 
 -- | /O(n)/. The function 'mapAccum' threads an accumulating
 -- argument through the map in ascending order of keys.
@@ -1501,9 +1451,6 @@ mapWithKey f (Bin sx kx x l r) = Bin sx kx (f kx x) (mapWithKey f l) (mapWithKey
 mapAccum :: (a -> b -> (a,c)) -> a -> Map k b -> (a,Map k c)
 mapAccum f a m
   = mapAccumWithKey (\a' _ x' -> f a' x') a m
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapAccum #-}
-#endif
 
 -- | /O(n)/. The function 'mapAccumWithKey' threads an accumulating
 -- argument through the map in ascending order of keys.
@@ -1514,9 +1461,6 @@ mapAccum f a m
 mapAccumWithKey :: (a -> k -> b -> (a,c)) -> a -> Map k b -> (a,Map k c)
 mapAccumWithKey f a t
   = mapAccumL f a t
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapAccumWithKey #-}
-#endif
 
 -- | /O(n)/. The function 'mapAccumL' threads an accumulating
 -- argument through the map in ascending order of keys.
@@ -1527,9 +1471,6 @@ mapAccumL f a (Bin sx kx x l r) =
       (a2,x') = f a1 kx x
       (a3,r') = mapAccumL f a2 r
   in (a3,Bin sx kx x' l' r')
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapAccumL #-}
-#endif
 
 -- | /O(n)/. The function 'mapAccumR' threads an accumulating
 -- argument through the map in descending order of keys.
@@ -1540,9 +1481,6 @@ mapAccumRWithKey f a (Bin sx kx x l r) =
       (a2,x') = f a1 kx x
       (a3,l') = mapAccumRWithKey f a2 l
   in (a3,Bin sx kx x' l' r')
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapAccumRWithKey #-}
-#endif
 
 -- | /O(n*log n)/.
 -- @'mapKeys' f s@ is the map obtained by applying @f@ to each key of @s@.
@@ -1601,9 +1539,6 @@ mapKeysMonotonic :: (k1->k2) -> Map k1 a -> Map k2 a
 mapKeysMonotonic _ Tip = Tip
 mapKeysMonotonic f (Bin sz k x l r) =
     Bin sz (f k) x (mapKeysMonotonic f l) (mapKeysMonotonic f r)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapKeysMonotonic #-}
-#endif
 
 {--------------------------------------------------------------------
   Folds
@@ -1731,9 +1666,6 @@ foldlWithKey' f = go
 elems :: Map k a -> [a]
 elems m
   = [x | (_,x) <- assocs m]
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE elems #-}
-#endif
 
 -- | /O(n)/. Return all keys of the map in ascending order.
 --
@@ -1743,9 +1675,6 @@ elems m
 keys  :: Map k a -> [k]
 keys m
   = [k | (k,_) <- assocs m]
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE keys  #-}
-#endif
 
 -- | /O(n)/. The set of all keys of the map.
 --
@@ -1754,9 +1683,6 @@ keys m
 
 keysSet :: Map k a -> Set.Set k
 keysSet m = Set.fromDistinctAscList (keys m)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE keysSet #-}
-#endif
 
 -- | /O(n)/. An alias for 'toAscList'. Return all key\/value pairs in the map
 -- in ascending key order. Subject to list fusion.
@@ -1767,9 +1693,6 @@ keysSet m = Set.fromDistinctAscList (keys m)
 assocs :: Map k a -> [(k,a)]
 assocs m
   = toAscList m
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE assocs #-}
-#endif
 
 {--------------------------------------------------------------------
   Lists
@@ -1826,9 +1749,6 @@ fromListWithKey f xs
 
 toList :: Map k a -> [(k,a)]
 toList = toAscList
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE toList #-}
-#endif
 
 -- | /O(n)/. Convert the map to a list of key\/value pairs where the keys are
 -- in ascending order. Subject to list fusion.
@@ -1837,17 +1757,11 @@ toList = toAscList
 
 toAscList :: Map k a -> [(k,a)]
 toAscList = foldrWithKey (\k x xs -> (k,x):xs) []
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE toAscList #-}
-#endif
 
 -- | /O(n)/. Convert the map to a list of key\/value pairs where the keys
 -- are in descending order. Subject to list fusion.
 toDescList :: Map k a -> [(k,a)]
 toDescList t  = foldlWithKey (\xs k x -> (k,x):xs) [] t
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE toDescList #-}
-#endif
 
 #if __GLASGOW_HASKELL__
 -- List fusion for the above four functions
@@ -1947,9 +1861,6 @@ fromDistinctAscList xs
     createR n c l ((k,x):ys) = create (createB l k x c) n ys
     createR _ _ _ []         = error "fromDistinctAscList createR []"
     createB l k x c r zs     = c (bin k x l r) zs
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE fromDistinctAscList #-}
-#endif
 
 
 {--------------------------------------------------------------------
@@ -2125,16 +2036,13 @@ splitLookupWithKey k t = k `seq`
 {--------------------------------------------------------------------
   Join
 --------------------------------------------------------------------}
-join :: Ord k => k -> a -> Map k a -> Map k a -> Map k a
+join :: k -> a -> Map k a -> Map k a -> Map k a
 join kx x Tip r  = insertMin kx x r
 join kx x l Tip  = insertMax kx x l
 join kx x l@(Bin sizeL ky y ly ry) r@(Bin sizeR kz z lz rz)
   | delta*sizeL < sizeR  = balanceL kz z (join kx x l lz) rz
   | delta*sizeR < sizeL  = balanceR ky y ly (join kx x ry r)
   | otherwise            = bin kx x l r
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE join #-}
-#endif
 
 
 -- insertMin and insertMax don't perform potentially expensive comparisons.
@@ -2144,18 +2052,12 @@ insertMax kx x t
       Tip -> singleton kx x
       Bin _ ky y l r
           -> balanceR ky y l (insertMax kx x r)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE insertMax #-}
-#endif
 
 insertMin kx x t
   = case t of
       Tip -> singleton kx x
       Bin _ ky y l r
           -> balanceL ky y (insertMin kx x l) r
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE insertMin #-}
-#endif
 
 {--------------------------------------------------------------------
   [merge l r]: merges two trees.
@@ -2167,9 +2069,6 @@ merge l@(Bin sizeL kx x lx rx) r@(Bin sizeR ky y ly ry)
   | delta*sizeL < sizeR = balanceL ky y (merge l ly) ry
   | delta*sizeR < sizeL = balanceR kx x lx (merge rx r)
   | otherwise           = glue l r
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE merge #-}
-#endif
 
 {--------------------------------------------------------------------
   [glue l r]: glues two trees together.
@@ -2181,9 +2080,6 @@ glue l Tip = l
 glue l r
   | size l > size r = let ((km,m),l') = deleteFindMax l in balanceR km m l' r
   | otherwise       = let ((km,m),r') = deleteFindMin r in balanceL km m l r'
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE glue #-}
-#endif
 
 
 -- | /O(log n)/. Delete and find the minimal element.
@@ -2197,9 +2093,6 @@ deleteFindMin t
       Bin _ k x Tip r -> ((k,x),r)
       Bin _ k x l r   -> let (km,l') = deleteFindMin l in (km,balanceR k x l' r)
       Tip             -> (error "Map.deleteFindMin: can not return the minimal element of an empty map", Tip)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE deleteFindMin #-}
-#endif
 
 -- | /O(log n)/. Delete and find the maximal element.
 --
@@ -2212,9 +2105,6 @@ deleteFindMax t
       Bin _ k x l Tip -> ((k,x),l)
       Bin _ k x l r   -> let (km,r') = deleteFindMax r in (km,balanceL k x l r')
       Tip             -> (error "Map.deleteFindMax: can not return the maximal element of an empty map", Tip)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE deleteFindMax #-}
-#endif
 
 
 {--------------------------------------------------------------------
index 0103e73..07fef4f 100644 (file)
@@ -333,6 +333,7 @@ findWithDefault def k m = def `seq` case lookup k m of
 
 singleton :: k -> a -> Map k a
 singleton k x = x `seq` Bin 1 k x Tip Tip
+{-# INLINE singleton #-}
 
 {--------------------------------------------------------------------
   Insertion
@@ -357,7 +358,7 @@ insert = go
             GT -> balanceR ky y l (go kx x r)
             EQ -> Bin sz kx x l r
 #if __GLASGOW_HASKELL__ >= 700
-{-# INLINEABLE insert #-}
+{-# INLINABLE insert #-}
 #else
 {-# INLINE insert #-}
 #endif
@@ -374,7 +375,11 @@ insert = go
 
 insertWith :: Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
 insertWith f = insertWithKey (\_ x' y' -> f x' y')
+#if __GLASGOW_HASKELL__ >= 700
+{-# INLINABLE insertWith #-}
+#else
 {-# INLINE insertWith #-}
+#endif
 
 -- | /O(log n)/. Insert with a function, combining key, new value and old value.
 -- @'insertWithKey' f key value mp@
@@ -400,7 +405,7 @@ insertWithKey = go
             EQ -> let x' = f kx x y
                   in x' `seq` Bin sy kx x' l r
 #if __GLASGOW_HASKELL__ >= 700
-{-# INLINEABLE insertWithKey #-}
+{-# INLINABLE insertWithKey #-}
 #else
 {-# INLINE insertWithKey #-}
 #endif
@@ -436,7 +441,7 @@ insertLookupWithKey = go
             EQ -> let x' = f kx x y
                   in x' `seq` (Just y `strictPair` Bin sy kx x' l r)
 #if __GLASGOW_HASKELL__ >= 700
-{-# INLINEABLE insertLookupWithKey #-}
+{-# INLINABLE insertLookupWithKey #-}
 #else
 {-# INLINE insertLookupWithKey #-}
 #endif
@@ -456,7 +461,11 @@ insertLookupWithKey = go
 
 adjust :: Ord k => (a -> a) -> k -> Map k a -> Map k a
 adjust f = adjustWithKey (\_ x -> f x)
+#if __GLASGOW_HASKELL__ >= 700
+{-# INLINABLE adjust #-}
+#else
 {-# INLINE adjust #-}
+#endif
 
 -- | /O(log n)/. Adjust a value at a specific key. When the key is not
 -- a member of the map, the original map is returned.
@@ -468,7 +477,11 @@ adjust f = adjustWithKey (\_ x -> f x)
 
 adjustWithKey :: Ord k => (k -> a -> a) -> k -> Map k a -> Map k a
 adjustWithKey f = updateWithKey (\k' x' -> Just (f k' x'))
+#if __GLASGOW_HASKELL__ >= 700
+{-# INLINABLE adjustWithKey #-}
+#else
 {-# INLINE adjustWithKey #-}
+#endif
 
 -- | /O(log n)/. The expression (@'update' f k map@) updates the value @x@
 -- at @k@ (if it is in the map). If (@f x@) is 'Nothing', the element is
@@ -481,7 +494,11 @@ adjustWithKey f = updateWithKey (\k' x' -> Just (f k' x'))
 
 update :: Ord k => (a -> Maybe a) -> k -> Map k a -> Map k a
 update f = updateWithKey (\_ x -> f x)
+#if __GLASGOW_HASKELL__ >= 700
+{-# INLINABLE update #-}
+#else
 {-# INLINE update #-}
+#endif
 
 -- | /O(log n)/. The expression (@'updateWithKey' f k map@) updates the
 -- value @x@ at @k@ (if it is in the map). If (@f k x@) is 'Nothing',
@@ -506,7 +523,7 @@ updateWithKey = go
                    Just x' -> x' `seq` Bin sx kx x' l r
                    Nothing -> glue l r
 #if __GLASGOW_HASKELL__ >= 700
-{-# INLINEABLE updateWithKey #-}
+{-# INLINABLE updateWithKey #-}
 #else
 {-# INLINE updateWithKey #-}
 #endif
@@ -535,7 +552,7 @@ updateLookupWithKey = go
                        Just x' -> x' `seq` (Just x' `strictPair` Bin sx kx x' l r)
                        Nothing -> (Just x,glue l r)
 #if __GLASGOW_HASKELL__ >= 700
-{-# INLINEABLE updateLookupWithKey #-}
+{-# INLINABLE updateLookupWithKey #-}
 #else
 {-# INLINE updateLookupWithKey #-}
 #endif
@@ -567,7 +584,7 @@ alter = go
                        Just x' -> x' `seq` Bin sx kx x' l r
                        Nothing -> glue l r
 #if __GLASGOW_HASKELL__ >= 700
-{-# INLINEABLE alter #-}
+{-# INLINABLE alter #-}
 #else
 {-# INLINE alter #-}
 #endif
@@ -600,9 +617,6 @@ updateAt f i t = i `seq`
               Nothing -> glue l r
       where
         sizeL = size l
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE updateAt #-}
-#endif
 
 {--------------------------------------------------------------------
   Minimal, Maximal
@@ -616,9 +630,6 @@ updateAt f i t = i `seq`
 updateMin :: (a -> Maybe a) -> Map k a -> Map k a
 updateMin f m
   = updateMinWithKey (\_ x -> f x) m
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE updateMin #-}
-#endif
 
 -- | /O(log n)/. Update the value at the maximal key.
 --
@@ -628,9 +639,6 @@ updateMin f m
 updateMax :: (a -> Maybe a) -> Map k a -> Map k a
 updateMax f m
   = updateMaxWithKey (\_ x -> f x) m
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE updateMax #-}
-#endif
 
 
 -- | /O(log n)/. Update the value at the minimal key.
@@ -644,9 +652,6 @@ updateMinWithKey f (Bin sx kx x Tip r) = case f kx x of
                                            Nothing -> r
                                            Just x' -> x' `seq` Bin sx kx x' Tip r
 updateMinWithKey f (Bin _ kx x l r)    = balanceR kx x (updateMinWithKey f l) r
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE updateMinWithKey #-}
-#endif
 
 -- | /O(log n)/. Update the value at the maximal key.
 --
@@ -659,9 +664,6 @@ updateMaxWithKey f (Bin sx kx x l Tip) = case f kx x of
                                            Nothing -> l
                                            Just x' -> x' `seq` Bin sx kx x' l Tip
 updateMaxWithKey f (Bin _ kx x l r)    = balanceL kx x l (updateMaxWithKey f r)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE updateMaxWithKey #-}
-#endif
 
 {--------------------------------------------------------------------
   Union.
@@ -690,7 +692,9 @@ unionsWith f ts
 unionWith :: Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
 unionWith f m1 m2
   = unionWithKey (\_ x y -> f x y) m1 m2
-{-# INLINE unionWith #-}
+#if __GLASGOW_HASKELL__ >= 700
+{-# INLINABLE unionWith #-}
+#endif
 
 -- | /O(n+m)/.
 -- Union with a combining function. The implementation uses the efficient /hedge-union/ algorithm.
@@ -748,7 +752,9 @@ hedgeUnionWithKey f blo bhi (Bin _ kx x l r) t2
 differenceWith :: Ord k => (a -> b -> Maybe a) -> Map k a -> Map k b -> Map k a
 differenceWith f m1 m2
   = differenceWithKey (\_ x y -> f x y) m1 m2
-{-# INLINE differenceWith #-}
+#if __GLASGOW_HASKELL__ >= 700
+{-# INLINABLE differenceWith #-}
+#endif
 
 -- | /O(n+m)/. Difference with a combining function. When two equal keys are
 -- encountered, the combining function is applied to the key and both values.
@@ -805,7 +811,9 @@ hedgeDiffWithKey f blo bhi t (Bin _ kx x l r)
 intersectionWith :: Ord k => (a -> b -> c) -> Map k a -> Map k b -> Map k c
 intersectionWith f m1 m2
   = intersectionWithKey (\_ x y -> f x y) m1 m2
-{-# INLINE intersectionWith #-}
+#if __GLASGOW_HASKELL__ >= 700
+{-# INLINABLE intersectionWith #-}
+#endif
 
 -- | /O(n+m)/. Intersection with a combining function.
 -- Intersection is more efficient on (bigset \``intersection`\` smallset).
@@ -844,25 +852,19 @@ intersectionWithKey f t1@(Bin s1 k1 x1 l1 r1) t2@(Bin s2 k2 x2 l2 r2) =
 -- > let f x = if x == "a" then Just "new a" else Nothing
 -- > mapMaybe f (fromList [(5,"a"), (3,"b")]) == singleton 5 "new a"
 
-mapMaybe :: Ord k => (a -> Maybe b) -> Map k a -> Map k b
+mapMaybe :: (a -> Maybe b) -> Map k a -> Map k b
 mapMaybe f = mapMaybeWithKey (\_ x -> f x)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapMaybe #-}
-#endif
 
 -- | /O(n)/. Map keys\/values and collect the 'Just' results.
 --
 -- > let f k _ = if k < 5 then Just ("key : " ++ (show k)) else Nothing
 -- > mapMaybeWithKey f (fromList [(5,"a"), (3,"b")]) == singleton 3 "key : 3"
 
-mapMaybeWithKey :: Ord k => (k -> a -> Maybe b) -> Map k a -> Map k b
+mapMaybeWithKey :: (k -> a -> Maybe b) -> Map k a -> Map k b
 mapMaybeWithKey _ Tip = Tip
 mapMaybeWithKey f (Bin _ kx x l r) = case f kx x of
   Just y  -> y `seq` join kx y (mapMaybeWithKey f l) (mapMaybeWithKey f r)
   Nothing -> merge (mapMaybeWithKey f l) (mapMaybeWithKey f r)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapMaybeWithKey #-}
-#endif
 
 -- | /O(n)/. Map values and separate the 'Left' and 'Right' results.
 --
@@ -873,12 +875,9 @@ mapMaybeWithKey f (Bin _ kx x l r) = case f kx x of
 -- > mapEither (\ a -> Right a) (fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")])
 -- >     == (empty, fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")])
 
-mapEither :: Ord k => (a -> Either b c) -> Map k a -> (Map k b, Map k c)
+mapEither :: (a -> Either b c) -> Map k a -> (Map k b, Map k c)
 mapEither f m
   = mapEitherWithKey (\_ x -> f x) m
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapEither #-}
-#endif
 
 -- | /O(n)/. Map keys\/values and separate the 'Left' and 'Right' results.
 --
@@ -889,8 +888,7 @@ mapEither f m
 -- > mapEitherWithKey (\_ a -> Right a) (fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")])
 -- >     == (empty, fromList [(1,"x"), (3,"b"), (5,"a"), (7,"z")])
 
-mapEitherWithKey :: Ord k =>
-  (k -> a -> Either b c) -> Map k a -> (Map k b, Map k c)
+mapEitherWithKey :: (k -> a -> Either b c) -> Map k a -> (Map k b, Map k c)
 mapEitherWithKey _ Tip = (Tip, Tip)
 mapEitherWithKey f (Bin _ kx x l r) = case f kx x of
   Left y  -> y `seq` (join kx y l1 r1 `strictPair` merge l2 r2)
@@ -898,9 +896,6 @@ mapEitherWithKey f (Bin _ kx x l r) = case f kx x of
  where
     (l1,l2) = mapEitherWithKey f l
     (r1,r2) = mapEitherWithKey f r
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapEitherWithKey #-}
-#endif
 
 {--------------------------------------------------------------------
   Mapping
@@ -911,9 +906,6 @@ mapEitherWithKey f (Bin _ kx x l r) = case f kx x of
 
 map :: (a -> b) -> Map k a -> Map k b
 map f = mapWithKey (\_ x -> f x)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE map #-}
-#endif
 
 -- | /O(n)/. Map a function over all values in the map.
 --
@@ -924,9 +916,6 @@ mapWithKey :: (k -> a -> b) -> Map k a -> Map k b
 mapWithKey _ Tip = Tip
 mapWithKey f (Bin sx kx x l r) = let x' = f kx x
                                  in x' `seq` Bin sx kx x' (mapWithKey f l) (mapWithKey f r)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapWithKey #-}
-#endif
 
 -- | /O(n)/. The function 'mapAccum' threads an accumulating
 -- argument through the map in ascending order of keys.
@@ -937,9 +926,6 @@ mapWithKey f (Bin sx kx x l r) = let x' = f kx x
 mapAccum :: (a -> b -> (a,c)) -> a -> Map k b -> (a,Map k c)
 mapAccum f a m
   = mapAccumWithKey (\a' _ x' -> f a' x') a m
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapAccum #-}
-#endif
 
 -- | /O(n)/. The function 'mapAccumWithKey' threads an accumulating
 -- argument through the map in ascending order of keys.
@@ -950,9 +936,6 @@ mapAccum f a m
 mapAccumWithKey :: (a -> k -> b -> (a,c)) -> a -> Map k b -> (a,Map k c)
 mapAccumWithKey f a t
   = mapAccumL f a t
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapAccumWithKey #-}
-#endif
 
 -- | /O(n)/. The function 'mapAccumL' threads an accumulating
 -- argument through the map in ascending order of keys.
@@ -963,9 +946,6 @@ mapAccumL f a (Bin sx kx x l r) =
       (a2,x') = f a1 kx x
       (a3,r') = mapAccumL f a2 r
   in x' `seq` (a3,Bin sx kx x' l' r')
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapAccumL #-}
-#endif
 
 -- | /O(n)/. The function 'mapAccumR' threads an accumulating
 -- argument through the map in descending order of keys.
@@ -976,9 +956,6 @@ mapAccumRWithKey f a (Bin sx kx x l r) =
       (a2,x') = f a1 kx x
       (a3,l') = mapAccumRWithKey f a2 l
   in x' `seq` (a3,Bin sx kx x' l' r')
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapAccumRWithKey #-}
-#endif
 
 -- | /O(n*log n)/.
 -- @'mapKeys' f s@ is the map obtained by applying @f@ to each key of @s@.
@@ -1038,9 +1015,6 @@ mapKeysMonotonic _ Tip = Tip
 mapKeysMonotonic f (Bin sz k x l r) =
     let k' = f k
     in k' `seq` Bin sz k' x (mapKeysMonotonic f l) (mapKeysMonotonic f r)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapKeysMonotonic #-}
-#endif
 
 {--------------------------------------------------------------------
   Lists
@@ -1181,6 +1155,3 @@ fromDistinctAscList xs
     createR n c l ((k,x):ys) = x `seq` create (createB l k x c) n ys
     createR _ _ _ []         = error "fromDistinctAscList createR []"
     createB l k x c r zs     = x `seq` c (bin k x l r) zs
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE fromDistinctAscList #-}
-#endif
index 17f4d8f..fda120d 100644 (file)
@@ -232,17 +232,13 @@ instance (Data a, Ord a) => Data (Set a) where
 null :: Set a -> Bool
 null Tip      = True
 null (Bin {}) = False
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE null #-}
-#endif
+{-# INLINE null #-}
 
 -- | /O(1)/. The number of elements in the set.
 size :: Set a -> Int
 size Tip = 0
 size (Bin sz _ _ _) = sz
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE size #-}
-#endif
+{-# INLINE size #-}
 
 -- | /O(log n)/. Is the element in the set?
 member :: Ord a => a -> Set a -> Bool
@@ -263,7 +259,11 @@ member = go
 -- | /O(log n)/. Is the element not in the set?
 notMember :: Ord a => a -> Set a -> Bool
 notMember a t = not $ member a t
+#if __GLASGOW_HASKELL__ >= 700
+{-# INLINABLE notMember #-}
+#else
 {-# INLINE notMember #-}
+#endif
 
 {--------------------------------------------------------------------
   Construction
@@ -271,10 +271,12 @@ notMember a t = not $ member a t
 -- | /O(1)/. The empty set.
 empty  :: Set a
 empty = Tip
+{-# INLINE empty #-}
 
 -- | /O(1)/. Create a singleton set.
 singleton :: a -> Set a
 singleton x = Bin 1 x Tip Tip
+{-# INLINE singleton #-}
 
 {--------------------------------------------------------------------
   Insertion, Deletion
@@ -292,7 +294,7 @@ insert = go
         GT -> balanceR y l (go x r)
         EQ -> Bin sz x l r
 #if __GLASGOW_HASKELL__ >= 700
-{-# INLINEABLE insert #-}
+{-# INLINABLE insert #-}
 #else
 {-# INLINE insert #-}
 #endif
@@ -309,7 +311,7 @@ insertR = go
         GT -> balanceR y l (go x r)
         EQ -> t
 #if __GLASGOW_HASKELL__ >= 700
-{-# INLINEABLE insertR #-}
+{-# INLINABLE insertR #-}
 #else
 {-# INLINE insertR #-}
 #endif
@@ -325,7 +327,7 @@ delete = go
         GT -> balanceL y l (go x r)
         EQ -> glue l r
 #if __GLASGOW_HASKELL__ >= 700
-{-# INLINEABLE delete #-}
+{-# INLINABLE delete #-}
 #else
 {-# INLINE delete #-}
 #endif
@@ -371,36 +373,24 @@ findMin :: Set a -> a
 findMin (Bin _ x Tip _) = x
 findMin (Bin _ _ l _)   = findMin l
 findMin Tip             = error "Set.findMin: empty set has no minimal element"
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE findMin #-}
-#endif
 
 -- | /O(log n)/. The maximal element of a set.
 findMax :: Set a -> a
 findMax (Bin _ x _ Tip)  = x
 findMax (Bin _ _ _ r)    = findMax r
 findMax Tip              = error "Set.findMax: empty set has no maximal element"
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE findMax #-}
-#endif
 
 -- | /O(log n)/. Delete the minimal element.
 deleteMin :: Set a -> Set a
 deleteMin (Bin _ _ Tip r) = r
 deleteMin (Bin _ x l r)   = balanceR x (deleteMin l) r
 deleteMin Tip             = Tip
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE deleteMin #-}
-#endif
 
 -- | /O(log n)/. Delete the maximal element.
 deleteMax :: Set a -> Set a
 deleteMax (Bin _ _ l Tip) = l
 deleteMax (Bin _ x l r)   = balanceL x l (deleteMax r)
 deleteMax Tip             = Tip
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE deleteMax #-}
-#endif
 
 {--------------------------------------------------------------------
   Union.
@@ -507,27 +497,21 @@ intersection t1@(Bin s1 x1 l1 r1) t2@(Bin s2 x2 l2 r2) =
   Filter and partition
 --------------------------------------------------------------------}
 -- | /O(n)/. Filter all elements that satisfy the predicate.
-filter :: Ord a => (a -> Bool) -> Set a -> Set a
+filter :: (a -> Bool) -> Set a -> Set a
 filter _ Tip = Tip
 filter p (Bin _ x l r)
     | p x       = join x (filter p l) (filter p r)
     | otherwise = merge (filter p l) (filter p r)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE filter #-}
-#endif
 
 -- | /O(n)/. Partition the set into two sets, one with all elements that satisfy
 -- the predicate and one with all elements that don't satisfy the predicate.
 -- See also 'split'.
-partition :: Ord a => (a -> Bool) -> Set a -> (Set a,Set a)
+partition :: (a -> Bool) -> Set a -> (Set a,Set a)
 partition _ Tip = (Tip, Tip)
 partition p (Bin _ x l r) = case (partition p l, partition p r) of
   ((l1, l2), (r1, r2))
     | p x       -> (join x l1 r1, merge l2 r2)
     | otherwise -> (merge l1 r1, join x l2 r2)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE partition #-}
-#endif
 
 {----------------------------------------------------------------------
   Map
@@ -558,9 +542,6 @@ map f = fromList . List.map f . toList
 mapMonotonic :: (a->b) -> Set a -> Set b
 mapMonotonic _ Tip = Tip
 mapMonotonic f (Bin sz x l r) = Bin sz (f x) (mapMonotonic f l) (mapMonotonic f r)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE mapMonotonic #-}
-#endif
 
 {--------------------------------------------------------------------
   Fold
@@ -629,9 +610,6 @@ foldl' f = go
 -- Subject to list fusion.
 elems :: Set a -> [a]
 elems = toAscList
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE elems #-}
-#endif
 
 {--------------------------------------------------------------------
   Lists
@@ -639,16 +617,10 @@ elems = toAscList
 -- | /O(n)/. Convert the set to a list of elements. Subject to list fusion.
 toList :: Set a -> [a]
 toList = toAscList
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE toList #-}
-#endif
 
 -- | /O(n)/. Convert the set to an ascending list of elements. Subject to list fusion.
 toAscList :: Set a -> [a]
 toAscList = foldr (:) []
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE toAscList #-}
-#endif
 
 #if __GLASGOW_HASKELL__
 -- List fusion for the above three functions
@@ -714,9 +686,6 @@ fromDistinctAscList xs
     createR n c l (x:ys) = create (createB l x c) n ys
     createR _ _ _ []     = error "fromDistinctAscList createR []"
     createB l x c r zs   = c (bin x l r) zs
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE fromDistinctAscList #-}
-#endif
 
 {--------------------------------------------------------------------
   Eq converts the set to a list. In a lazy setting, this
@@ -917,9 +886,6 @@ join x l@(Bin sizeL y ly ry) r@(Bin sizeR z lz rz)
   | delta*sizeL < sizeR  = balanceL z (join x l lz) rz
   | delta*sizeR < sizeL  = balanceR y ly (join x ry r)
   | otherwise            = bin x l r
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE join #-}
-#endif
 
 
 -- insertMin and insertMax don't perform potentially expensive comparisons.
@@ -929,18 +895,12 @@ insertMax x t
       Tip -> singleton x
       Bin _ y l r
           -> balanceR y l (insertMax x r)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE insertMax #-}
-#endif
 
 insertMin x t
   = case t of
       Tip -> singleton x
       Bin _ y l r
           -> balanceL y (insertMin x l) r
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE insertMin #-}
-#endif
 
 {--------------------------------------------------------------------
   [merge l r]: merges two trees.
@@ -952,9 +912,6 @@ merge l@(Bin sizeL x lx rx) r@(Bin sizeR y ly ry)
   | delta*sizeL < sizeR = balanceL y (merge l ly) ry
   | delta*sizeR < sizeL = balanceR x lx (merge rx r)
   | otherwise           = glue l r
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE merge #-}
-#endif
 
 {--------------------------------------------------------------------
   [glue l r]: glues two trees together.
@@ -966,10 +923,6 @@ glue l Tip = l
 glue l r
   | size l > size r = let (m,l') = deleteFindMax l in balanceR m l' r
   | otherwise       = let (m,r') = deleteFindMin r in balanceL m l r'
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE glue #-}
-#endif
-
 
 -- | /O(log n)/. Delete and find the minimal element.
 --
@@ -981,9 +934,6 @@ deleteFindMin t
       Bin _ x Tip r -> (x,r)
       Bin _ x l r   -> let (xm,l') = deleteFindMin l in (xm,balanceR x l' r)
       Tip           -> (error "Set.deleteFindMin: can not return the minimal element of an empty set", Tip)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE deleteFindMin #-}
-#endif
 
 -- | /O(log n)/. Delete and find the maximal element.
 --
@@ -994,27 +944,18 @@ deleteFindMax t
       Bin _ x l Tip -> (x,l)
       Bin _ x l r   -> let (xm,r') = deleteFindMax r in (xm,balanceL x l r')
       Tip           -> (error "Set.deleteFindMax: can not return the maximal element of an empty set", Tip)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE deleteFindMax #-}
-#endif
 
 -- | /O(log n)/. Retrieves the minimal key of the set, and the set
 -- stripped of that element, or 'Nothing' if passed an empty set.
 minView :: Set a -> Maybe (a, Set a)
 minView Tip = Nothing
 minView x = Just (deleteFindMin x)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE minView #-}
-#endif
 
 -- | /O(log n)/. Retrieves the maximal key of the set, and the set
 -- stripped of that element, or 'Nothing' if passed an empty set.
 maxView :: Set a -> Maybe (a, Set a)
 maxView Tip = Nothing
 maxView x = Just (deleteFindMax x)
-#if __GLASGOW_HASKELL__ >= 700
-{-# INLINABLE maxView #-}
-#endif
 
 {--------------------------------------------------------------------
   [balance x l r] balances two trees with value x.