    {-# LANGUAGE CPP #-}
    {-# LANGUAGE BangPatterns #-}
    {-# LANGUAGE PatternGuards #-}

    {-# OPTIONS_GHC -fno-warn-incomplete-uni-patterns #-}

    #include "containers.h"

    -----------------------------------------------------------------------------
    -- |
    -- Module      :  Data.IntMap.Strict.Internal
    -- Copyright   :  (c) Daan Leijen 2002
    --                (c) Andriy Palamarchuk 2008
    -- License     :  BSD-style
    -- Maintainer  :  libraries@haskell.org
    -- Portability :  portable
    --
    --
    -- = Finite Int Maps (strict interface)
    --
    -- The @'IntMap' v@ type represents a finite map (sometimes called a dictionary)
    -- from key of type @Int@ to values of type @v@.
    --
    -- Each function in this module is careful to force values before installing
    -- them in an 'IntMap'. This is usually more efficient when laziness is not
    -- necessary. When laziness /is/ required, use the functions in
    -- "Data.IntMap.Lazy".
    --
    -- In particular, the functions in this module obey the following law:
    --
    --  - If all values stored in all maps in the arguments are in WHNF, then all
    --    values stored in all maps in the results will be in WHNF once those maps
    --    are evaluated.
    --
    -- For a walkthrough of the most commonly used functions see the
    -- <https://haskell-containers.readthedocs.io/en/latest/map.html maps introduction>.
    --
    -- This module is intended to be imported qualified, to avoid name clashes with
    -- Prelude functions:
    --
    -- > import Data.IntMap.Strict (IntMap)
    -- > import qualified Data.IntMap.Strict as IntMap
    --
    -- Note that the implementation is generally /left-biased/. Functions that take
    -- two maps as arguments and combine them, such as `union` and `intersection`,
    -- prefer the values in the first argument to those in the second.
    --
    --
    -- == Detailed performance information
    --
    -- The amortized running time is given for each operation, with \(n\) referring to
    -- the number of entries in the map and \(W\) referring to the number of bits in
    -- an 'Int' (32 or 64).
    --
    -- Benchmarks comparing "Data.IntMap.Strict" with other dictionary
    -- implementations can be found at https://github.com/haskell-perf/dictionaries.
    --
    --
    -- == Warning
    --
    -- The 'IntMap' type is shared between the lazy and strict modules, meaning that
    -- the same 'IntMap' value can be passed to functions in both modules. This
    -- means that the 'Functor', 'Traversable' and 'Data.Data.Data' instances are
    -- the same as for the "Data.IntMap.Lazy" module, so if they are used the
    -- resulting map may contain suspended values (thunks).
    --
    --
    -- == Implementation
    --
    -- The implementation is based on /big-endian patricia trees/.  This data
    -- structure performs especially well on binary operations like 'union' and
    -- 'intersection'. Additionally, benchmarks show that it is also (much) faster
    -- on insertions and deletions when compared to a generic size-balanced map
    -- implementation (see "Data.Map").
    --
    --    * Chris Okasaki and Andy Gill,  \"/Fast Mergeable Integer Maps/\",
    --      Workshop on ML, September 1998, pages 77-86,
    --      <http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.37.5452>
    --
    --    * D.R. Morrison, \"/PATRICIA -- Practical Algorithm To Retrieve Information Coded In Alphanumeric/\",
    --      Journal of the ACM, 15(4), October 1968, pages 514-534.
    --
    -----------------------------------------------------------------------------

    -- See the notes at the beginning of Data.IntMap.Internal.

    module Data.IntMap.Strict.Internal (
        -- * Map type
    #if !defined(TESTING)
        IntMap, Key          -- instance Eq,Show
    #else
        IntMap(..), Key          -- instance Eq,Show
    #endif

        -- * Construction
        , empty
        , singleton
        , fromSet

        -- ** From Unordered Lists
        , fromList
        , fromListWith
        , fromListWithKey

        -- ** From Ascending Lists
        , fromAscList
        , fromAscListWith
        , fromAscListWithKey
        , fromDistinctAscList

        -- * Insertion
        , insert
        , insertWith
        , insertWithKey
        , insertLookupWithKey

        -- * Deletion\/Update
        , delete
        , adjust
        , adjustWithKey
        , update
        , updateWithKey
        , updateLookupWithKey
        , alter
        , alterF

        -- * Query
        -- ** Lookup
        , lookup
        , (!?)
        , (!)
        , findWithDefault
        , member
        , notMember
        , lookupLT
        , lookupGT
        , lookupLE
        , lookupGE

        -- ** Size
        , null
        , size

        -- * Combine

        -- ** Union
        , union
        , unionWith
        , unionWithKey
        , unions
        , unionsWith

        -- ** Difference
        , difference
        , (\\)
        , differenceWith
        , differenceWithKey

        -- ** Intersection
        , intersection
        , intersectionWith
        , intersectionWithKey

        -- ** Disjoint
        , disjoint

        -- ** Compose
        , compose

        -- ** Universal combining function
        , mergeWithKey

        -- * Traversal
        -- ** Map
        , map
        , mapWithKey
        , traverseWithKey
        , traverseMaybeWithKey
        , mapAccum
        , mapAccumWithKey
        , mapAccumRWithKey
        , mapKeys
        , mapKeysWith
        , mapKeysMonotonic

        -- * Folds
        , foldr
        , foldl
        , foldrWithKey
        , foldlWithKey
        , foldMapWithKey

        -- ** Strict folds
        , foldr'
        , foldl'
        , foldrWithKey'
        , foldlWithKey'

        -- * Conversion
        , elems
        , keys
        , assocs
        , keysSet

        -- ** Lists
        , toList

    -- ** Ordered lists
        , toAscList
        , toDescList

        -- * Filter
        , filter
        , filterWithKey
        , restrictKeys
        , withoutKeys
        , partition
        , partitionWithKey

        , takeWhileAntitone
        , dropWhileAntitone
        , spanAntitone

        , mapMaybe
        , mapMaybeWithKey
        , mapEither
        , mapEitherWithKey

        , split
        , splitLookup
        , splitRoot

        -- * Submap
        , isSubmapOf, isSubmapOfBy
        , isProperSubmapOf, isProperSubmapOfBy

        -- * Min\/Max
        , lookupMin
        , lookupMax
        , findMin
        , findMax
        , deleteMin
        , deleteMax
        , deleteFindMin
        , deleteFindMax
        , updateMin
        , updateMax
        , updateMinWithKey
        , updateMaxWithKey
        , minView
        , maxView
        , minViewWithKey
        , maxViewWithKey

    #ifdef __GLASGOW_HASKELL__
        -- * Debugging
        , showTree
        , showTreeWith
    #endif
        ) where

    import Utils.Containers.Internal.Prelude hiding
      (lookup,map,filter,foldr,foldl,null)
    import Prelude ()

    import Data.Bits
    import qualified Data.IntMap.Internal as L
    import Data.IntMap.Internal
      ( IntMap (..)
      , Key
      , mask
      , branchMask
      , nomatch
      , zero
      , natFromInt
      , intFromNat
      , bin
      , binCheckLeft
      , binCheckRight
      , link
      , linkWithMask

      , (\\)
      , (!)
      , (!?)
      , empty
      , assocs
      , filter
      , filterWithKey
      , findMin
      , findMax
      , foldMapWithKey
      , foldr
      , foldl
      , foldr'
      , foldl'
      , foldlWithKey
      , foldrWithKey
      , foldlWithKey'
      , foldrWithKey'
      , keysSet
      , mergeWithKey'
      , compose
      , delete
      , deleteMin
      , deleteMax
      , deleteFindMax
      , deleteFindMin
      , difference
      , elems
      , intersection
      , disjoint
      , isProperSubmapOf
      , isProperSubmapOfBy
      , isSubmapOf
      , isSubmapOfBy
      , lookup
      , lookupLE
      , lookupGE
      , lookupLT
      , lookupGT
      , lookupMin
      , lookupMax
      , minView
      , maxView
      , minViewWithKey
      , maxViewWithKey
      , keys
      , mapKeys
      , mapKeysMonotonic
      , member
      , notMember
      , null
      , partition
      , partitionWithKey
      , takeWhileAntitone
      , dropWhileAntitone
      , spanAntitone
      , restrictKeys
      , size
      , split
      , splitLookup
      , splitRoot
      , toAscList
      , toDescList
      , toList
      , union
      , unions
      , withoutKeys
      )
    #ifdef __GLASGOW_HASKELL__
    import Data.IntMap.Internal.DeprecatedDebug (showTree, showTreeWith)
    #endif
    import qualified Data.IntSet.Internal as IntSet
    import Utils.Containers.Internal.BitUtil
    import Utils.Containers.Internal.StrictPair
    import qualified Data.Foldable as Foldable

    {--------------------------------------------------------------------
      Query
    --------------------------------------------------------------------}

    -- | \(O(\min(n,W))\). The expression @('findWithDefault' def k map)@
    -- returns the value at key @k@ or returns @def@ when the key is not an
    -- element of the map.
    --
    -- > findWithDefault 'x' 1 (fromList [(5,'a'), (3,'b')]) == 'x'
    -- > findWithDefault 'x' 5 (fromList [(5,'a'), (3,'b')]) == 'a'

    -- See IntMap.Internal.Note: Local 'go' functions and capturing]
    findWithDefault :: a -> Key -> IntMap a -> a
    findWithDefault :: forall a. a -> Key -> IntMap a -> a
    findWithDefault a
    def !Key
    k = IntMap a -> a
    go
      where
        go :: IntMap a -> a
    go (Bin Key
    p Key
    m IntMap a
    l IntMap a
    r) | Key -> Key -> Key -> Bool
    nomatch Key
    k Key
    p Key
    m = a
    def
                         | Key -> Key -> Bool
    zero Key
    k Key
    m  = IntMap a -> a
    go IntMap a
    l
                         | Bool
    otherwise = IntMap a -> a
    go IntMap a
    r
        go (Tip Key
    kx a
    x) | Key
    k Key -> Key -> Bool
    forall a. Eq a => a -> a -> Bool
    == Key
    kx   = a
    x
                      | Bool
    otherwise = a
    def
        go IntMap a
    Nil = a
    def

    {--------------------------------------------------------------------
      Construction
    --------------------------------------------------------------------}
    -- | \(O(1)\). A map of one element.
    --
    -- > singleton 1 'a'        == fromList [(1, 'a')]
    -- > size (singleton 1 'a') == 1

    singleton :: Key -> a -> IntMap a
    singleton :: forall a. Key -> a -> IntMap a
    singleton Key
    k !a
    x
      = Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    k a
    x
    {-# INLINE singleton #-}

    {--------------------------------------------------------------------
      Insert
    --------------------------------------------------------------------}
    -- | \(O(\min(n,W))\). Insert a new key\/value pair in the map.
    -- If the key is already present in the map, the associated value is
    -- replaced with the supplied value, i.e. 'insert' is equivalent to
    -- @'insertWith' 'const'@.
    --
    -- > insert 5 'x' (fromList [(5,'a'), (3,'b')]) == fromList [(3, 'b'), (5, 'x')]
    -- > insert 7 'x' (fromList [(5,'a'), (3,'b')]) == fromList [(3, 'b'), (5, 'a'), (7, 'x')]
    -- > insert 5 'x' empty                         == singleton 5 'x'

    insert :: Key -> a -> IntMap a -> IntMap a
    insert :: forall a. Key -> a -> IntMap a -> IntMap a
    insert !Key
    k !a
    x IntMap a
    t =
      case IntMap a
    t of
        Bin Key
    p Key
    m IntMap a
    l IntMap a
    r
          | Key -> Key -> Key -> Bool
    nomatch Key
    k Key
    p Key
    m -> Key -> IntMap a -> Key -> IntMap a -> IntMap a
    forall a. Key -> IntMap a -> Key -> IntMap a -> IntMap a
    link Key
    k (Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    k a
    x) Key
    p IntMap a
    t
          | Key -> Key -> Bool
    zero Key
    k Key
    m      -> Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin Key
    p Key
    m (Key -> a -> IntMap a -> IntMap a
    forall a. Key -> a -> IntMap a -> IntMap a
    insert Key
    k a
    x IntMap a
    l) IntMap a
    r
          | Bool
    otherwise     -> Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin Key
    p Key
    m IntMap a
    l (Key -> a -> IntMap a -> IntMap a
    forall a. Key -> a -> IntMap a -> IntMap a
    insert Key
    k a
    x IntMap a
    r)
        Tip Key
    ky a
    _
          | Key
    kKey -> Key -> Bool
    forall a. Eq a => a -> a -> Bool
    ==Key
    ky         -> Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    k a
    x
          | Bool
    otherwise     -> Key -> IntMap a -> Key -> IntMap a -> IntMap a
    forall a. Key -> IntMap a -> Key -> IntMap a -> IntMap a
    link Key
    k (Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    k a
    x) Key
    ky IntMap a
    t
        IntMap a
    Nil -> Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    k a
    x

    -- right-biased insertion, used by 'union'
    -- | \(O(\min(n,W))\). Insert with a combining function.
    -- @'insertWith' f key value mp@
    -- will insert the pair (key, value) into @mp@ if key does
    -- not exist in the map. If the key does exist, the function will
    -- insert @f new_value old_value@.
    --
    -- > insertWith (++) 5 "xxx" (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "xxxa")]
    -- > insertWith (++) 7 "xxx" (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "a"), (7, "xxx")]
    -- > insertWith (++) 5 "xxx" empty                         == singleton 5 "xxx"

    insertWith :: (a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
    insertWith :: forall a. (a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
    insertWith a -> a -> a
    f Key
    k a
    x IntMap a
    t
      = (Key -> a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
    forall a. (Key -> a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
    insertWithKey (\Key
    _ a
    x' a
    y' -> a -> a -> a
    f a
    x' a
    y') Key
    k a
    x IntMap a
    t

    -- | \(O(\min(n,W))\). Insert with a combining function.
    -- @'insertWithKey' f key value mp@
    -- will insert the pair (key, value) into @mp@ if key does
    -- not exist in the map. If the key does exist, the function will
    -- insert @f key new_value old_value@.
    --
    -- > let f key new_value old_value = (show key) ++ ":" ++ new_value ++ "|" ++ old_value
    -- > insertWithKey f 5 "xxx" (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "5:xxx|a")]
    -- > insertWithKey f 7 "xxx" (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "a"), (7, "xxx")]
    -- > insertWithKey f 5 "xxx" empty                         == singleton 5 "xxx"
    --
    -- If the key exists in the map, this function is lazy in @value@ but strict
    -- in the result of @f@.

    insertWithKey :: (Key -> a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
    insertWithKey :: forall a. (Key -> a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
    insertWithKey Key -> a -> a -> a
    f !Key
    k a
    x IntMap a
    t =
      case IntMap a
    t of
        Bin Key
    p Key
    m IntMap a
    l IntMap a
    r
          | Key -> Key -> Key -> Bool
    nomatch Key
    k Key
    p Key
    m -> Key -> IntMap a -> Key -> IntMap a -> IntMap a
    forall a. Key -> IntMap a -> Key -> IntMap a -> IntMap a
    link Key
    k (Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    singleton Key
    k a
    x) Key
    p IntMap a
    t
          | Key -> Key -> Bool
    zero Key
    k Key
    m      -> Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin Key
    p Key
    m ((Key -> a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
    forall a. (Key -> a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
    insertWithKey Key -> a -> a -> a
    f Key
    k a
    x IntMap a
    l) IntMap a
    r
          | Bool
    otherwise     -> Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin Key
    p Key
    m IntMap a
    l ((Key -> a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
    forall a. (Key -> a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
    insertWithKey Key -> a -> a -> a
    f Key
    k a
    x IntMap a
    r)
        Tip Key
    ky a
    y
          | Key
    kKey -> Key -> Bool
    forall a. Eq a => a -> a -> Bool
    ==Key
    ky         -> Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    k (a -> IntMap a) -> a -> IntMap a
    forall a b. (a -> b) -> a -> b
    $! Key -> a -> a -> a
    f Key
    k a
    x a
    y
          | Bool
    otherwise     -> Key -> IntMap a -> Key -> IntMap a -> IntMap a
    forall a. Key -> IntMap a -> Key -> IntMap a -> IntMap a
    link Key
    k (Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    singleton Key
    k a
    x) Key
    ky IntMap a
    t
        IntMap a
    Nil -> Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    singleton Key
    k a
    x

    -- | \(O(\min(n,W))\). The expression (@'insertLookupWithKey' f k x map@)
    -- is a pair where the first element is equal to (@'lookup' k map@)
    -- and the second element equal to (@'insertWithKey' f k x map@).
    --
    -- > let f key new_value old_value = (show key) ++ ":" ++ new_value ++ "|" ++ old_value
    -- > insertLookupWithKey f 5 "xxx" (fromList [(5,"a"), (3,"b")]) == (Just "a", fromList [(3, "b"), (5, "5:xxx|a")])
    -- > insertLookupWithKey f 7 "xxx" (fromList [(5,"a"), (3,"b")]) == (Nothing,  fromList [(3, "b"), (5, "a"), (7, "xxx")])
    -- > insertLookupWithKey f 5 "xxx" empty                         == (Nothing,  singleton 5 "xxx")
    --
    -- This is how to define @insertLookup@ using @insertLookupWithKey@:
    --
    -- > let insertLookup kx x t = insertLookupWithKey (\_ a _ -> a) kx x t
    -- > insertLookup 5 "x" (fromList [(5,"a"), (3,"b")]) == (Just "a", fromList [(3, "b"), (5, "x")])
    -- > insertLookup 7 "x" (fromList [(5,"a"), (3,"b")]) == (Nothing,  fromList [(3, "b"), (5, "a"), (7, "x")])

    insertLookupWithKey :: (Key -> a -> a -> a) -> Key -> a -> IntMap a -> (Maybe a, IntMap a)
    insertLookupWithKey :: forall a.
    (Key -> a -> a -> a) -> Key -> a -> IntMap a -> (Maybe a, IntMap a)
    insertLookupWithKey Key -> a -> a -> a
    f0 !Key
    k0 a
    x0 IntMap a
    t0 = StrictPair (Maybe a) (IntMap a) -> (Maybe a, IntMap a)
    forall a b. StrictPair a b -> (a, b)
    toPair (StrictPair (Maybe a) (IntMap a) -> (Maybe a, IntMap a))
    -> StrictPair (Maybe a) (IntMap a) -> (Maybe a, IntMap a)
    forall a b. (a -> b) -> a -> b
    $ (Key -> a -> a -> a)
    -> Key -> a -> IntMap a -> StrictPair (Maybe a) (IntMap a)
    forall {t}.
    (Key -> t -> t -> t)
    -> Key -> t -> IntMap t -> StrictPair (Maybe t) (IntMap t)
    go Key -> a -> a -> a
    f0 Key
    k0 a
    x0 IntMap a
    t0
      where
        go :: (Key -> t -> t -> t)
    -> Key -> t -> IntMap t -> StrictPair (Maybe t) (IntMap t)
    go Key -> t -> t -> t
    f Key
    k t
    x IntMap t
    t =
          case IntMap t
    t of
            Bin Key
    p Key
    m IntMap t
    l IntMap t
    r
              | Key -> Key -> Key -> Bool
    nomatch Key
    k Key
    p Key
    m -> Maybe t
    forall a. Maybe a
    Nothing Maybe t -> IntMap t -> StrictPair (Maybe t) (IntMap t)
    forall a b. a -> b -> StrictPair a b
    :*: Key -> IntMap t -> Key -> IntMap t -> IntMap t
    forall a. Key -> IntMap a -> Key -> IntMap a -> IntMap a
    link Key
    k (Key -> t -> IntMap t
    forall a. Key -> a -> IntMap a
    singleton Key
    k t
    x) Key
    p IntMap t
    t
              | Key -> Key -> Bool
    zero Key
    k Key
    m      -> let (Maybe t
    found :*: IntMap t
    l') = (Key -> t -> t -> t)
    -> Key -> t -> IntMap t -> StrictPair (Maybe t) (IntMap t)
    go Key -> t -> t -> t
    f Key
    k t
    x IntMap t
    l in (Maybe t
    found Maybe t -> IntMap t -> StrictPair (Maybe t) (IntMap t)
    forall a b. a -> b -> StrictPair a b
    :*: Key -> Key -> IntMap t -> IntMap t -> IntMap t
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin Key
    p Key
    m IntMap t
    l' IntMap t
    r)
              | Bool
    otherwise     -> let (Maybe t
    found :*: IntMap t
    r') = (Key -> t -> t -> t)
    -> Key -> t -> IntMap t -> StrictPair (Maybe t) (IntMap t)
    go Key -> t -> t -> t
    f Key
    k t
    x IntMap t
    r in (Maybe t
    found Maybe t -> IntMap t -> StrictPair (Maybe t) (IntMap t)
    forall a b. a -> b -> StrictPair a b
    :*: Key -> Key -> IntMap t -> IntMap t -> IntMap t
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin Key
    p Key
    m IntMap t
    l IntMap t
    r')
            Tip Key
    ky t
    y
              | Key
    kKey -> Key -> Bool
    forall a. Eq a => a -> a -> Bool
    ==Key
    ky         -> (t -> Maybe t
    forall a. a -> Maybe a
    Just t
    y Maybe t -> IntMap t -> StrictPair (Maybe t) (IntMap t)
    forall a b. a -> b -> StrictPair a b
    :*: (Key -> t -> IntMap t
    forall a. Key -> a -> IntMap a
    Tip Key
    k (t -> IntMap t) -> t -> IntMap t
    forall a b. (a -> b) -> a -> b
    $! Key -> t -> t -> t
    f Key
    k t
    x t
    y))
              | Bool
    otherwise     -> (Maybe t
    forall a. Maybe a
    Nothing Maybe t -> IntMap t -> StrictPair (Maybe t) (IntMap t)
    forall a b. a -> b -> StrictPair a b
    :*: Key -> IntMap t -> Key -> IntMap t -> IntMap t
    forall a. Key -> IntMap a -> Key -> IntMap a -> IntMap a
    link Key
    k (Key -> t -> IntMap t
    forall a. Key -> a -> IntMap a
    singleton Key
    k t
    x) Key
    ky IntMap t
    t)
            IntMap t
    Nil -> Maybe t
    forall a. Maybe a
    Nothing Maybe t -> IntMap t -> StrictPair (Maybe t) (IntMap t)
    forall a b. a -> b -> StrictPair a b
    :*: (Key -> t -> IntMap t
    forall a. Key -> a -> IntMap a
    singleton Key
    k t
    x)

    {--------------------------------------------------------------------
      Deletion
    --------------------------------------------------------------------}
    -- | \(O(\min(n,W))\). Adjust a value at a specific key. When the key is not
    -- a member of the map, the original map is returned.
    --
    -- > adjust ("new " ++) 5 (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "new a")]
    -- > adjust ("new " ++) 7 (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "a")]
    -- > adjust ("new " ++) 7 empty                         == empty

    adjust ::  (a -> a) -> Key -> IntMap a -> IntMap a
    adjust :: forall a. (a -> a) -> Key -> IntMap a -> IntMap a
    adjust a -> a
    f Key
    k IntMap a
    m
      = (Key -> a -> a) -> Key -> IntMap a -> IntMap a
    forall a. (Key -> a -> a) -> Key -> IntMap a -> IntMap a
    adjustWithKey (\Key
    _ a
    x -> a -> a
    f a
    x) Key
    k IntMap a
    m

    -- | \(O(\min(n,W))\). Adjust a value at a specific key. When the key is not
    -- a member of the map, the original map is returned.
    --
    -- > let f key x = (show key) ++ ":new " ++ x
    -- > adjustWithKey f 5 (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "5:new a")]
    -- > adjustWithKey f 7 (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "a")]
    -- > adjustWithKey f 7 empty                         == empty

    adjustWithKey ::  (Key -> a -> a) -> Key -> IntMap a -> IntMap a
    adjustWithKey :: forall a. (Key -> a -> a) -> Key -> IntMap a -> IntMap a
    adjustWithKey Key -> a -> a
    f !Key
    k IntMap a
    t =
      case IntMap a
    t of
        Bin Key
    p Key
    m IntMap a
    l IntMap a
    r
          | Key -> Key -> Key -> Bool
    nomatch Key
    k Key
    p Key
    m -> IntMap a
    t
          | Key -> Key -> Bool
    zero Key
    k Key
    m      -> Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin Key
    p Key
    m ((Key -> a -> a) -> Key -> IntMap a -> IntMap a
    forall a. (Key -> a -> a) -> Key -> IntMap a -> IntMap a
    adjustWithKey Key -> a -> a
    f Key
    k IntMap a
    l) IntMap a
    r
          | Bool
    otherwise     -> Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin Key
    p Key
    m IntMap a
    l ((Key -> a -> a) -> Key -> IntMap a -> IntMap a
    forall a. (Key -> a -> a) -> Key -> IntMap a -> IntMap a
    adjustWithKey Key -> a -> a
    f Key
    k IntMap a
    r)
        Tip Key
    ky a
    y
          | Key
    kKey -> Key -> Bool
    forall a. Eq a => a -> a -> Bool
    ==Key
    ky         -> Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    ky (a -> IntMap a) -> a -> IntMap a
    forall a b. (a -> b) -> a -> b
    $! Key -> a -> a
    f Key
    k a
    y
          | Bool
    otherwise     -> IntMap a
    t
        IntMap a
    Nil -> IntMap a
    forall a. IntMap a
    Nil

    -- | \(O(\min(n,W))\). 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
    -- deleted. If it is (@'Just' y@), the key @k@ is bound to the new value @y@.
    --
    -- > let f x = if x == "a" then Just "new a" else Nothing
    -- > update f 5 (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "new a")]
    -- > update f 7 (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "a")]
    -- > update f 3 (fromList [(5,"a"), (3,"b")]) == singleton 5 "a"

    update ::  (a -> Maybe a) -> Key -> IntMap a -> IntMap a
    update :: forall a. (a -> Maybe a) -> Key -> IntMap a -> IntMap a
    update a -> Maybe a
    f
      = (Key -> a -> Maybe a) -> Key -> IntMap a -> IntMap a
    forall a. (Key -> a -> Maybe a) -> Key -> IntMap a -> IntMap a
    updateWithKey (\Key
    _ a
    x -> a -> Maybe a
    f a
    x)

    -- | \(O(\min(n,W))\). The expression (@'update' f k map@) updates the value @x@
    -- at @k@ (if it is in the map). If (@f k x@) is 'Nothing', the element is
    -- deleted. If it is (@'Just' y@), the key @k@ is bound to the new value @y@.
    --
    -- > let f k x = if x == "a" then Just ((show k) ++ ":new a") else Nothing
    -- > updateWithKey f 5 (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "5:new a")]
    -- > updateWithKey f 7 (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "a")]
    -- > updateWithKey f 3 (fromList [(5,"a"), (3,"b")]) == singleton 5 "a"

    updateWithKey ::  (Key -> a -> Maybe a) -> Key -> IntMap a -> IntMap a
    updateWithKey :: forall a. (Key -> a -> Maybe a) -> Key -> IntMap a -> IntMap a
    updateWithKey Key -> a -> Maybe a
    f !Key
    k IntMap a
    t =
      case IntMap a
    t of
        Bin Key
    p Key
    m IntMap a
    l IntMap a
    r
          | Key -> Key -> Key -> Bool
    nomatch Key
    k Key
    p Key
    m -> IntMap a
    t
          | Key -> Key -> Bool
    zero Key
    k Key
    m      -> Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    binCheckLeft Key
    p Key
    m ((Key -> a -> Maybe a) -> Key -> IntMap a -> IntMap a
    forall a. (Key -> a -> Maybe a) -> Key -> IntMap a -> IntMap a
    updateWithKey Key -> a -> Maybe a
    f Key
    k IntMap a
    l) IntMap a
    r
          | Bool
    otherwise     -> Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    binCheckRight Key
    p Key
    m IntMap a
    l ((Key -> a -> Maybe a) -> Key -> IntMap a -> IntMap a
    forall a. (Key -> a -> Maybe a) -> Key -> IntMap a -> IntMap a
    updateWithKey Key -> a -> Maybe a
    f Key
    k IntMap a
    r)
        Tip Key
    ky a
    y
          | Key
    kKey -> Key -> Bool
    forall a. Eq a => a -> a -> Bool
    ==Key
    ky         -> case Key -> a -> Maybe a
    f Key
    k a
    y of
                               Just !a
    y' -> Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    ky a
    y'
                               Maybe a
    Nothing -> IntMap a
    forall a. IntMap a
    Nil
          | Bool
    otherwise     -> IntMap a
    t
        IntMap a
    Nil -> IntMap a
    forall a. IntMap a
    Nil

    -- | \(O(\min(n,W))\). Lookup and update.
    -- The function returns original value, if it is updated.
    -- This is different behavior than 'Data.Map.updateLookupWithKey'.
    -- Returns the original key value if the map entry is deleted.
    --
    -- > let f k x = if x == "a" then Just ((show k) ++ ":new a") else Nothing
    -- > updateLookupWithKey f 5 (fromList [(5,"a"), (3,"b")]) == (Just "a", fromList [(3, "b"), (5, "5:new a")])
    -- > updateLookupWithKey f 7 (fromList [(5,"a"), (3,"b")]) == (Nothing,  fromList [(3, "b"), (5, "a")])
    -- > updateLookupWithKey f 3 (fromList [(5,"a"), (3,"b")]) == (Just "b", singleton 5 "a")

    updateLookupWithKey ::  (Key -> a -> Maybe a) -> Key -> IntMap a -> (Maybe a,IntMap a)
    updateLookupWithKey :: forall a.
    (Key -> a -> Maybe a) -> Key -> IntMap a -> (Maybe a, IntMap a)
    updateLookupWithKey Key -> a -> Maybe a
    f0 !Key
    k0 IntMap a
    t0 = StrictPair (Maybe a) (IntMap a) -> (Maybe a, IntMap a)
    forall a b. StrictPair a b -> (a, b)
    toPair (StrictPair (Maybe a) (IntMap a) -> (Maybe a, IntMap a))
    -> StrictPair (Maybe a) (IntMap a) -> (Maybe a, IntMap a)
    forall a b. (a -> b) -> a -> b
    $ (Key -> a -> Maybe a)
    -> Key -> IntMap a -> StrictPair (Maybe a) (IntMap a)
    forall {a}.
    (Key -> a -> Maybe a)
    -> Key -> IntMap a -> StrictPair (Maybe a) (IntMap a)
    go Key -> a -> Maybe a
    f0 Key
    k0 IntMap a
    t0
      where
        go :: (Key -> a -> Maybe a)
    -> Key -> IntMap a -> StrictPair (Maybe a) (IntMap a)
    go Key -> a -> Maybe a
    f Key
    k IntMap a
    t =
          case IntMap a
    t of
            Bin Key
    p Key
    m IntMap a
    l IntMap a
    r
              | Key -> Key -> Key -> Bool
    nomatch Key
    k Key
    p Key
    m -> (Maybe a
    forall a. Maybe a
    Nothing Maybe a -> IntMap a -> StrictPair (Maybe a) (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: IntMap a
    t)
              | Key -> Key -> Bool
    zero Key
    k Key
    m      -> let (Maybe a
    found :*: IntMap a
    l') = (Key -> a -> Maybe a)
    -> Key -> IntMap a -> StrictPair (Maybe a) (IntMap a)
    go Key -> a -> Maybe a
    f Key
    k IntMap a
    l in (Maybe a
    found Maybe a -> IntMap a -> StrictPair (Maybe a) (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    binCheckLeft Key
    p Key
    m IntMap a
    l' IntMap a
    r)
              | Bool
    otherwise     -> let (Maybe a
    found :*: IntMap a
    r') = (Key -> a -> Maybe a)
    -> Key -> IntMap a -> StrictPair (Maybe a) (IntMap a)
    go Key -> a -> Maybe a
    f Key
    k IntMap a
    r in (Maybe a
    found Maybe a -> IntMap a -> StrictPair (Maybe a) (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    binCheckRight Key
    p Key
    m IntMap a
    l IntMap a
    r')
            Tip Key
    ky a
    y
              | Key
    kKey -> Key -> Bool
    forall a. Eq a => a -> a -> Bool
    ==Key
    ky         -> case Key -> a -> Maybe a
    f Key
    k a
    y of
                                   Just !a
    y' -> (a -> Maybe a
    forall a. a -> Maybe a
    Just a
    y Maybe a -> IntMap a -> StrictPair (Maybe a) (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    ky a
    y')
                                   Maybe a
    Nothing  -> (a -> Maybe a
    forall a. a -> Maybe a
    Just a
    y Maybe a -> IntMap a -> StrictPair (Maybe a) (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: IntMap a
    forall a. IntMap a
    Nil)
              | Bool
    otherwise     -> (Maybe a
    forall a. Maybe a
    Nothing Maybe a -> IntMap a -> StrictPair (Maybe a) (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: IntMap a
    t)
            IntMap a
    Nil -> (Maybe a
    forall a. Maybe a
    Nothing Maybe a -> IntMap a -> StrictPair (Maybe a) (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: IntMap a
    forall a. IntMap a
    Nil)

    -- | \(O(\min(n,W))\). The expression (@'alter' f k map@) alters the value @x@ at @k@, or absence thereof.
    -- 'alter' can be used to insert, delete, or update a value in an 'IntMap'.
    -- In short : @'lookup' k ('alter' f k m) = f ('lookup' k m)@.
    alter :: (Maybe a -> Maybe a) -> Key -> IntMap a -> IntMap a
    alter :: forall a. (Maybe a -> Maybe a) -> Key -> IntMap a -> IntMap a
    alter Maybe a -> Maybe a
    f !Key
    k IntMap a
    t =
      case IntMap a
    t of
        Bin Key
    p Key
    m IntMap a
    l IntMap a
    r
          | Key -> Key -> Key -> Bool
    nomatch Key
    k Key
    p Key
    m -> case Maybe a -> Maybe a
    f Maybe a
    forall a. Maybe a
    Nothing of
                               Maybe a
    Nothing -> IntMap a
    t
                               Just !a
    x  -> Key -> IntMap a -> Key -> IntMap a -> IntMap a
    forall a. Key -> IntMap a -> Key -> IntMap a -> IntMap a
    link Key
    k (Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    k a
    x) Key
    p IntMap a
    t
          | Key -> Key -> Bool
    zero Key
    k Key
    m      -> Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    binCheckLeft Key
    p Key
    m ((Maybe a -> Maybe a) -> Key -> IntMap a -> IntMap a
    forall a. (Maybe a -> Maybe a) -> Key -> IntMap a -> IntMap a
    alter Maybe a -> Maybe a
    f Key
    k IntMap a
    l) IntMap a
    r
          | Bool
    otherwise     -> Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    binCheckRight Key
    p Key
    m IntMap a
    l ((Maybe a -> Maybe a) -> Key -> IntMap a -> IntMap a
    forall a. (Maybe a -> Maybe a) -> Key -> IntMap a -> IntMap a
    alter Maybe a -> Maybe a
    f Key
    k IntMap a
    r)
        Tip Key
    ky a
    y
          | Key
    kKey -> Key -> Bool
    forall a. Eq a => a -> a -> Bool
    ==Key
    ky         -> case Maybe a -> Maybe a
    f (a -> Maybe a
    forall a. a -> Maybe a
    Just a
    y) of
                               Just !a
    x -> Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    ky a
    x
                               Maybe a
    Nothing -> IntMap a
    forall a. IntMap a
    Nil
          | Bool
    otherwise     -> case Maybe a -> Maybe a
    f Maybe a
    forall a. Maybe a
    Nothing of
                               Just !a
    x -> Key -> IntMap a -> Key -> IntMap a -> IntMap a
    forall a. Key -> IntMap a -> Key -> IntMap a -> IntMap a
    link Key
    k (Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    k a
    x) Key
    ky IntMap a
    t
                               Maybe a
    Nothing -> IntMap a
    t
        IntMap a
    Nil               -> case Maybe a -> Maybe a
    f Maybe a
    forall a. Maybe a
    Nothing of
                               Just !a
    x -> Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    k a
    x
                               Maybe a
    Nothing -> IntMap a
    forall a. IntMap a
    Nil

    -- | \(O(\log n)\). The expression (@'alterF' f k map@) alters the value @x@ at
    -- @k@, or absence thereof.  'alterF' can be used to inspect, insert, delete,
    -- or update a value in an 'IntMap'.  In short : @'lookup' k <$> 'alterF' f k m = f
    -- ('lookup' k m)@.
    --
    -- Example:
    --
    -- @
    -- interactiveAlter :: Int -> IntMap String -> IO (IntMap String)
    -- interactiveAlter k m = alterF f k m where
    --   f Nothing = do
    --      putStrLn $ show k ++
    --          " was not found in the map. Would you like to add it?"
    --      getUserResponse1 :: IO (Maybe String)
    --   f (Just old) = do
    --      putStrLn $ "The key is currently bound to " ++ show old ++
    --          ". Would you like to change or delete it?"
    --      getUserResponse2 :: IO (Maybe String)
    -- @
    --
    -- 'alterF' is the most general operation for working with an individual
    -- key that may or may not be in a given map.

    -- Note: 'alterF' is a flipped version of the 'at' combinator from
    -- 'Control.Lens.At'.
    --
    -- @since 0.5.8

    alterF :: Functor f
           => (Maybe a -> f (Maybe a)) -> Key -> IntMap a -> f (IntMap a)
    -- This implementation was modified from 'Control.Lens.At'.
    alterF :: forall (f :: * -> *) a.
    Functor f =>
    (Maybe a -> f (Maybe a)) -> Key -> IntMap a -> f (IntMap a)
    alterF Maybe a -> f (Maybe a)
    f Key
    k IntMap a
    m = ((Maybe a -> IntMap a) -> f (Maybe a) -> f (IntMap a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe a -> f (Maybe a)
    f Maybe a
    mv) ((Maybe a -> IntMap a) -> f (IntMap a))
    -> (Maybe a -> IntMap a) -> f (IntMap a)
    forall a b. (a -> b) -> a -> b
    $ \Maybe a
    fres ->
      case Maybe a
    fres of
        Maybe a
    Nothing -> IntMap a -> (a -> IntMap a) -> Maybe a -> IntMap a
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe IntMap a
    m (IntMap a -> a -> IntMap a
    forall a b. a -> b -> a
    const (Key -> IntMap a -> IntMap a
    forall a. Key -> IntMap a -> IntMap a
    delete Key
    k IntMap a
    m)) Maybe a
    mv
        Just !a
    v' -> Key -> a -> IntMap a -> IntMap a
    forall a. Key -> a -> IntMap a -> IntMap a
    insert Key
    k a
    v' IntMap a
    m
      where mv :: Maybe a
    mv = Key -> IntMap a -> Maybe a
    forall a. Key -> IntMap a -> Maybe a
    lookup Key
    k IntMap a
    m

    {--------------------------------------------------------------------
      Union
    --------------------------------------------------------------------}
    -- | The union of a list of maps, with a combining operation.
    --
    -- > unionsWith (++) [(fromList [(5, "a"), (3, "b")]), (fromList [(5, "A"), (7, "C")]), (fromList [(5, "A3"), (3, "B3")])]
    -- >     == fromList [(3, "bB3"), (5, "aAA3"), (7, "C")]

    unionsWith :: Foldable f => (a->a->a) -> f (IntMap a) -> IntMap a
    unionsWith :: forall (f :: * -> *) a.
    Foldable f =>
    (a -> a -> a) -> f (IntMap a) -> IntMap a
    unionsWith a -> a -> a
    f f (IntMap a)
    ts
      = (IntMap a -> IntMap a -> IntMap a)
    -> IntMap a -> f (IntMap a) -> IntMap a
    forall b a. (b -> a -> b) -> b -> f a -> b
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    Foldable.foldl' ((a -> a -> a) -> IntMap a -> IntMap a -> IntMap a
    forall a. (a -> a -> a) -> IntMap a -> IntMap a -> IntMap a
    unionWith a -> a -> a
    f) IntMap a
    forall a. IntMap a
    empty f (IntMap a)
    ts

    -- | \(O(n+m)\). The union with a combining function.
    --
    -- > unionWith (++) (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == fromList [(3, "b"), (5, "aA"), (7, "C")]

    unionWith :: (a -> a -> a) -> IntMap a -> IntMap a -> IntMap a
    unionWith :: forall a. (a -> a -> a) -> IntMap a -> IntMap a -> IntMap a
    unionWith a -> a -> a
    f IntMap a
    m1 IntMap a
    m2
      = (Key -> a -> a -> a) -> IntMap a -> IntMap a -> IntMap a
    forall a. (Key -> a -> a -> a) -> IntMap a -> IntMap a -> IntMap a
    unionWithKey (\Key
    _ a
    x a
    y -> a -> a -> a
    f a
    x a
    y) IntMap a
    m1 IntMap a
    m2

    -- | \(O(n+m)\). The union with a combining function.
    --
    -- > let f key left_value right_value = (show key) ++ ":" ++ left_value ++ "|" ++ right_value
    -- > unionWithKey f (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == fromList [(3, "b"), (5, "5:a|A"), (7, "C")]

    unionWithKey :: (Key -> a -> a -> a) -> IntMap a -> IntMap a -> IntMap a
    unionWithKey :: forall a. (Key -> a -> a -> a) -> IntMap a -> IntMap a -> IntMap a
    unionWithKey Key -> a -> a -> a
    f IntMap a
    m1 IntMap a
    m2
      = (Key -> Key -> IntMap a -> IntMap a -> IntMap a)
    -> (IntMap a -> IntMap a -> IntMap a)
    -> (IntMap a -> IntMap a)
    -> (IntMap a -> IntMap a)
    -> IntMap a
    -> IntMap a
    -> IntMap a
    forall c a b.
    (Key -> Key -> IntMap c -> IntMap c -> IntMap c)
    -> (IntMap a -> IntMap b -> IntMap c)
    -> (IntMap a -> IntMap c)
    -> (IntMap b -> IntMap c)
    -> IntMap a
    -> IntMap b
    -> IntMap c
    mergeWithKey' Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin (\(Tip Key
    k1 a
    x1) (Tip Key
    _k2 a
    x2) -> Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    k1 (a -> IntMap a) -> a -> IntMap a
    forall a b. (a -> b) -> a -> b
    $! Key -> a -> a -> a
    f Key
    k1 a
    x1 a
    x2) IntMap a -> IntMap a
    forall a. a -> a
    id IntMap a -> IntMap a
    forall a. a -> a
    id IntMap a
    m1 IntMap a
    m2

    {--------------------------------------------------------------------
      Difference
    --------------------------------------------------------------------}

    -- | \(O(n+m)\). Difference with a combining function.
    --
    -- > let f al ar = if al == "b" then Just (al ++ ":" ++ ar) else Nothing
    -- > differenceWith f (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (3, "B"), (7, "C")])
    -- >     == singleton 3 "b:B"

    differenceWith :: (a -> b -> Maybe a) -> IntMap a -> IntMap b -> IntMap a
    differenceWith :: forall a b. (a -> b -> Maybe a) -> IntMap a -> IntMap b -> IntMap a
    differenceWith a -> b -> Maybe a
    f IntMap a
    m1 IntMap b
    m2
      = (Key -> a -> b -> Maybe a) -> IntMap a -> IntMap b -> IntMap a
    forall a b.
    (Key -> a -> b -> Maybe a) -> IntMap a -> IntMap b -> IntMap a
    differenceWithKey (\Key
    _ a
    x b
    y -> a -> b -> Maybe a
    f a
    x b
    y) IntMap a
    m1 IntMap b
    m2

    -- | \(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.
    -- If it returns 'Nothing', the element is discarded (proper set difference).
    -- If it returns (@'Just' y@), the element is updated with a new value @y@.
    --
    -- > let f k al ar = if al == "b" then Just ((show k) ++ ":" ++ al ++ "|" ++ ar) else Nothing
    -- > differenceWithKey f (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (3, "B"), (10, "C")])
    -- >     == singleton 3 "3:b|B"

    differenceWithKey :: (Key -> a -> b -> Maybe a) -> IntMap a -> IntMap b -> IntMap a
    differenceWithKey :: forall a b.
    (Key -> a -> b -> Maybe a) -> IntMap a -> IntMap b -> IntMap a
    differenceWithKey Key -> a -> b -> Maybe a
    f IntMap a
    m1 IntMap b
    m2
      = (Key -> a -> b -> Maybe a)
    -> (IntMap a -> IntMap a)
    -> (IntMap b -> IntMap a)
    -> IntMap a
    -> IntMap b
    -> IntMap a
    forall a b c.
    (Key -> a -> b -> Maybe c)
    -> (IntMap a -> IntMap c)
    -> (IntMap b -> IntMap c)
    -> IntMap a
    -> IntMap b
    -> IntMap c
    mergeWithKey Key -> a -> b -> Maybe a
    f IntMap a -> IntMap a
    forall a. a -> a
    id (IntMap a -> IntMap b -> IntMap a
    forall a b. a -> b -> a
    const IntMap a
    forall a. IntMap a
    Nil) IntMap a
    m1 IntMap b
    m2

    {--------------------------------------------------------------------
      Intersection
    --------------------------------------------------------------------}

    -- | \(O(n+m)\). The intersection with a combining function.
    --
    -- > intersectionWith (++) (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == singleton 5 "aA"

    intersectionWith :: (a -> b -> c) -> IntMap a -> IntMap b -> IntMap c
    intersectionWith :: forall a b c. (a -> b -> c) -> IntMap a -> IntMap b -> IntMap c
    intersectionWith a -> b -> c
    f IntMap a
    m1 IntMap b
    m2
      = (Key -> a -> b -> c) -> IntMap a -> IntMap b -> IntMap c
    forall a b c.
    (Key -> a -> b -> c) -> IntMap a -> IntMap b -> IntMap c
    intersectionWithKey (\Key
    _ a
    x b
    y -> a -> b -> c
    f a
    x b
    y) IntMap a
    m1 IntMap b
    m2

    -- | \(O(n+m)\). The intersection with a combining function.
    --
    -- > let f k al ar = (show k) ++ ":" ++ al ++ "|" ++ ar
    -- > intersectionWithKey f (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == singleton 5 "5:a|A"

    intersectionWithKey :: (Key -> a -> b -> c) -> IntMap a -> IntMap b -> IntMap c
    intersectionWithKey :: forall a b c.
    (Key -> a -> b -> c) -> IntMap a -> IntMap b -> IntMap c
    intersectionWithKey Key -> a -> b -> c
    f IntMap a
    m1 IntMap b
    m2
      = (Key -> Key -> IntMap c -> IntMap c -> IntMap c)
    -> (IntMap a -> IntMap b -> IntMap c)
    -> (IntMap a -> IntMap c)
    -> (IntMap b -> IntMap c)
    -> IntMap a
    -> IntMap b
    -> IntMap c
    forall c a b.
    (Key -> Key -> IntMap c -> IntMap c -> IntMap c)
    -> (IntMap a -> IntMap b -> IntMap c)
    -> (IntMap a -> IntMap c)
    -> (IntMap b -> IntMap c)
    -> IntMap a
    -> IntMap b
    -> IntMap c
    mergeWithKey' Key -> Key -> IntMap c -> IntMap c -> IntMap c
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    bin (\(Tip Key
    k1 a
    x1) (Tip Key
    _k2 b
    x2) -> Key -> c -> IntMap c
    forall a. Key -> a -> IntMap a
    Tip Key
    k1 (c -> IntMap c) -> c -> IntMap c
    forall a b. (a -> b) -> a -> b
    $! Key -> a -> b -> c
    f Key
    k1 a
    x1 b
    x2) (IntMap c -> IntMap a -> IntMap c
    forall a b. a -> b -> a
    const IntMap c
    forall a. IntMap a
    Nil) (IntMap c -> IntMap b -> IntMap c
    forall a b. a -> b -> a
    const IntMap c
    forall a. IntMap a
    Nil) IntMap a
    m1 IntMap b
    m2

    {--------------------------------------------------------------------
      MergeWithKey
    --------------------------------------------------------------------}

    -- | \(O(n+m)\). A high-performance universal combining function. Using
    -- 'mergeWithKey', all combining functions can be defined without any loss of
    -- efficiency (with exception of 'union', 'difference' and 'intersection',
    -- where sharing of some nodes is lost with 'mergeWithKey').
    --
    -- Please make sure you know what is going on when using 'mergeWithKey',
    -- otherwise you can be surprised by unexpected code growth or even
    -- corruption of the data structure.
    --
    -- When 'mergeWithKey' is given three arguments, it is inlined to the call
    -- site. You should therefore use 'mergeWithKey' only to define your custom
    -- combining functions. For example, you could define 'unionWithKey',
    -- 'differenceWithKey' and 'intersectionWithKey' as
    --
    -- > myUnionWithKey f m1 m2 = mergeWithKey (\k x1 x2 -> Just (f k x1 x2)) id id m1 m2
    -- > myDifferenceWithKey f m1 m2 = mergeWithKey f id (const empty) m1 m2
    -- > myIntersectionWithKey f m1 m2 = mergeWithKey (\k x1 x2 -> Just (f k x1 x2)) (const empty) (const empty) m1 m2
    --
    -- When calling @'mergeWithKey' combine only1 only2@, a function combining two
    -- 'IntMap's is created, such that
    --
    -- * if a key is present in both maps, it is passed with both corresponding
    --   values to the @combine@ function. Depending on the result, the key is either
    --   present in the result with specified value, or is left out;
    --
    -- * a nonempty subtree present only in the first map is passed to @only1@ and
    --   the output is added to the result;
    --
    -- * a nonempty subtree present only in the second map is passed to @only2@ and
    --   the output is added to the result.
    --
    -- The @only1@ and @only2@ methods /must return a map with a subset (possibly empty) of the keys of the given map/.
    -- The values can be modified arbitrarily.  Most common variants of @only1@ and
    -- @only2@ are 'id' and @'const' 'empty'@, but for example @'map' f@ or
    -- @'filterWithKey' f@ could be used for any @f@.

    mergeWithKey :: (Key -> a -> b -> Maybe c) -> (IntMap a -> IntMap c) -> (IntMap b -> IntMap c)
                 -> IntMap a -> IntMap b -> IntMap c
    mergeWithKey :: forall a b c.
    (Key -> a -> b -> Maybe c)
    -> (IntMap a -> IntMap c)
    -> (IntMap b -> IntMap c)
    -> IntMap a
    -> IntMap b
    -> IntMap c
    mergeWithKey Key -> a -> b -> Maybe c
    f IntMap a -> IntMap c
    g1 IntMap b -> IntMap c
    g2 = (Key -> Key -> IntMap c -> IntMap c -> IntMap c)
    -> (IntMap a -> IntMap b -> IntMap c)
    -> (IntMap a -> IntMap c)
    -> (IntMap b -> IntMap c)
    -> IntMap a
    -> IntMap b
    -> IntMap c
    forall c a b.
    (Key -> Key -> IntMap c -> IntMap c -> IntMap c)
    -> (IntMap a -> IntMap b -> IntMap c)
    -> (IntMap a -> IntMap c)
    -> (IntMap b -> IntMap c)
    -> IntMap a
    -> IntMap b
    -> IntMap c
    mergeWithKey' Key -> Key -> IntMap c -> IntMap c -> IntMap c
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    bin IntMap a -> IntMap b -> IntMap c
    combine IntMap a -> IntMap c
    g1 IntMap b -> IntMap c
    g2
      where -- We use the lambda form to avoid non-exhaustive pattern matches warning.
            combine :: IntMap a -> IntMap b -> IntMap c
    combine = \(Tip Key
    k1 a
    x1) (Tip Key
    _k2 b
    x2) -> case Key -> a -> b -> Maybe c
    f Key
    k1 a
    x1 b
    x2 of Maybe c
    Nothing -> IntMap c
    forall a. IntMap a
    Nil
                                                                      Just !c
    x -> Key -> c -> IntMap c
    forall a. Key -> a -> IntMap a
    Tip Key
    k1 c
    x
            {-# INLINE combine #-}
    {-# INLINE mergeWithKey #-}

    {--------------------------------------------------------------------
      Min\/Max
    --------------------------------------------------------------------}

    -- | \(O(\log n)\). Update the value at the minimal key.
    --
    -- > updateMinWithKey (\ k a -> Just ((show k) ++ ":" ++ a)) (fromList [(5,"a"), (3,"b")]) == fromList [(3,"3:b"), (5,"a")]
    -- > updateMinWithKey (\ _ _ -> Nothing)                     (fromList [(5,"a"), (3,"b")]) == singleton 5 "a"

    updateMinWithKey :: (Key -> a -> Maybe a) -> IntMap a -> IntMap a
    updateMinWithKey :: forall a. (Key -> a -> Maybe a) -> IntMap a -> IntMap a
    updateMinWithKey Key -> a -> Maybe a
    f IntMap a
    t =
      case IntMap a
    t of Bin Key
    p Key
    m IntMap a
    l IntMap a
    r | Key
    m Key -> Key -> Bool
    forall a. Ord a => a -> a -> Bool
    < Key
    0 -> Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    binCheckRight Key
    p Key
    m IntMap a
    l ((Key -> a -> Maybe a) -> IntMap a -> IntMap a
    forall a. (Key -> a -> Maybe a) -> IntMap a -> IntMap a
    go Key -> a -> Maybe a
    f IntMap a
    r)
                IntMap a
    _ -> (Key -> a -> Maybe a) -> IntMap a -> IntMap a
    forall a. (Key -> a -> Maybe a) -> IntMap a -> IntMap a
    go Key -> a -> Maybe a
    f IntMap a
    t
      where
        go :: (Key -> t -> Maybe t) -> IntMap t -> IntMap t
    go Key -> t -> Maybe t
    f' (Bin Key
    p Key
    m IntMap t
    l IntMap t
    r) = Key -> Key -> IntMap t -> IntMap t -> IntMap t
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    binCheckLeft Key
    p Key
    m ((Key -> t -> Maybe t) -> IntMap t -> IntMap t
    go Key -> t -> Maybe t
    f' IntMap t
    l) IntMap t
    r
        go Key -> t -> Maybe t
    f' (Tip Key
    k t
    y) = case Key -> t -> Maybe t
    f' Key
    k t
    y of
                            Just !t
    y' -> Key -> t -> IntMap t
    forall a. Key -> a -> IntMap a
    Tip Key
    k t
    y'
                            Maybe t
    Nothing -> IntMap t
    forall a. IntMap a
    Nil
        go Key -> t -> Maybe t
    _ IntMap t
    Nil = [Char] -> IntMap t
    forall a. HasCallStack => [Char] -> a
    error [Char]
    "updateMinWithKey Nil"

    -- | \(O(\log n)\). Update the value at the maximal key.
    --
    -- > updateMaxWithKey (\ k a -> Just ((show k) ++ ":" ++ a)) (fromList [(5,"a"), (3,"b")]) == fromList [(3,"b"), (5,"5:a")]
    -- > updateMaxWithKey (\ _ _ -> Nothing)                     (fromList [(5,"a"), (3,"b")]) == singleton 3 "b"

    updateMaxWithKey :: (Key -> a -> Maybe a) -> IntMap a -> IntMap a
    updateMaxWithKey :: forall a. (Key -> a -> Maybe a) -> IntMap a -> IntMap a
    updateMaxWithKey Key -> a -> Maybe a
    f IntMap a
    t =
      case IntMap a
    t of Bin Key
    p Key
    m IntMap a
    l IntMap a
    r | Key
    m Key -> Key -> Bool
    forall a. Ord a => a -> a -> Bool
    < Key
    0 -> Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    binCheckLeft Key
    p Key
    m ((Key -> a -> Maybe a) -> IntMap a -> IntMap a
    forall a. (Key -> a -> Maybe a) -> IntMap a -> IntMap a
    go Key -> a -> Maybe a
    f IntMap a
    l) IntMap a
    r
                IntMap a
    _ -> (Key -> a -> Maybe a) -> IntMap a -> IntMap a
    forall a. (Key -> a -> Maybe a) -> IntMap a -> IntMap a
    go Key -> a -> Maybe a
    f IntMap a
    t
      where
        go :: (Key -> t -> Maybe t) -> IntMap t -> IntMap t
    go Key -> t -> Maybe t
    f' (Bin Key
    p Key
    m IntMap t
    l IntMap t
    r) = Key -> Key -> IntMap t -> IntMap t -> IntMap t
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    binCheckRight Key
    p Key
    m IntMap t
    l ((Key -> t -> Maybe t) -> IntMap t -> IntMap t
    go Key -> t -> Maybe t
    f' IntMap t
    r)
        go Key -> t -> Maybe t
    f' (Tip Key
    k t
    y) = case Key -> t -> Maybe t
    f' Key
    k t
    y of
                            Just !t
    y' -> Key -> t -> IntMap t
    forall a. Key -> a -> IntMap a
    Tip Key
    k t
    y'
                            Maybe t
    Nothing -> IntMap t
    forall a. IntMap a
    Nil
        go Key -> t -> Maybe t
    _ IntMap t
    Nil = [Char] -> IntMap t
    forall a. HasCallStack => [Char] -> a
    error [Char]
    "updateMaxWithKey Nil"

    -- | \(O(\log n)\). Update the value at the maximal key.
    --
    -- > updateMax (\ a -> Just ("X" ++ a)) (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "Xa")]
    -- > updateMax (\ _ -> Nothing)         (fromList [(5,"a"), (3,"b")]) == singleton 3 "b"

    updateMax :: (a -> Maybe a) -> IntMap a -> IntMap a
    updateMax :: forall a. (a -> Maybe a) -> IntMap a -> IntMap a
    updateMax a -> Maybe a
    f = (Key -> a -> Maybe a) -> IntMap a -> IntMap a
    forall a. (Key -> a -> Maybe a) -> IntMap a -> IntMap a
    updateMaxWithKey ((a -> Maybe a) -> Key -> a -> Maybe a
    forall a b. a -> b -> a
    const a -> Maybe a
    f)

    -- | \(O(\log n)\). Update the value at the minimal key.
    --
    -- > updateMin (\ a -> Just ("X" ++ a)) (fromList [(5,"a"), (3,"b")]) == fromList [(3, "Xb"), (5, "a")]
    -- > updateMin (\ _ -> Nothing)         (fromList [(5,"a"), (3,"b")]) == singleton 5 "a"

    updateMin :: (a -> Maybe a) -> IntMap a -> IntMap a
    updateMin :: forall a. (a -> Maybe a) -> IntMap a -> IntMap a
    updateMin a -> Maybe a
    f = (Key -> a -> Maybe a) -> IntMap a -> IntMap a
    forall a. (Key -> a -> Maybe a) -> IntMap a -> IntMap a
    updateMinWithKey ((a -> Maybe a) -> Key -> a -> Maybe a
    forall a b. a -> b -> a
    const a -> Maybe a
    f)

    {--------------------------------------------------------------------
      Mapping
    --------------------------------------------------------------------}
    -- | \(O(n)\). Map a function over all values in the map.
    --
    -- > map (++ "x") (fromList [(5,"a"), (3,"b")]) == fromList [(3, "bx"), (5, "ax")]

    map :: (a -> b) -> IntMap a -> IntMap b
    map :: forall a b. (a -> b) -> IntMap a -> IntMap b
    map a -> b
    f = IntMap a -> IntMap b
    go
      where
        go :: IntMap a -> IntMap b
    go (Bin Key
    p Key
    m IntMap a
    l IntMap a
    r) = Key -> Key -> IntMap b -> IntMap b -> IntMap b
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin Key
    p Key
    m (IntMap a -> IntMap b
    go IntMap a
    l) (IntMap a -> IntMap b
    go IntMap a
    r)
        go (Tip Key
    k a
    x)     = Key -> b -> IntMap b
    forall a. Key -> a -> IntMap a
    Tip Key
    k (b -> IntMap b) -> b -> IntMap b
    forall a b. (a -> b) -> a -> b
    $! a -> b
    f a
    x
        go IntMap a
    Nil           = IntMap b
    forall a. IntMap a
    Nil

    #ifdef __GLASGOW_HASKELL__
    {-# NOINLINE [1] map #-}
    {-# RULES
    "map/map" forall f g xs . map f (map g xs) = map (\x -> f $! g x) xs
    "map/mapL" forall f g xs . map f (L.map g xs) = map (\x -> f (g x)) xs
     #-}
    #endif

    -- | \(O(n)\). Map a function over all values in the map.
    --
    -- > let f key x = (show key) ++ ":" ++ x
    -- > mapWithKey f (fromList [(5,"a"), (3,"b")]) == fromList [(3, "3:b"), (5, "5:a")]

    mapWithKey :: (Key -> a -> b) -> IntMap a -> IntMap b
    mapWithKey :: forall a b. (Key -> a -> b) -> IntMap a -> IntMap b
    mapWithKey Key -> a -> b
    f IntMap a
    t
      = case IntMap a
    t of
          Bin Key
    p Key
    m IntMap a
    l IntMap a
    r -> Key -> Key -> IntMap b -> IntMap b -> IntMap b
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin Key
    p Key
    m ((Key -> a -> b) -> IntMap a -> IntMap b
    forall a b. (Key -> a -> b) -> IntMap a -> IntMap b
    mapWithKey Key -> a -> b
    f IntMap a
    l) ((Key -> a -> b) -> IntMap a -> IntMap b
    forall a b. (Key -> a -> b) -> IntMap a -> IntMap b
    mapWithKey Key -> a -> b
    f IntMap a
    r)
          Tip Key
    k a
    x     -> Key -> b -> IntMap b
    forall a. Key -> a -> IntMap a
    Tip Key
    k (b -> IntMap b) -> b -> IntMap b
    forall a b. (a -> b) -> a -> b
    $! Key -> a -> b
    f Key
    k a
    x
          IntMap a
    Nil         -> IntMap b
    forall a. IntMap a
    Nil

    #ifdef __GLASGOW_HASKELL__
    -- Pay close attention to strictness here. We need to force the
    -- intermediate result for map f . map g, and we need to refrain
    -- from forcing it for map f . L.map g, etc.
    --
    -- TODO Consider moving map and mapWithKey to IntMap.Internal so we can write
    -- non-orphan RULES for things like L.map f (map g xs). We'd need a new function
    -- for this, and we'd have to pay attention to simplifier phases. Something like
    --
    -- lsmap :: (b -> c) -> (a -> b) -> IntMap a -> IntMap c
    -- lsmap _ _ Nil = Nil
    -- lsmap f g (Tip k x) = let !gx = g x in Tip k (f gx)
    -- lsmap f g (Bin p m l r) = Bin p m (lsmap f g l) (lsmap f g r)
    {-# NOINLINE [1] mapWithKey #-}
    {-# RULES
    "mapWithKey/mapWithKey" forall f g xs . mapWithKey f (mapWithKey g xs) =
      mapWithKey (\k a -> f k $! g k a) xs
    "mapWithKey/mapWithKeyL" forall f g xs . mapWithKey f (L.mapWithKey g xs) =
      mapWithKey (\k a -> f k (g k a)) xs
    "mapWithKey/map" forall f g xs . mapWithKey f (map g xs) =
      mapWithKey (\k a -> f k $! g a) xs
    "mapWithKey/mapL" forall f g xs . mapWithKey f (L.map g xs) =
      mapWithKey (\k a -> f k (g a)) xs
    "map/mapWithKey" forall f g xs . map f (mapWithKey g xs) =
      mapWithKey (\k a -> f $! g k a) xs
    "map/mapWithKeyL" forall f g xs . map f (L.mapWithKey g xs) =
      mapWithKey (\k a -> f (g k a)) xs
     #-}
    #endif

    -- | \(O(n)\).
    -- @'traverseWithKey' f s == 'fromList' <$> 'traverse' (\(k, v) -> (,) k <$> f k v) ('toList' m)@
    -- That is, behaves exactly like a regular 'traverse' except that the traversing
    -- function also has access to the key associated with a value.
    --
    -- > traverseWithKey (\k v -> if odd k then Just (succ v) else Nothing) (fromList [(1, 'a'), (5, 'e')]) == Just (fromList [(1, 'b'), (5, 'f')])
    -- > traverseWithKey (\k v -> if odd k then Just (succ v) else Nothing) (fromList [(2, 'c')])           == Nothing
    traverseWithKey :: Applicative t => (Key -> a -> t b) -> IntMap a -> t (IntMap b)
    traverseWithKey :: forall (t :: * -> *) a b.
    Applicative t =>
    (Key -> a -> t b) -> IntMap a -> t (IntMap b)
    traverseWithKey Key -> a -> t b
    f = IntMap a -> t (IntMap b)
    go
      where
        go :: IntMap a -> t (IntMap b)
    go IntMap a
    Nil = IntMap b -> t (IntMap b)
    forall a. a -> t a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure IntMap b
    forall a. IntMap a
    Nil
        go (Tip Key
    k a
    v) = (\ !b
    v' -> Key -> b -> IntMap b
    forall a. Key -> a -> IntMap a
    Tip Key
    k b
    v') (b -> IntMap b) -> t b -> t (IntMap b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Key -> a -> t b
    f Key
    k a
    v
        go (Bin Key
    p Key
    m IntMap a
    l IntMap a
    r)
          | Key
    m Key -> Key -> Bool
    forall a. Ord a => a -> a -> Bool
    < Key
    0     = (IntMap b -> IntMap b -> IntMap b)
    -> t (IntMap b) -> t (IntMap b) -> t (IntMap b)
    forall a b c. (a -> b -> c) -> t a -> t b -> t c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 ((IntMap b -> IntMap b -> IntMap b)
    -> IntMap b -> IntMap b -> IntMap b
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (Key -> Key -> IntMap b -> IntMap b -> IntMap b
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin Key
    p Key
    m)) (IntMap a -> t (IntMap b)
    go IntMap a
    r) (IntMap a -> t (IntMap b)
    go IntMap a
    l)
          | Bool
    otherwise = (IntMap b -> IntMap b -> IntMap b)
    -> t (IntMap b) -> t (IntMap b) -> t (IntMap b)
    forall a b c. (a -> b -> c) -> t a -> t b -> t c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 (Key -> Key -> IntMap b -> IntMap b -> IntMap b
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin Key
    p Key
    m) (IntMap a -> t (IntMap b)
    go IntMap a
    l) (IntMap a -> t (IntMap b)
    go IntMap a
    r)
    {-# INLINE traverseWithKey #-}

    -- | \(O(n)\). Traverse keys\/values and collect the 'Just' results.
    --
    -- @since 0.6.4
    traverseMaybeWithKey
      :: Applicative f => (Key -> a -> f (Maybe b)) -> IntMap a -> f (IntMap b)
    traverseMaybeWithKey :: forall (f :: * -> *) a b.
    Applicative f =>
    (Key -> a -> f (Maybe b)) -> IntMap a -> f (IntMap b)
    traverseMaybeWithKey Key -> a -> f (Maybe b)
    f = IntMap a -> f (IntMap b)
    go
        where
        go :: IntMap a -> f (IntMap b)
    go IntMap a
    Nil           = IntMap b -> f (IntMap b)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure IntMap b
    forall a. IntMap a
    Nil
        go (Tip Key
    k a
    x)     = IntMap b -> (b -> IntMap b) -> Maybe b -> IntMap b
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe IntMap b
    forall a. IntMap a
    Nil (Key -> b -> IntMap b
    forall a. Key -> a -> IntMap a
    Tip Key
    k (b -> IntMap b) -> b -> IntMap b
    forall a b. (a -> b) -> a -> b
    $!) (Maybe b -> IntMap b) -> f (Maybe b) -> f (IntMap b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Key -> a -> f (Maybe b)
    f Key
    k a
    x
        go (Bin Key
    p Key
    m IntMap a
    l IntMap a
    r)
          | Key
    m Key -> Key -> Bool
    forall a. Ord a => a -> a -> Bool
    < Key
    0     = (IntMap b -> IntMap b -> IntMap b)
    -> f (IntMap b) -> f (IntMap b) -> f (IntMap b)
    forall a b c. (a -> b -> c) -> f a -> f b -> f c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 ((IntMap b -> IntMap b -> IntMap b)
    -> IntMap b -> IntMap b -> IntMap b
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (Key -> Key -> IntMap b -> IntMap b -> IntMap b
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    bin Key
    p Key
    m)) (IntMap a -> f (IntMap b)
    go IntMap a
    r) (IntMap a -> f (IntMap b)
    go IntMap a
    l)
          | Bool
    otherwise = (IntMap b -> IntMap b -> IntMap b)
    -> f (IntMap b) -> f (IntMap b) -> f (IntMap b)
    forall a b c. (a -> b -> c) -> f a -> f b -> f c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 (Key -> Key -> IntMap b -> IntMap b -> IntMap b
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    bin Key
    p Key
    m) (IntMap a -> f (IntMap b)
    go IntMap a
    l) (IntMap a -> f (IntMap b)
    go IntMap a
    r)

    -- | \(O(n)\). The function @'mapAccum'@ threads an accumulating
    -- argument through the map in ascending order of keys.
    --
    -- > let f a b = (a ++ b, b ++ "X")
    -- > mapAccum f "Everything: " (fromList [(5,"a"), (3,"b")]) == ("Everything: ba", fromList [(3, "bX"), (5, "aX")])

    mapAccum :: (a -> b -> (a,c)) -> a -> IntMap b -> (a,IntMap c)
    mapAccum :: forall a b c. (a -> b -> (a, c)) -> a -> IntMap b -> (a, IntMap c)
    mapAccum a -> b -> (a, c)
    f = (a -> Key -> b -> (a, c)) -> a -> IntMap b -> (a, IntMap c)
    forall a b c.
    (a -> Key -> b -> (a, c)) -> a -> IntMap b -> (a, IntMap c)
    mapAccumWithKey (\a
    a' Key
    _ b
    x -> a -> b -> (a, c)
    f a
    a' b
    x)

    -- | \(O(n)\). The function @'mapAccumWithKey'@ threads an accumulating
    -- argument through the map in ascending order of keys.
    --
    -- > let f a k b = (a ++ " " ++ (show k) ++ "-" ++ b, b ++ "X")
    -- > mapAccumWithKey f "Everything:" (fromList [(5,"a"), (3,"b")]) == ("Everything: 3-b 5-a", fromList [(3, "bX"), (5, "aX")])

    mapAccumWithKey :: (a -> Key -> b -> (a,c)) -> a -> IntMap b -> (a,IntMap c)
    mapAccumWithKey :: forall a b c.
    (a -> Key -> b -> (a, c)) -> a -> IntMap b -> (a, IntMap c)
    mapAccumWithKey a -> Key -> b -> (a, c)
    f a
    a IntMap b
    t
      = (a -> Key -> b -> (a, c)) -> a -> IntMap b -> (a, IntMap c)
    forall a b c.
    (a -> Key -> b -> (a, c)) -> a -> IntMap b -> (a, IntMap c)
    mapAccumL a -> Key -> b -> (a, c)
    f a
    a IntMap b
    t

    -- | \(O(n)\). The function @'mapAccumL'@ threads an accumulating
    -- argument through the map in ascending order of keys.  Strict in
    -- the accumulating argument and the both elements of the
    -- result of the function.
    mapAccumL :: (a -> Key -> b -> (a,c)) -> a -> IntMap b -> (a,IntMap c)
    mapAccumL :: forall a b c.
    (a -> Key -> b -> (a, c)) -> a -> IntMap b -> (a, IntMap c)
    mapAccumL a -> Key -> b -> (a, c)
    f0 a
    a0 IntMap b
    t0 = StrictPair a (IntMap c) -> (a, IntMap c)
    forall a b. StrictPair a b -> (a, b)
    toPair (StrictPair a (IntMap c) -> (a, IntMap c))
    -> StrictPair a (IntMap c) -> (a, IntMap c)
    forall a b. (a -> b) -> a -> b
    $ (a -> Key -> b -> (a, c))
    -> a -> IntMap b -> StrictPair a (IntMap c)
    forall {a} {a} {a}.
    (a -> Key -> a -> (a, a))
    -> a -> IntMap a -> StrictPair a (IntMap a)
    go a -> Key -> b -> (a, c)
    f0 a
    a0 IntMap b
    t0
      where
        go :: (a -> Key -> a -> (a, a))
    -> a -> IntMap a -> StrictPair a (IntMap a)
    go a -> Key -> a -> (a, a)
    f a
    a IntMap a
    t
          = case IntMap a
    t of
              Bin Key
    p Key
    m IntMap a
    l IntMap a
    r
                | Key
    m Key -> Key -> Bool
    forall a. Ord a => a -> a -> Bool
    < Key
    0 ->
                    let (a
    a1 :*: IntMap a
    r') = (a -> Key -> a -> (a, a))
    -> a -> IntMap a -> StrictPair a (IntMap a)
    go a -> Key -> a -> (a, a)
    f a
    a IntMap a
    r
                        (a
    a2 :*: IntMap a
    l') = (a -> Key -> a -> (a, a))
    -> a -> IntMap a -> StrictPair a (IntMap a)
    go a -> Key -> a -> (a, a)
    f a
    a1 IntMap a
    l
                    in (a
    a2 a -> IntMap a -> StrictPair a (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin Key
    p Key
    m IntMap a
    l' IntMap a
    r')
                | Bool
    otherwise ->
                    let (a
    a1 :*: IntMap a
    l') = (a -> Key -> a -> (a, a))
    -> a -> IntMap a -> StrictPair a (IntMap a)
    go a -> Key -> a -> (a, a)
    f a
    a IntMap a
    l
                        (a
    a2 :*: IntMap a
    r') = (a -> Key -> a -> (a, a))
    -> a -> IntMap a -> StrictPair a (IntMap a)
    go a -> Key -> a -> (a, a)
    f a
    a1 IntMap a
    r
                    in (a
    a2 a -> IntMap a -> StrictPair a (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin Key
    p Key
    m IntMap a
    l' IntMap a
    r')
              Tip Key
    k a
    x     -> let !(a
    a',!a
    x') = a -> Key -> a -> (a, a)
    f a
    a Key
    k a
    x in (a
    a' a -> IntMap a -> StrictPair a (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    k a
    x')
              IntMap a
    Nil         -> (a
    a a -> IntMap a -> StrictPair a (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: IntMap a
    forall a. IntMap a
    Nil)

    -- | \(O(n)\). The function @'mapAccumRWithKey'@ threads an accumulating
    -- argument through the map in descending order of keys.
    mapAccumRWithKey :: (a -> Key -> b -> (a,c)) -> a -> IntMap b -> (a,IntMap c)
    mapAccumRWithKey :: forall a b c.
    (a -> Key -> b -> (a, c)) -> a -> IntMap b -> (a, IntMap c)
    mapAccumRWithKey a -> Key -> b -> (a, c)
    f0 a
    a0 IntMap b
    t0 = StrictPair a (IntMap c) -> (a, IntMap c)
    forall a b. StrictPair a b -> (a, b)
    toPair (StrictPair a (IntMap c) -> (a, IntMap c))
    -> StrictPair a (IntMap c) -> (a, IntMap c)
    forall a b. (a -> b) -> a -> b
    $ (a -> Key -> b -> (a, c))
    -> a -> IntMap b -> StrictPair a (IntMap c)
    forall {a} {a} {a}.
    (a -> Key -> a -> (a, a))
    -> a -> IntMap a -> StrictPair a (IntMap a)
    go a -> Key -> b -> (a, c)
    f0 a
    a0 IntMap b
    t0
      where
        go :: (a -> Key -> a -> (a, a))
    -> a -> IntMap a -> StrictPair a (IntMap a)
    go a -> Key -> a -> (a, a)
    f a
    a IntMap a
    t
          = case IntMap a
    t of
              Bin Key
    p Key
    m IntMap a
    l IntMap a
    r
                | Key
    m Key -> Key -> Bool
    forall a. Ord a => a -> a -> Bool
    < Key
    0 ->
                  let (a
    a1 :*: IntMap a
    l') = (a -> Key -> a -> (a, a))
    -> a -> IntMap a -> StrictPair a (IntMap a)
    go a -> Key -> a -> (a, a)
    f a
    a IntMap a
    l
                      (a
    a2 :*: IntMap a
    r') = (a -> Key -> a -> (a, a))
    -> a -> IntMap a -> StrictPair a (IntMap a)
    go a -> Key -> a -> (a, a)
    f a
    a1 IntMap a
    r
                  in (a
    a2 a -> IntMap a -> StrictPair a (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin Key
    p Key
    m IntMap a
    l' IntMap a
    r')
                | Bool
    otherwise ->
                  let (a
    a1 :*: IntMap a
    r') = (a -> Key -> a -> (a, a))
    -> a -> IntMap a -> StrictPair a (IntMap a)
    go a -> Key -> a -> (a, a)
    f a
    a IntMap a
    r
                      (a
    a2 :*: IntMap a
    l') = (a -> Key -> a -> (a, a))
    -> a -> IntMap a -> StrictPair a (IntMap a)
    go a -> Key -> a -> (a, a)
    f a
    a1 IntMap a
    l
                  in (a
    a2 a -> IntMap a -> StrictPair a (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin Key
    p Key
    m IntMap a
    l' IntMap a
    r')
              Tip Key
    k a
    x     -> let !(a
    a',!a
    x') = a -> Key -> a -> (a, a)
    f a
    a Key
    k a
    x in (a
    a' a -> IntMap a -> StrictPair a (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    k a
    x')
              IntMap a
    Nil         -> (a
    a a -> IntMap a -> StrictPair a (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: IntMap a
    forall a. IntMap a
    Nil)

    -- | \(O(n \log n)\).
    -- @'mapKeysWith' c f s@ is the map obtained by applying @f@ to each key of @s@.
    --
    -- The size of the result may be smaller if @f@ maps two or more distinct
    -- keys to the same new key.  In this case the associated values will be
    -- combined using @c@.
    --
    -- > mapKeysWith (++) (\ _ -> 1) (fromList [(1,"b"), (2,"a"), (3,"d"), (4,"c")]) == singleton 1 "cdab"
    -- > mapKeysWith (++) (\ _ -> 3) (fromList [(1,"b"), (2,"a"), (3,"d"), (4,"c")]) == singleton 3 "cdab"

    mapKeysWith :: (a -> a -> a) -> (Key->Key) -> IntMap a -> IntMap a
    mapKeysWith :: forall a. (a -> a -> a) -> (Key -> Key) -> IntMap a -> IntMap a
    mapKeysWith a -> a -> a
    c Key -> Key
    f = (a -> a -> a) -> [(Key, a)] -> IntMap a
    forall a. (a -> a -> a) -> [(Key, a)] -> IntMap a
    fromListWith a -> a -> a
    c ([(Key, a)] -> IntMap a)
    -> (IntMap a -> [(Key, a)]) -> IntMap a -> IntMap a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Key -> a -> [(Key, a)] -> [(Key, a)])
    -> [(Key, a)] -> IntMap a -> [(Key, a)]
    forall a b. (Key -> a -> b -> b) -> b -> IntMap a -> b
    foldrWithKey (\Key
    k a
    x [(Key, a)]
    xs -> (Key -> Key
    f Key
    k, a
    x) (Key, a) -> [(Key, a)] -> [(Key, a)]
    forall a. a -> [a] -> [a]
    : [(Key, a)]
    xs) []

    {--------------------------------------------------------------------
      Filter
    --------------------------------------------------------------------}
    -- | \(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 :: (a -> Maybe b) -> IntMap a -> IntMap b
    mapMaybe :: forall a b. (a -> Maybe b) -> IntMap a -> IntMap b
    mapMaybe a -> Maybe b
    f = (Key -> a -> Maybe b) -> IntMap a -> IntMap b
    forall a b. (Key -> a -> Maybe b) -> IntMap a -> IntMap b
    mapMaybeWithKey (\Key
    _ a
    x -> a -> Maybe b
    f a
    x)

    -- | \(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 :: (Key -> a -> Maybe b) -> IntMap a -> IntMap b
    mapMaybeWithKey :: forall a b. (Key -> a -> Maybe b) -> IntMap a -> IntMap b
    mapMaybeWithKey Key -> a -> Maybe b
    f (Bin Key
    p Key
    m IntMap a
    l IntMap a
    r)
      = Key -> Key -> IntMap b -> IntMap b -> IntMap b
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    bin Key
    p Key
    m ((Key -> a -> Maybe b) -> IntMap a -> IntMap b
    forall a b. (Key -> a -> Maybe b) -> IntMap a -> IntMap b
    mapMaybeWithKey Key -> a -> Maybe b
    f IntMap a
    l) ((Key -> a -> Maybe b) -> IntMap a -> IntMap b
    forall a b. (Key -> a -> Maybe b) -> IntMap a -> IntMap b
    mapMaybeWithKey Key -> a -> Maybe b
    f IntMap a
    r)
    mapMaybeWithKey Key -> a -> Maybe b
    f (Tip Key
    k a
    x) = case Key -> a -> Maybe b
    f Key
    k a
    x of
      Just !b
    y  -> Key -> b -> IntMap b
    forall a. Key -> a -> IntMap a
    Tip Key
    k b
    y
      Maybe b
    Nothing -> IntMap b
    forall a. IntMap a
    Nil
    mapMaybeWithKey Key -> a -> Maybe b
    _ IntMap a
    Nil = IntMap b
    forall a. IntMap a
    Nil

    -- | \(O(n)\). Map values and separate the 'Left' and 'Right' results.
    --
    -- > let f a = if a < "c" then Left a else Right a
    -- > mapEither f (fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")])
    -- >     == (fromList [(3,"b"), (5,"a")], fromList [(1,"x"), (7,"z")])
    -- >
    -- > mapEither (\ a -> Right a) (fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")])
    -- >     == (empty, fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")])

    mapEither :: (a -> Either b c) -> IntMap a -> (IntMap b, IntMap c)
    mapEither :: forall a b c. (a -> Either b c) -> IntMap a -> (IntMap b, IntMap c)
    mapEither a -> Either b c
    f IntMap a
    m
      = (Key -> a -> Either b c) -> IntMap a -> (IntMap b, IntMap c)
    forall a b c.
    (Key -> a -> Either b c) -> IntMap a -> (IntMap b, IntMap c)
    mapEitherWithKey (\Key
    _ a
    x -> a -> Either b c
    f a
    x) IntMap a
    m

    -- | \(O(n)\). Map keys\/values and separate the 'Left' and 'Right' results.
    --
    -- > let f k a = if k < 5 then Left (k * 2) else Right (a ++ a)
    -- > mapEitherWithKey f (fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")])
    -- >     == (fromList [(1,2), (3,6)], fromList [(5,"aa"), (7,"zz")])
    -- >
    -- > mapEitherWithKey (\_ a -> Right a) (fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")])
    -- >     == (empty, fromList [(1,"x"), (3,"b"), (5,"a"), (7,"z")])

    mapEitherWithKey :: (Key -> a -> Either b c) -> IntMap a -> (IntMap b, IntMap c)
    mapEitherWithKey :: forall a b c.
    (Key -> a -> Either b c) -> IntMap a -> (IntMap b, IntMap c)
    mapEitherWithKey Key -> a -> Either b c
    f0 IntMap a
    t0 = StrictPair (IntMap b) (IntMap c) -> (IntMap b, IntMap c)
    forall a b. StrictPair a b -> (a, b)
    toPair (StrictPair (IntMap b) (IntMap c) -> (IntMap b, IntMap c))
    -> StrictPair (IntMap b) (IntMap c) -> (IntMap b, IntMap c)
    forall a b. (a -> b) -> a -> b
    $ (Key -> a -> Either b c)
    -> IntMap a -> StrictPair (IntMap b) (IntMap c)
    forall {t} {a} {a}.
    (Key -> t -> Either a a)
    -> IntMap t -> StrictPair (IntMap a) (IntMap a)
    go Key -> a -> Either b c
    f0 IntMap a
    t0
      where
        go :: (Key -> t -> Either a a)
    -> IntMap t -> StrictPair (IntMap a) (IntMap a)
    go Key -> t -> Either a a
    f (Bin Key
    p Key
    m IntMap t
    l IntMap t
    r)
          = Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    bin Key
    p Key
    m IntMap a
    l1 IntMap a
    r1 IntMap a -> IntMap a -> StrictPair (IntMap a) (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    bin Key
    p Key
    m IntMap a
    l2 IntMap a
    r2
          where
            (IntMap a
    l1 :*: IntMap a
    l2) = (Key -> t -> Either a a)
    -> IntMap t -> StrictPair (IntMap a) (IntMap a)
    go Key -> t -> Either a a
    f IntMap t
    l
            (IntMap a
    r1 :*: IntMap a
    r2) = (Key -> t -> Either a a)
    -> IntMap t -> StrictPair (IntMap a) (IntMap a)
    go Key -> t -> Either a a
    f IntMap t
    r
        go Key -> t -> Either a a
    f (Tip Key
    k t
    x) = case Key -> t -> Either a a
    f Key
    k t
    x of
          Left !a
    y  -> (Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    k a
    y IntMap a -> IntMap a -> StrictPair (IntMap a) (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: IntMap a
    forall a. IntMap a
    Nil)
          Right !a
    z -> (IntMap a
    forall a. IntMap a
    Nil IntMap a -> IntMap a -> StrictPair (IntMap a) (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    k a
    z)
        go Key -> t -> Either a a
    _ IntMap t
    Nil = (IntMap a
    forall a. IntMap a
    Nil IntMap a -> IntMap a -> StrictPair (IntMap a) (IntMap a)
    forall a b. a -> b -> StrictPair a b
    :*: IntMap a
    forall a. IntMap a
    Nil)

    {--------------------------------------------------------------------
      Conversions
    --------------------------------------------------------------------}

    -- | \(O(n)\). Build a map from a set of keys and a function which for each key
    -- computes its value.
    --
    -- > fromSet (\k -> replicate k 'a') (Data.IntSet.fromList [3, 5]) == fromList [(5,"aaaaa"), (3,"aaa")]
    -- > fromSet undefined Data.IntSet.empty == empty

    fromSet :: (Key -> a) -> IntSet.IntSet -> IntMap a
    fromSet :: forall a. (Key -> a) -> IntSet -> IntMap a
    fromSet Key -> a
    _ IntSet
    IntSet.Nil = IntMap a
    forall a. IntMap a
    Nil
    fromSet Key -> a
    f (IntSet.Bin Key
    p Key
    m IntSet
    l IntSet
    r) = Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin Key
    p Key
    m ((Key -> a) -> IntSet -> IntMap a
    forall a. (Key -> a) -> IntSet -> IntMap a
    fromSet Key -> a
    f IntSet
    l) ((Key -> a) -> IntSet -> IntMap a
    forall a. (Key -> a) -> IntSet -> IntMap a
    fromSet Key -> a
    f IntSet
    r)
    fromSet Key -> a
    f (IntSet.Tip Key
    kx BitMap
    bm) = (Key -> a) -> Key -> BitMap -> Key -> IntMap a
    forall {a}. (Key -> a) -> Key -> BitMap -> Key -> IntMap a
    buildTree Key -> a
    f Key
    kx BitMap
    bm (Key
    IntSet.suffixBitMask Key -> Key -> Key
    forall a. Num a => a -> a -> a
    + Key
    1)
      where -- This is slightly complicated, as we to convert the dense
            -- representation of IntSet into tree representation of IntMap.
            --
            -- We are given a nonzero bit mask 'bmask' of 'bits' bits with prefix 'prefix'.
            -- We split bmask into halves corresponding to left and right subtree.
            -- If they are both nonempty, we create a Bin node, otherwise exactly
            -- one of them is nonempty and we construct the IntMap from that half.
            buildTree :: (Key -> a) -> Key -> BitMap -> Key -> IntMap a
    buildTree Key -> a
    g !Key
    prefix !BitMap
    bmask Key
    bits = case Key
    bits of
              Key
    0 -> Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    prefix (a -> IntMap a) -> a -> IntMap a
    forall a b. (a -> b) -> a -> b
    $! Key -> a
    g Key
    prefix
              Key
    _ -> case BitMap -> Key
    intFromNat ((Key -> BitMap
    natFromInt Key
    bits) BitMap -> Key -> BitMap
    `shiftRL` Key
    1) of
                     Key
    bits2 | BitMap
    bmask BitMap -> BitMap -> BitMap
    forall a. Bits a => a -> a -> a
    .&. ((BitMap
    1 BitMap -> Key -> BitMap
    `shiftLL` Key
    bits2) BitMap -> BitMap -> BitMap
    forall a. Num a => a -> a -> a
    - BitMap
    1) BitMap -> BitMap -> Bool
    forall a. Eq a => a -> a -> Bool
    == BitMap
    0 ->
                               (Key -> a) -> Key -> BitMap -> Key -> IntMap a
    buildTree Key -> a
    g (Key
    prefix Key -> Key -> Key
    forall a. Num a => a -> a -> a
    + Key
    bits2) (BitMap
    bmask BitMap -> Key -> BitMap
    `shiftRL` Key
    bits2) Key
    bits2
                           | (BitMap
    bmask BitMap -> Key -> BitMap
    `shiftRL` Key
    bits2) BitMap -> BitMap -> BitMap
    forall a. Bits a => a -> a -> a
    .&. ((BitMap
    1 BitMap -> Key -> BitMap
    `shiftLL` Key
    bits2) BitMap -> BitMap -> BitMap
    forall a. Num a => a -> a -> a
    - BitMap
    1) BitMap -> BitMap -> Bool
    forall a. Eq a => a -> a -> Bool
    == BitMap
    0 ->
                               (Key -> a) -> Key -> BitMap -> Key -> IntMap a
    buildTree Key -> a
    g Key
    prefix BitMap
    bmask Key
    bits2
                           | Bool
    otherwise ->
                               Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    Bin Key
    prefix Key
    bits2 ((Key -> a) -> Key -> BitMap -> Key -> IntMap a
    buildTree Key -> a
    g Key
    prefix BitMap
    bmask Key
    bits2) ((Key -> a) -> Key -> BitMap -> Key -> IntMap a
    buildTree Key -> a
    g (Key
    prefix Key -> Key -> Key
    forall a. Num a => a -> a -> a
    + Key
    bits2) (BitMap
    bmask BitMap -> Key -> BitMap
    `shiftRL` Key
    bits2) Key
    bits2)

    {--------------------------------------------------------------------
      Lists
    --------------------------------------------------------------------}
    -- | \(O(n \min(n,W))\). Create a map from a list of key\/value pairs.
    --
    -- > fromList [] == empty
    -- > fromList [(5,"a"), (3,"b"), (5, "c")] == fromList [(5,"c"), (3,"b")]
    -- > fromList [(5,"c"), (3,"b"), (5, "a")] == fromList [(5,"a"), (3,"b")]

    fromList :: [(Key,a)] -> IntMap a
    fromList :: forall a. [(Key, a)] -> IntMap a
    fromList [(Key, a)]
    xs
      = (IntMap a -> (Key, a) -> IntMap a)
    -> IntMap a -> [(Key, a)] -> IntMap a
    forall b a. (b -> a -> b) -> b -> [a] -> b
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    Foldable.foldl' IntMap a -> (Key, a) -> IntMap a
    forall {a}. IntMap a -> (Key, a) -> IntMap a
    ins IntMap a
    forall a. IntMap a
    empty [(Key, a)]
    xs
      where
        ins :: IntMap a -> (Key, a) -> IntMap a
    ins IntMap a
    t (Key
    k,a
    x)  = Key -> a -> IntMap a -> IntMap a
    forall a. Key -> a -> IntMap a -> IntMap a
    insert Key
    k a
    x IntMap a
    t

    -- | \(O(n \min(n,W))\). Create a map from a list of key\/value pairs with a combining function. See also 'fromAscListWith'.
    --
    -- > fromListWith (++) [(5,"a"), (5,"b"), (3,"b"), (3,"a"), (5,"a")] == fromList [(3, "ab"), (5, "aba")]
    -- > fromListWith (++) [] == empty

    fromListWith :: (a -> a -> a) -> [(Key,a)] -> IntMap a
    fromListWith :: forall a. (a -> a -> a) -> [(Key, a)] -> IntMap a
    fromListWith a -> a -> a
    f [(Key, a)]
    xs
      = (Key -> a -> a -> a) -> [(Key, a)] -> IntMap a
    forall a. (Key -> a -> a -> a) -> [(Key, a)] -> IntMap a
    fromListWithKey (\Key
    _ a
    x a
    y -> a -> a -> a
    f a
    x a
    y) [(Key, a)]
    xs

    -- | \(O(n \min(n,W))\). Build a map from a list of key\/value pairs with a combining function. See also fromAscListWithKey'.
    --
    -- > let f key new_value old_value = show key ++ ":" ++ new_value ++ "|" ++ old_value
    -- > fromListWithKey f [(5,"a"), (5,"b"), (3,"b"), (3,"a"), (5,"c")] == fromList [(3, "3:a|b"), (5, "5:c|5:b|a")]
    -- > fromListWithKey f [] == empty

    fromListWithKey :: (Key -> a -> a -> a) -> [(Key,a)] -> IntMap a
    fromListWithKey :: forall a. (Key -> a -> a -> a) -> [(Key, a)] -> IntMap a
    fromListWithKey Key -> a -> a -> a
    f [(Key, a)]
    xs
      = (IntMap a -> (Key, a) -> IntMap a)
    -> IntMap a -> [(Key, a)] -> IntMap a
    forall b a. (b -> a -> b) -> b -> [a] -> b
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    Foldable.foldl' IntMap a -> (Key, a) -> IntMap a
    ins IntMap a
    forall a. IntMap a
    empty [(Key, a)]
    xs
      where
        ins :: IntMap a -> (Key, a) -> IntMap a
    ins IntMap a
    t (Key
    k,a
    x) = (Key -> a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
    forall a. (Key -> a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
    insertWithKey Key -> a -> a -> a
    f Key
    k a
    x IntMap a
    t

    -- | \(O(n)\). Build a map from a list of key\/value pairs where
    -- the keys are in ascending order.
    --
    -- > fromAscList [(3,"b"), (5,"a")]          == fromList [(3, "b"), (5, "a")]
    -- > fromAscList [(3,"b"), (5,"a"), (5,"b")] == fromList [(3, "b"), (5, "b")]

    fromAscList :: [(Key,a)] -> IntMap a
    fromAscList :: forall a. [(Key, a)] -> IntMap a
    fromAscList = Distinct -> (Key -> a -> a -> a) -> [(Key, a)] -> IntMap a
    forall a.
    Distinct -> (Key -> a -> a -> a) -> [(Key, a)] -> IntMap a
    fromMonoListWithKey Distinct
    Nondistinct (\Key
    _ a
    x a
    _ -> a
    x)
    {-# NOINLINE fromAscList #-}

    -- | \(O(n)\). Build a map from a list of key\/value pairs where
    -- the keys are in ascending order, with a combining function on equal keys.
    -- /The precondition (input list is ascending) is not checked./
    --
    -- > fromAscListWith (++) [(3,"b"), (5,"a"), (5,"b")] == fromList [(3, "b"), (5, "ba")]

    fromAscListWith :: (a -> a -> a) -> [(Key,a)] -> IntMap a
    fromAscListWith :: forall a. (a -> a -> a) -> [(Key, a)] -> IntMap a
    fromAscListWith a -> a -> a
    f = Distinct -> (Key -> a -> a -> a) -> [(Key, a)] -> IntMap a
    forall a.
    Distinct -> (Key -> a -> a -> a) -> [(Key, a)] -> IntMap a
    fromMonoListWithKey Distinct
    Nondistinct (\Key
    _ a
    x a
    y -> a -> a -> a
    f a
    x a
    y)
    {-# NOINLINE fromAscListWith #-}

    -- | \(O(n)\). Build a map from a list of key\/value pairs where
    -- the keys are in ascending order, with a combining function on equal keys.
    -- /The precondition (input list is ascending) is not checked./
    --
    -- > fromAscListWith (++) [(3,"b"), (5,"a"), (5,"b")] == fromList [(3, "b"), (5, "ba")]

    fromAscListWithKey :: (Key -> a -> a -> a) -> [(Key,a)] -> IntMap a
    fromAscListWithKey :: forall a. (Key -> a -> a -> a) -> [(Key, a)] -> IntMap a
    fromAscListWithKey Key -> a -> a -> a
    f = Distinct -> (Key -> a -> a -> a) -> [(Key, a)] -> IntMap a
    forall a.
    Distinct -> (Key -> a -> a -> a) -> [(Key, a)] -> IntMap a
    fromMonoListWithKey Distinct
    Nondistinct Key -> a -> a -> a
    f
    {-# NOINLINE fromAscListWithKey #-}

    -- | \(O(n)\). Build a map from a list of key\/value pairs where
    -- the keys are in ascending order and all distinct.
    -- /The precondition (input list is strictly ascending) is not checked./
    --
    -- > fromDistinctAscList [(3,"b"), (5,"a")] == fromList [(3, "b"), (5, "a")]

    fromDistinctAscList :: [(Key,a)] -> IntMap a
    fromDistinctAscList :: forall a. [(Key, a)] -> IntMap a
    fromDistinctAscList = Distinct -> (Key -> a -> a -> a) -> [(Key, a)] -> IntMap a
    forall a.
    Distinct -> (Key -> a -> a -> a) -> [(Key, a)] -> IntMap a
    fromMonoListWithKey Distinct
    Distinct (\Key
    _ a
    x a
    _ -> a
    x)
    {-# NOINLINE fromDistinctAscList #-}

    -- | \(O(n)\). Build a map from a list of key\/value pairs with monotonic keys
    -- and a combining function.
    --
    -- The precise conditions under which this function works are subtle:
    -- For any branch mask, keys with the same prefix w.r.t. the branch
    -- mask must occur consecutively in the list.

    fromMonoListWithKey :: Distinct -> (Key -> a -> a -> a) -> [(Key,a)] -> IntMap a
    fromMonoListWithKey :: forall a.
    Distinct -> (Key -> a -> a -> a) -> [(Key, a)] -> IntMap a
    fromMonoListWithKey Distinct
    distinct Key -> a -> a -> a
    f = [(Key, a)] -> IntMap a
    go
      where
        go :: [(Key, a)] -> IntMap a
    go []              = IntMap a
    forall a. IntMap a
    Nil
        go ((Key
    kx,a
    vx) : [(Key, a)]
    zs1) = Key -> a -> [(Key, a)] -> IntMap a
    addAll' Key
    kx a
    vx [(Key, a)]
    zs1

        -- `addAll'` collects all keys equal to `kx` into a single value,
        -- and then proceeds with `addAll`.
        addAll' :: Key -> a -> [(Key, a)] -> IntMap a
    addAll' !Key
    kx a
    vx []
            = Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    kx (a -> IntMap a) -> a -> IntMap a
    forall a b. (a -> b) -> a -> b
    $! a
    vx
        addAll' !Key
    kx a
    vx ((Key
    ky,a
    vy) : [(Key, a)]
    zs)
            | Distinct
    Nondistinct <- Distinct
    distinct, Key
    kx Key -> Key -> Bool
    forall a. Eq a => a -> a -> Bool
    == Key
    ky
            = let !v :: a
    v = Key -> a -> a -> a
    f Key
    kx a
    vy a
    vx in Key -> a -> [(Key, a)] -> IntMap a
    addAll' Key
    ky a
    v [(Key, a)]
    zs
            -- inlined: | otherwise = addAll kx (Tip kx $! vx) (ky : zs)
            | Key
    m <- Key -> Key -> Key
    branchMask Key
    kx Key
    ky
            , Inserted IntMap a
    ty [(Key, a)]
    zs' <- Key -> Key -> a -> [(Key, a)] -> Inserted a
    addMany' Key
    m Key
    ky a
    vy [(Key, a)]
    zs
            = Key -> IntMap a -> [(Key, a)] -> IntMap a
    addAll Key
    kx (Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    linkWithMask Key
    m Key
    ky IntMap a
    ty {-kx-} (Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    kx (a -> IntMap a) -> a -> IntMap a
    forall a b. (a -> b) -> a -> b
    $! a
    vx)) [(Key, a)]
    zs'

        -- for `addAll` and `addMany`, kx is /a/ key inside the tree `tx`
        -- `addAll` consumes the rest of the list, adding to the tree `tx`
        addAll :: Key -> IntMap a -> [(Key, a)] -> IntMap a
    addAll !Key
    _kx !IntMap a
    tx []
            = IntMap a
    tx
        addAll !Key
    kx !IntMap a
    tx ((Key
    ky,a
    vy) : [(Key, a)]
    zs)
            | Key
    m <- Key -> Key -> Key
    branchMask Key
    kx Key
    ky
            , Inserted IntMap a
    ty [(Key, a)]
    zs' <- Key -> Key -> a -> [(Key, a)] -> Inserted a
    addMany' Key
    m Key
    ky a
    vy [(Key, a)]
    zs
            = Key -> IntMap a -> [(Key, a)] -> IntMap a
    addAll Key
    kx (Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    linkWithMask Key
    m Key
    ky IntMap a
    ty {-kx-} IntMap a
    tx) [(Key, a)]
    zs'

        -- `addMany'` is similar to `addAll'`, but proceeds with `addMany'`.
        addMany' :: Key -> Key -> a -> [(Key, a)] -> Inserted a
    addMany' !Key
    _m !Key
    kx a
    vx []
            = IntMap a -> [(Key, a)] -> Inserted a
    forall a. IntMap a -> [(Key, a)] -> Inserted a
    Inserted (Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    kx (a -> IntMap a) -> a -> IntMap a
    forall a b. (a -> b) -> a -> b
    $! a
    vx) []
        addMany' !Key
    m !Key
    kx a
    vx zs0 :: [(Key, a)]
    zs0@((Key
    ky,a
    vy) : [(Key, a)]
    zs)
            | Distinct
    Nondistinct <- Distinct
    distinct, Key
    kx Key -> Key -> Bool
    forall a. Eq a => a -> a -> Bool
    == Key
    ky
            = let !v :: a
    v = Key -> a -> a -> a
    f Key
    kx a
    vy a
    vx in Key -> Key -> a -> [(Key, a)] -> Inserted a
    addMany' Key
    m Key
    ky a
    v [(Key, a)]
    zs
            -- inlined: | otherwise = addMany m kx (Tip kx $! vx) (ky : zs)
            | Key -> Key -> Key
    mask Key
    kx Key
    m Key -> Key -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Key -> Key -> Key
    mask Key
    ky Key
    m
            = IntMap a -> [(Key, a)] -> Inserted a
    forall a. IntMap a -> [(Key, a)] -> Inserted a
    Inserted (Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    kx (a -> IntMap a) -> a -> IntMap a
    forall a b. (a -> b) -> a -> b
    $! a
    vx) [(Key, a)]
    zs0
            | Key
    mxy <- Key -> Key -> Key
    branchMask Key
    kx Key
    ky
            , Inserted IntMap a
    ty [(Key, a)]
    zs' <- Key -> Key -> a -> [(Key, a)] -> Inserted a
    addMany' Key
    mxy Key
    ky a
    vy [(Key, a)]
    zs
            = Key -> Key -> IntMap a -> [(Key, a)] -> Inserted a
    addMany Key
    m Key
    kx (Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    linkWithMask Key
    mxy Key
    ky IntMap a
    ty {-kx-} (Key -> a -> IntMap a
    forall a. Key -> a -> IntMap a
    Tip Key
    kx (a -> IntMap a) -> a -> IntMap a
    forall a b. (a -> b) -> a -> b
    $! a
    vx)) [(Key, a)]
    zs'

        -- `addAll` adds to `tx` all keys whose prefix w.r.t. `m` agrees with `kx`.
        addMany :: Key -> Key -> IntMap a -> [(Key, a)] -> Inserted a
    addMany !Key
    _m !Key
    _kx IntMap a
    tx []
            = IntMap a -> [(Key, a)] -> Inserted a
    forall a. IntMap a -> [(Key, a)] -> Inserted a
    Inserted IntMap a
    tx []
        addMany !Key
    m !Key
    kx IntMap a
    tx zs0 :: [(Key, a)]
    zs0@((Key
    ky,a
    vy) : [(Key, a)]
    zs)
            | Key -> Key -> Key
    mask Key
    kx Key
    m Key -> Key -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Key -> Key -> Key
    mask Key
    ky Key
    m
            = IntMap a -> [(Key, a)] -> Inserted a
    forall a. IntMap a -> [(Key, a)] -> Inserted a
    Inserted IntMap a
    tx [(Key, a)]
    zs0
            | Key
    mxy <- Key -> Key -> Key
    branchMask Key
    kx Key
    ky
            , Inserted IntMap a
    ty [(Key, a)]
    zs' <- Key -> Key -> a -> [(Key, a)] -> Inserted a
    addMany' Key
    mxy Key
    ky a
    vy [(Key, a)]
    zs
            = Key -> Key -> IntMap a -> [(Key, a)] -> Inserted a
    addMany Key
    m Key
    kx (Key -> Key -> IntMap a -> IntMap a -> IntMap a
    forall a. Key -> Key -> IntMap a -> IntMap a -> IntMap a
    linkWithMask Key
    mxy Key
    ky IntMap a
    ty {-kx-} IntMap a
    tx) [(Key, a)]
    zs'
    {-# INLINE fromMonoListWithKey #-}

    data Inserted a = Inserted !(IntMap a) ![(Key,a)]

    data Distinct = Distinct | Nondistinct