{-# LANGUAGE CPP #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE PatternGuards #-}
#ifdef __GLASGOW_HASKELL__
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeFamilies #-}
#endif
#if !defined(TESTING) && defined(__GLASGOW_HASKELL__)
{-# LANGUAGE Trustworthy #-}
#endif

{-# OPTIONS_HADDOCK not-home #-}
{-# OPTIONS_GHC -fno-warn-incomplete-uni-patterns #-}

#include "containers.h"

-----------------------------------------------------------------------------
-- |
-- Module      :  Data.Word64Map.Internal
-- Copyright   :  (c) Daan Leijen 2002
--                (c) Andriy Palamarchuk 2008
--                (c) wren romano 2016
-- License     :  BSD-style
-- Maintainer  :  libraries@haskell.org
-- Portability :  portable
--
-- = WARNING
--
-- This module is considered __internal__.
--
-- The Package Versioning Policy __does not apply__.
--
-- The contents of this module may change __in any way whatsoever__
-- and __without any warning__ between minor versions of this package.
--
-- Authors importing this module are expected to track development
-- closely.
--
-- = Description
--
-- This defines the data structures and core (hidden) manipulations
-- on representations.
--
-- @since 0.5.9
-----------------------------------------------------------------------------

-- [Note: INLINE bit fiddling]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- It is essential that the bit fiddling functions like mask, zero, branchMask
-- etc are inlined. If they do not, the memory allocation skyrockets. The GHC
-- usually gets it right, but it is disastrous if it does not. Therefore we
-- explicitly mark these functions INLINE.


-- [Note: Local 'go' functions and capturing]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Care must be taken when using 'go' function which captures an argument.
-- Sometimes (for example when the argument is passed to a data constructor,
-- as in insert), GHC heap-allocates more than necessary. Therefore C-- code
-- must be checked for increased allocation when creating and modifying such
-- functions.


-- [Note: Order of constructors]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- The order of constructors of Word64Map matters when considering performance.
-- Currently in GHC 7.0, when type has 3 constructors, they are matched from
-- the first to the last -- the best performance is achieved when the
-- constructors are ordered by frequency.
-- On GHC 7.0, reordering constructors from Nil | Tip | Bin to Bin | Tip | Nil
-- improves the benchmark by circa 10%.
--

module GHC.Data.Word64Map.Internal (
    -- * Map type
      Word64Map(..), Key          -- instance Eq,Show

    -- * Operators
    , (!), (!?), (\\)

    -- * Query
    , null
    , size
    , member
    , notMember
    , lookup
    , findWithDefault
    , lookupLT
    , lookupGT
    , lookupLE
    , lookupGE
    , disjoint

    -- * Construction
    , empty
    , singleton

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

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

    -- * Combine

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

    -- ** Difference
    , difference
    , differenceWith
    , differenceWithKey

    -- ** Intersection
    , intersection
    , intersectionWith
    , intersectionWithKey

    -- ** Compose
    , compose

    -- ** General combining function
    , SimpleWhenMissing
    , SimpleWhenMatched
    , runWhenMatched
    , runWhenMissing
    , merge
    -- *** @WhenMatched@ tactics
    , zipWithMaybeMatched
    , zipWithMatched
    -- *** @WhenMissing@ tactics
    , mapMaybeMissing
    , dropMissing
    , preserveMissing
    , mapMissing
    , filterMissing

    -- ** Applicative general combining function
    , WhenMissing (..)
    , WhenMatched (..)
    , mergeA
    -- *** @WhenMatched@ tactics
    -- | The tactics described for 'merge' work for
    -- 'mergeA' as well. Furthermore, the following
    -- are available.
    , zipWithMaybeAMatched
    , zipWithAMatched
    -- *** @WhenMissing@ tactics
    -- | The tactics described for 'merge' work for
    -- 'mergeA' as well. Furthermore, the following
    -- are available.
    , traverseMaybeMissing
    , traverseMissing
    , filterAMissing

    -- ** Deprecated general combining function
    , mergeWithKey
    , 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
    , fromSet

    -- ** Lists
    , toList
    , fromList
    , fromListWith
    , fromListWithKey

    -- ** Ordered lists
    , toAscList
    , toDescList
    , fromAscList
    , fromAscListWith
    , fromAscListWithKey
    , fromDistinctAscList

    -- * 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

    -- * Debugging
    , showTree
    , showTreeWith

    -- * Internal types
    , Mask, Prefix, Nat

    -- * Utility
    , natFromInt
    , intFromNat
    , link
    , linkWithMask
    , bin
    , binCheckLeft
    , binCheckRight
    , zero
    , nomatch
    , match
    , mask
    , maskW
    , shorter
    , branchMask
    , highestBitMask

    -- * Used by "Word64Map.Merge.Lazy" and "Word64Map.Merge.Strict"
    , mapWhenMissing
    , mapWhenMatched
    , lmapWhenMissing
    , contramapFirstWhenMatched
    , contramapSecondWhenMatched
    , mapGentlyWhenMissing
    , mapGentlyWhenMatched
    ) where

import GHC.Prelude.Basic hiding
  (lookup, filter, foldr, foldl, foldl', null, map)

import Data.Functor.Identity (Identity (..))
import Data.Semigroup (Semigroup(stimes,(<>)),stimesIdempotentMonoid)
import Data.Functor.Classes

import Control.DeepSeq (NFData(rnf))
import qualified Data.Foldable as Foldable
import Data.Maybe (fromMaybe)

import GHC.Data.Word64Set.Internal (Key)
import qualified GHC.Data.Word64Set.Internal as Word64Set
import GHC.Utils.Containers.Internal.BitUtil
import GHC.Utils.Containers.Internal.StrictPair

#ifdef __GLASGOW_HASKELL__
import Data.Coerce
import Data.Data (Data(..), Constr, mkConstr, constrIndex, Fixity(Prefix),
                  DataType, mkDataType, gcast1)
import GHC.Exts (build)
import qualified GHC.Exts as GHCExts
import Text.Read
#endif
import qualified Control.Category as Category
import Data.Word


-- A "Nat" is a 64 bit machine word (an unsigned Int64)
type Nat = Word64

natFromInt :: Key -> Nat
natFromInt :: Word64 -> Word64
natFromInt = Word64 -> Word64
forall a. a -> a
id
{-# INLINE natFromInt #-}

intFromNat :: Nat -> Key
intFromNat :: Word64 -> Word64
intFromNat = Word64 -> Word64
forall a. a -> a
id
{-# INLINE intFromNat #-}

{--------------------------------------------------------------------
  Types
--------------------------------------------------------------------}


-- | A map of integers to values @a@.

-- See Note: Order of constructors
data Word64Map a = Bin {-# UNPACK #-} !Prefix
                    {-# UNPACK #-} !Mask
                    !(Word64Map a)
                    !(Word64Map a)
-- Fields:
--   prefix: The most significant bits shared by all keys in this Bin.
--   mask: The switching bit to determine if a key should follow the left
--         or right subtree of a 'Bin'.
-- Invariant: Nil is never found as a child of Bin.
-- Invariant: The Mask is a power of 2. It is the largest bit position at which
--            two keys of the map differ.
-- Invariant: Prefix is the common high-order bits that all elements share to
--            the left of the Mask bit.
-- Invariant: In (Bin prefix mask left right), left consists of the elements that
--            don't have the mask bit set; right is all the elements that do.
              | Tip {-# UNPACK #-} !Key a
              | Nil

type Prefix = Word64
type Mask   = Word64


-- Some stuff from "Data.Word64Set.Internal", for 'restrictKeys' and
-- 'withoutKeys' to use.
type Word64SetPrefix = Word64
type Word64SetBitMap = Word64

bitmapOf :: Word64 -> Word64SetBitMap
bitmapOf :: Word64 -> Word64
bitmapOf Word64
x = Word64 -> Int -> Word64
shiftLL Word64
1 (Word64 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word64
x Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. Word64
Word64Set.suffixBitMask))
{-# INLINE bitmapOf #-}

{--------------------------------------------------------------------
  Operators
--------------------------------------------------------------------}

-- | \(O(\min(n,W))\). Find the value at a key.
-- Calls 'error' when the element can not be found.
--
-- > fromList [(5,'a'), (3,'b')] ! 1    Error: element not in the map
-- > fromList [(5,'a'), (3,'b')] ! 5 == 'a'

(!) :: Word64Map a -> Key -> a
! :: forall a. Word64Map a -> Word64 -> a
(!) Word64Map a
m Word64
k = Word64 -> Word64Map a -> a
forall a. Word64 -> Word64Map a -> a
find Word64
k Word64Map a
m

-- | \(O(\min(n,W))\). Find the value at a key.
-- Returns 'Nothing' when the element can not be found.
--
-- > fromList [(5,'a'), (3,'b')] !? 1 == Nothing
-- > fromList [(5,'a'), (3,'b')] !? 5 == Just 'a'
--
-- @since 0.5.11

(!?) :: Word64Map a -> Key -> Maybe a
!? :: forall a. Word64Map a -> Word64 -> Maybe a
(!?) Word64Map a
m Word64
k = Word64 -> Word64Map a -> Maybe a
forall a. Word64 -> Word64Map a -> Maybe a
lookup Word64
k Word64Map a
m

-- | Same as 'difference'.
(\\) :: Word64Map a -> Word64Map b -> Word64Map a
Word64Map a
m1 \\ :: forall a b. Word64Map a -> Word64Map b -> Word64Map a
\\ Word64Map b
m2 = Word64Map a -> Word64Map b -> Word64Map a
forall a b. Word64Map a -> Word64Map b -> Word64Map a
difference Word64Map a
m1 Word64Map b
m2

infixl 9 !?,\\{-This comment teaches CPP correct behaviour -}

{--------------------------------------------------------------------
  Types
--------------------------------------------------------------------}

instance Monoid (Word64Map a) where
    mempty :: Word64Map a
mempty  = Word64Map a
forall a. Word64Map a
empty
    mconcat :: [Word64Map a] -> Word64Map a
mconcat = [Word64Map a] -> Word64Map a
forall (f :: * -> *) a.
Foldable f =>
f (Word64Map a) -> Word64Map a
unions
    mappend :: Word64Map a -> Word64Map a -> Word64Map a
mappend = Word64Map a -> Word64Map a -> Word64Map a
forall a. Semigroup a => a -> a -> a
(<>)

-- | @since 0.5.7
instance Semigroup (Word64Map a) where
    <> :: Word64Map a -> Word64Map a -> Word64Map a
(<>)    = Word64Map a -> Word64Map a -> Word64Map a
forall a. Word64Map a -> Word64Map a -> Word64Map a
union
    stimes :: forall b. Integral b => b -> Word64Map a -> Word64Map a
stimes  = b -> Word64Map a -> Word64Map a
forall b a. (Integral b, Monoid a) => b -> a -> a
stimesIdempotentMonoid

-- | Folds in order of increasing key.
instance Foldable.Foldable Word64Map where
  fold :: forall m. Monoid m => Word64Map m -> m
fold = Word64Map m -> m
forall m. Monoid m => Word64Map m -> m
go
    where go :: Word64Map a -> a
go Word64Map a
Nil = a
forall a. Monoid a => a
mempty
          go (Tip Word64
_ a
v) = a
v
          go (Bin Word64
_ Word64
m Word64Map a
l Word64Map a
r)
            | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0     = Word64Map a -> a
go Word64Map a
r a -> a -> a
forall a. Monoid a => a -> a -> a
`mappend` Word64Map a -> a
go Word64Map a
l
            | Bool
otherwise = Word64Map a -> a
go Word64Map a
l a -> a -> a
forall a. Monoid a => a -> a -> a
`mappend` Word64Map a -> a
go Word64Map a
r
  {-# INLINABLE fold #-}
  foldr :: forall a b. (a -> b -> b) -> b -> Word64Map a -> b
foldr = (a -> b -> b) -> b -> Word64Map a -> b
forall a b. (a -> b -> b) -> b -> Word64Map a -> b
foldr
  {-# INLINE foldr #-}
  foldl :: forall b a. (b -> a -> b) -> b -> Word64Map a -> b
foldl = (b -> a -> b) -> b -> Word64Map a -> b
forall b a. (b -> a -> b) -> b -> Word64Map a -> b
foldl
  {-# INLINE foldl #-}
  foldMap :: forall m a. Monoid m => (a -> m) -> Word64Map a -> m
foldMap a -> m
f Word64Map a
t = Word64Map a -> m
go Word64Map a
t
    where go :: Word64Map a -> m
go Word64Map a
Nil = m
forall a. Monoid a => a
mempty
          go (Tip Word64
_ a
v) = a -> m
f a
v
          go (Bin Word64
_ Word64
m Word64Map a
l Word64Map a
r)
            | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0     = Word64Map a -> m
go Word64Map a
r m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` Word64Map a -> m
go Word64Map a
l
            | Bool
otherwise = Word64Map a -> m
go Word64Map a
l m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` Word64Map a -> m
go Word64Map a
r
  {-# INLINE foldMap #-}
  foldl' :: forall b a. (b -> a -> b) -> b -> Word64Map a -> b
foldl' = (b -> a -> b) -> b -> Word64Map a -> b
forall b a. (b -> a -> b) -> b -> Word64Map a -> b
foldl'
  {-# INLINE foldl' #-}
  foldr' :: forall a b. (a -> b -> b) -> b -> Word64Map a -> b
foldr' = (a -> b -> b) -> b -> Word64Map a -> b
forall a b. (a -> b -> b) -> b -> Word64Map a -> b
foldr'
  {-# INLINE foldr' #-}
  length :: forall a. Word64Map a -> Int
length = Word64Map a -> Int
forall a. Word64Map a -> Int
size
  {-# INLINE length #-}
  null :: forall a. Word64Map a -> Bool
null   = Word64Map a -> Bool
forall a. Word64Map a -> Bool
null
  {-# INLINE null #-}
  toList :: forall a. Word64Map a -> [a]
toList = Word64Map a -> [a]
forall a. Word64Map a -> [a]
elems -- NB: Foldable.toList /= Word64Map.toList
  {-# INLINE toList #-}
  elem :: forall a. Eq a => a -> Word64Map a -> Bool
elem = a -> Word64Map a -> Bool
forall a. Eq a => a -> Word64Map a -> Bool
go
    where go :: t -> Word64Map t -> Bool
go !t
_ Word64Map t
Nil = Bool
False
          go t
x (Tip Word64
_ t
y) = t
x t -> t -> Bool
forall a. Eq a => a -> a -> Bool
== t
y
          go t
x (Bin Word64
_ Word64
_ Word64Map t
l Word64Map t
r) = t -> Word64Map t -> Bool
go t
x Word64Map t
l Bool -> Bool -> Bool
|| t -> Word64Map t -> Bool
go t
x Word64Map t
r
  {-# INLINABLE elem #-}
  maximum :: forall a. Ord a => Word64Map a -> a
maximum = Word64Map a -> a
forall a. Ord a => Word64Map a -> a
start
    where start :: Word64Map a -> a
start Word64Map a
Nil = [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"Data.Foldable.maximum (for Data.Word64Map): empty map"
          start (Tip Word64
_ a
y) = a
y
          start (Bin Word64
_ Word64
m Word64Map a
l Word64Map a
r)
            | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0     = a -> Word64Map a -> a
forall {t}. Ord t => t -> Word64Map t -> t
go (Word64Map a -> a
start Word64Map a
r) Word64Map a
l
            | Bool
otherwise = a -> Word64Map a -> a
forall {t}. Ord t => t -> Word64Map t -> t
go (Word64Map a -> a
start Word64Map a
l) Word64Map a
r

          go :: t -> Word64Map t -> t
go !t
m Word64Map t
Nil = t
m
          go t
m (Tip Word64
_ t
y) = t -> t -> t
forall a. Ord a => a -> a -> a
max t
m t
y
          go t
m (Bin Word64
_ Word64
_ Word64Map t
l Word64Map t
r) = t -> Word64Map t -> t
go (t -> Word64Map t -> t
go t
m Word64Map t
l) Word64Map t
r
  {-# INLINABLE maximum #-}
  minimum :: forall a. Ord a => Word64Map a -> a
minimum = Word64Map a -> a
forall a. Ord a => Word64Map a -> a
start
    where start :: Word64Map a -> a
start Word64Map a
Nil = [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"Data.Foldable.minimum (for Data.Word64Map): empty map"
          start (Tip Word64
_ a
y) = a
y
          start (Bin Word64
_ Word64
m Word64Map a
l Word64Map a
r)
            | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0     = a -> Word64Map a -> a
forall {t}. Ord t => t -> Word64Map t -> t
go (Word64Map a -> a
start Word64Map a
r) Word64Map a
l
            | Bool
otherwise = a -> Word64Map a -> a
forall {t}. Ord t => t -> Word64Map t -> t
go (Word64Map a -> a
start Word64Map a
l) Word64Map a
r

          go :: t -> Word64Map t -> t
go !t
m Word64Map t
Nil = t
m
          go t
m (Tip Word64
_ t
y) = t -> t -> t
forall a. Ord a => a -> a -> a
min t
m t
y
          go t
m (Bin Word64
_ Word64
_ Word64Map t
l Word64Map t
r) = t -> Word64Map t -> t
go (t -> Word64Map t -> t
go t
m Word64Map t
l) Word64Map t
r
  {-# INLINABLE minimum #-}
  sum :: forall a. Num a => Word64Map a -> a
sum = (a -> a -> a) -> a -> Word64Map a -> a
forall b a. (b -> a -> b) -> b -> Word64Map a -> b
foldl' a -> a -> a
forall a. Num a => a -> a -> a
(+) a
0
  {-# INLINABLE sum #-}
  product :: forall a. Num a => Word64Map a -> a
product = (a -> a -> a) -> a -> Word64Map a -> a
forall b a. (b -> a -> b) -> b -> Word64Map a -> b
foldl' a -> a -> a
forall a. Num a => a -> a -> a
(*) a
1
  {-# INLINABLE product #-}

-- | Traverses in order of increasing key.
instance Traversable Word64Map where
    traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Word64Map a -> f (Word64Map b)
traverse a -> f b
f = (Word64 -> a -> f b) -> Word64Map a -> f (Word64Map b)
forall (t :: * -> *) a b.
Applicative t =>
(Word64 -> a -> t b) -> Word64Map a -> t (Word64Map b)
traverseWithKey (\Word64
_ -> a -> f b
f)
    {-# INLINE traverse #-}

instance NFData a => NFData (Word64Map a) where
    rnf :: Word64Map a -> ()
rnf Word64Map a
Nil = ()
    rnf (Tip Word64
_ a
v) = a -> ()
forall a. NFData a => a -> ()
rnf a
v
    rnf (Bin Word64
_ Word64
_ Word64Map a
l Word64Map a
r) = Word64Map a -> ()
forall a. NFData a => a -> ()
rnf Word64Map a
l () -> () -> ()
forall a b. a -> b -> b
`seq` Word64Map a -> ()
forall a. NFData a => a -> ()
rnf Word64Map a
r

#if __GLASGOW_HASKELL__

{--------------------------------------------------------------------
  A Data instance
--------------------------------------------------------------------}

-- This instance preserves data abstraction at the cost of inefficiency.
-- We provide limited reflection services for the sake of data abstraction.

instance Data a => Data (Word64Map a) where
  gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Word64Map a -> c (Word64Map a)
gfoldl forall d b. Data d => c (d -> b) -> d -> c b
f forall g. g -> c g
z Word64Map a
im = ([(Word64, a)] -> Word64Map a) -> c ([(Word64, a)] -> Word64Map a)
forall g. g -> c g
z [(Word64, a)] -> Word64Map a
forall a. [(Word64, a)] -> Word64Map a
fromList c ([(Word64, a)] -> Word64Map a)
-> [(Word64, a)] -> c (Word64Map a)
forall d b. Data d => c (d -> b) -> d -> c b
`f` (Word64Map a -> [(Word64, a)]
forall a. Word64Map a -> [(Word64, a)]
toList Word64Map a
im)
  toConstr :: Word64Map a -> Constr
toConstr Word64Map a
_     = Constr
fromListConstr
  gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Word64Map a)
gunfold forall b r. Data b => c (b -> r) -> c r
k forall r. r -> c r
z Constr
c  = case Constr -> Int
constrIndex Constr
c of
    Int
1 -> c ([(Word64, a)] -> Word64Map a) -> c (Word64Map a)
forall b r. Data b => c (b -> r) -> c r
k (([(Word64, a)] -> Word64Map a) -> c ([(Word64, a)] -> Word64Map a)
forall r. r -> c r
z [(Word64, a)] -> Word64Map a
forall a. [(Word64, a)] -> Word64Map a
fromList)
    Int
_ -> [Char] -> c (Word64Map a)
forall a. HasCallStack => [Char] -> a
error [Char]
"gunfold"
  dataTypeOf :: Word64Map a -> DataType
dataTypeOf Word64Map a
_   = DataType
intMapDataType
  dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Word64Map a))
dataCast1 forall d. Data d => c (t d)
f    = c (t a) -> Maybe (c (Word64Map a))
forall {k1} {k2} (c :: k1 -> *) (t :: k2 -> k1) (t' :: k2 -> k1)
       (a :: k2).
(Typeable t, Typeable t') =>
c (t a) -> Maybe (c (t' a))
gcast1 c (t a)
forall d. Data d => c (t d)
f

fromListConstr :: Constr
fromListConstr :: Constr
fromListConstr = DataType -> [Char] -> [[Char]] -> Fixity -> Constr
mkConstr DataType
intMapDataType [Char]
"fromList" [] Fixity
Prefix

intMapDataType :: DataType
intMapDataType :: DataType
intMapDataType = [Char] -> [Constr] -> DataType
mkDataType [Char]
"Data.Word64Map.Internal.Word64Map" [Constr
fromListConstr]

#endif

{--------------------------------------------------------------------
  Query
--------------------------------------------------------------------}
-- | \(O(1)\). Is the map empty?
--
-- > Data.Word64Map.null (empty)           == True
-- > Data.Word64Map.null (singleton 1 'a') == False

null :: Word64Map a -> Bool
null :: forall a. Word64Map a -> Bool
null Word64Map a
Nil = Bool
True
null Word64Map a
_   = Bool
False
{-# INLINE null #-}

-- | \(O(n)\). Number of elements in the map.
--
-- > size empty                                   == 0
-- > size (singleton 1 'a')                       == 1
-- > size (fromList([(1,'a'), (2,'c'), (3,'b')])) == 3
size :: Word64Map a -> Int
size :: forall a. Word64Map a -> Int
size = Int -> Word64Map a -> Int
forall {t} {a}. Num t => t -> Word64Map a -> t
go Int
0
  where
    go :: t -> Word64Map a -> t
go !t
acc (Bin Word64
_ Word64
_ Word64Map a
l Word64Map a
r) = t -> Word64Map a -> t
go (t -> Word64Map a -> t
go t
acc Word64Map a
l) Word64Map a
r
    go t
acc (Tip Word64
_ a
_) = t
1 t -> t -> t
forall a. Num a => a -> a -> a
+ t
acc
    go t
acc Word64Map a
Nil = t
acc

-- | \(O(\min(n,W))\). Is the key a member of the map?
--
-- > member 5 (fromList [(5,'a'), (3,'b')]) == True
-- > member 1 (fromList [(5,'a'), (3,'b')]) == False

-- See Note: Local 'go' functions and capturing]
member :: Key -> Word64Map a -> Bool
member :: forall a. Word64 -> Word64Map a -> Bool
member !Word64
k = Word64Map a -> Bool
go
  where
    go :: Word64Map a -> Bool
go (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r) | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
k Word64
p Word64
m = Bool
False
                     | Word64 -> Word64 -> Bool
zero Word64
k Word64
m  = Word64Map a -> Bool
go Word64Map a
l
                     | Bool
otherwise = Word64Map a -> Bool
go Word64Map a
r
    go (Tip Word64
kx a
_) = Word64
k Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
kx
    go Word64Map a
Nil = Bool
False

-- | \(O(\min(n,W))\). Is the key not a member of the map?
--
-- > notMember 5 (fromList [(5,'a'), (3,'b')]) == False
-- > notMember 1 (fromList [(5,'a'), (3,'b')]) == True

notMember :: Key -> Word64Map a -> Bool
notMember :: forall a. Word64 -> Word64Map a -> Bool
notMember Word64
k Word64Map a
m = Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Word64 -> Word64Map a -> Bool
forall a. Word64 -> Word64Map a -> Bool
member Word64
k Word64Map a
m

-- | \(O(\min(n,W))\). Lookup the value at a key in the map. See also 'Data.Map.lookup'.

-- See Note: Local 'go' functions and capturing
lookup :: Key -> Word64Map a -> Maybe a
lookup :: forall a. Word64 -> Word64Map a -> Maybe a
lookup !Word64
k = Word64Map a -> Maybe a
go
  where
    go :: Word64Map a -> Maybe a
go (Bin Word64
_p Word64
m Word64Map a
l Word64Map a
r) | Word64 -> Word64 -> Bool
zero Word64
k Word64
m  = Word64Map a -> Maybe a
go Word64Map a
l
                      | Bool
otherwise = Word64Map a -> Maybe a
go Word64Map a
r
    go (Tip Word64
kx a
x) | Word64
k Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
kx   = a -> Maybe a
forall a. a -> Maybe a
Just a
x
                  | Bool
otherwise = Maybe a
forall a. Maybe a
Nothing
    go Word64Map a
Nil = Maybe a
forall a. Maybe a
Nothing

-- See Note: Local 'go' functions and capturing]
find :: Key -> Word64Map a -> a
find :: forall a. Word64 -> Word64Map a -> a
find !Word64
k = Word64Map a -> a
go
  where
    go :: Word64Map a -> a
go (Bin Word64
_p Word64
m Word64Map a
l Word64Map a
r) | Word64 -> Word64 -> Bool
zero Word64
k Word64
m  = Word64Map a -> a
go Word64Map a
l
                      | Bool
otherwise = Word64Map a -> a
go Word64Map a
r
    go (Tip Word64
kx a
x) | Word64
k Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
kx   = a
x
                  | Bool
otherwise = a
not_found
    go Word64Map a
Nil = a
not_found

    not_found :: a
not_found = [Char] -> a
forall a. HasCallStack => [Char] -> a
error ([Char]
"Word64Map.!: key " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Word64 -> [Char]
forall a. Show a => a -> [Char]
show Word64
k [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" is not an element of the map")

-- | \(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 Note: Local 'go' functions and capturing]
findWithDefault :: a -> Key -> Word64Map a -> a
findWithDefault :: forall a. a -> Word64 -> Word64Map a -> a
findWithDefault a
def !Word64
k = Word64Map a -> a
go
  where
    go :: Word64Map a -> a
go (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r) | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
k Word64
p Word64
m = a
def
                     | Word64 -> Word64 -> Bool
zero Word64
k Word64
m  = Word64Map a -> a
go Word64Map a
l
                     | Bool
otherwise = Word64Map a -> a
go Word64Map a
r
    go (Tip Word64
kx a
x) | Word64
k Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
kx   = a
x
                  | Bool
otherwise = a
def
    go Word64Map a
Nil = a
def

-- | \(O(\min(n,W))\). Find largest key smaller than the given one and return the
-- corresponding (key, value) pair.
--
-- > lookupLT 3 (fromList [(3,'a'), (5,'b')]) == Nothing
-- > lookupLT 4 (fromList [(3,'a'), (5,'b')]) == Just (3, 'a')

-- See Note: Local 'go' functions and capturing.
lookupLT :: Key -> Word64Map a -> Maybe (Key, a)
lookupLT :: forall a. Word64 -> Word64Map a -> Maybe (Word64, a)
lookupLT !Word64
k Word64Map a
t = case Word64Map a
t of
    Bin Word64
_ Word64
m Word64Map a
l Word64Map a
r | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 -> if Word64
k Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
>= Word64
0 then Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
r Word64Map a
l else Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
forall a. Word64Map a
Nil Word64Map a
r
    Word64Map a
_ -> Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
forall a. Word64Map a
Nil Word64Map a
t
  where
    go :: Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
def (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
      | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
k Word64
p Word64
m = if Word64
k Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
p then Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMax Word64Map a
def else Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMax Word64Map a
r
      | Word64 -> Word64 -> Bool
zero Word64
k Word64
m  = Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
def Word64Map a
l
      | Bool
otherwise = Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
l Word64Map a
r
    go Word64Map a
def (Tip Word64
ky a
y)
      | Word64
k Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word64
ky   = Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMax Word64Map a
def
      | Bool
otherwise = (Word64, a) -> Maybe (Word64, a)
forall a. a -> Maybe a
Just (Word64
ky, a
y)
    go Word64Map a
def Word64Map a
Nil = Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMax Word64Map a
def

-- | \(O(\min(n,W))\). Find smallest key greater than the given one and return the
-- corresponding (key, value) pair.
--
-- > lookupGT 4 (fromList [(3,'a'), (5,'b')]) == Just (5, 'b')
-- > lookupGT 5 (fromList [(3,'a'), (5,'b')]) == Nothing

-- See Note: Local 'go' functions and capturing.
lookupGT :: Key -> Word64Map a -> Maybe (Key, a)
lookupGT :: forall a. Word64 -> Word64Map a -> Maybe (Word64, a)
lookupGT !Word64
k Word64Map a
t = case Word64Map a
t of
    Bin Word64
_ Word64
m Word64Map a
l Word64Map a
r | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 -> if Word64
k Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
>= Word64
0 then Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
forall a. Word64Map a
Nil Word64Map a
l else Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
l Word64Map a
r
    Word64Map a
_ -> Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
forall a. Word64Map a
Nil Word64Map a
t
  where
    go :: Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
def (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
      | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
k Word64
p Word64
m = if Word64
k Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
p then Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMin Word64Map a
l else Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMin Word64Map a
def
      | Word64 -> Word64 -> Bool
zero Word64
k Word64
m  = Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
r Word64Map a
l
      | Bool
otherwise = Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
def Word64Map a
r
    go Word64Map a
def (Tip Word64
ky a
y)
      | Word64
k Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
>= Word64
ky   = Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMin Word64Map a
def
      | Bool
otherwise = (Word64, a) -> Maybe (Word64, a)
forall a. a -> Maybe a
Just (Word64
ky, a
y)
    go Word64Map a
def Word64Map a
Nil = Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMin Word64Map a
def

-- | \(O(\min(n,W))\). Find largest key smaller or equal to the given one and return
-- the corresponding (key, value) pair.
--
-- > lookupLE 2 (fromList [(3,'a'), (5,'b')]) == Nothing
-- > lookupLE 4 (fromList [(3,'a'), (5,'b')]) == Just (3, 'a')
-- > lookupLE 5 (fromList [(3,'a'), (5,'b')]) == Just (5, 'b')

-- See Note: Local 'go' functions and capturing.
lookupLE :: Key -> Word64Map a -> Maybe (Key, a)
lookupLE :: forall a. Word64 -> Word64Map a -> Maybe (Word64, a)
lookupLE !Word64
k Word64Map a
t = case Word64Map a
t of
    Bin Word64
_ Word64
m Word64Map a
l Word64Map a
r | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 -> if Word64
k Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
>= Word64
0 then Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
r Word64Map a
l else Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
forall a. Word64Map a
Nil Word64Map a
r
    Word64Map a
_ -> Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
forall a. Word64Map a
Nil Word64Map a
t
  where
    go :: Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
def (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
      | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
k Word64
p Word64
m = if Word64
k Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
p then Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMax Word64Map a
def else Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMax Word64Map a
r
      | Word64 -> Word64 -> Bool
zero Word64
k Word64
m  = Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
def Word64Map a
l
      | Bool
otherwise = Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
l Word64Map a
r
    go Word64Map a
def (Tip Word64
ky a
y)
      | Word64
k Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
ky    = Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMax Word64Map a
def
      | Bool
otherwise = (Word64, a) -> Maybe (Word64, a)
forall a. a -> Maybe a
Just (Word64
ky, a
y)
    go Word64Map a
def Word64Map a
Nil = Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMax Word64Map a
def

-- | \(O(\min(n,W))\). Find smallest key greater or equal to the given one and return
-- the corresponding (key, value) pair.
--
-- > lookupGE 3 (fromList [(3,'a'), (5,'b')]) == Just (3, 'a')
-- > lookupGE 4 (fromList [(3,'a'), (5,'b')]) == Just (5, 'b')
-- > lookupGE 6 (fromList [(3,'a'), (5,'b')]) == Nothing

-- See Note: Local 'go' functions and capturing.
lookupGE :: Key -> Word64Map a -> Maybe (Key, a)
lookupGE :: forall a. Word64 -> Word64Map a -> Maybe (Word64, a)
lookupGE !Word64
k Word64Map a
t = case Word64Map a
t of
    Bin Word64
_ Word64
m Word64Map a
l Word64Map a
r | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 -> if Word64
k Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
>= Word64
0 then Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
forall a. Word64Map a
Nil Word64Map a
l else Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
l Word64Map a
r
    Word64Map a
_ -> Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
forall a. Word64Map a
Nil Word64Map a
t
  where
    go :: Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
def (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
      | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
k Word64
p Word64
m = if Word64
k Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
p then Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMin Word64Map a
l else Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMin Word64Map a
def
      | Word64 -> Word64 -> Bool
zero Word64
k Word64
m  = Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
r Word64Map a
l
      | Bool
otherwise = Word64Map a -> Word64Map a -> Maybe (Word64, a)
go Word64Map a
def Word64Map a
r
    go Word64Map a
def (Tip Word64
ky a
y)
      | Word64
k Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
> Word64
ky    = Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMin Word64Map a
def
      | Bool
otherwise = (Word64, a) -> Maybe (Word64, a)
forall a. a -> Maybe a
Just (Word64
ky, a
y)
    go Word64Map a
def Word64Map a
Nil = Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMin Word64Map a
def


-- Helper function for lookupGE and lookupGT. It assumes that if a Bin node is
-- given, it has m > 0.
unsafeFindMin :: Word64Map a -> Maybe (Key, a)
unsafeFindMin :: forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMin Word64Map a
Nil = Maybe (Word64, a)
forall a. Maybe a
Nothing
unsafeFindMin (Tip Word64
ky a
y) = (Word64, a) -> Maybe (Word64, a)
forall a. a -> Maybe a
Just (Word64
ky, a
y)
unsafeFindMin (Bin Word64
_ Word64
_ Word64Map a
l Word64Map a
_) = Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMin Word64Map a
l

-- Helper function for lookupLE and lookupLT. It assumes that if a Bin node is
-- given, it has m > 0.
unsafeFindMax :: Word64Map a -> Maybe (Key, a)
unsafeFindMax :: forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMax Word64Map a
Nil = Maybe (Word64, a)
forall a. Maybe a
Nothing
unsafeFindMax (Tip Word64
ky a
y) = (Word64, a) -> Maybe (Word64, a)
forall a. a -> Maybe a
Just (Word64
ky, a
y)
unsafeFindMax (Bin Word64
_ Word64
_ Word64Map a
_ Word64Map a
r) = Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
unsafeFindMax Word64Map a
r

{--------------------------------------------------------------------
  Disjoint
--------------------------------------------------------------------}
-- | \(O(n+m)\). Check whether the key sets of two maps are disjoint
-- (i.e. their 'intersection' is empty).
--
-- > disjoint (fromList [(2,'a')]) (fromList [(1,()), (3,())])   == True
-- > disjoint (fromList [(2,'a')]) (fromList [(1,'a'), (2,'b')]) == False
-- > disjoint (fromList [])        (fromList [])                 == True
--
-- > disjoint a b == null (intersection a b)
--
-- @since 0.6.2.1
disjoint :: Word64Map a -> Word64Map b -> Bool
disjoint :: forall a b. Word64Map a -> Word64Map b -> Bool
disjoint Word64Map a
Nil Word64Map b
_ = Bool
True
disjoint Word64Map a
_ Word64Map b
Nil = Bool
True
disjoint (Tip Word64
kx a
_) Word64Map b
ys = Word64 -> Word64Map b -> Bool
forall a. Word64 -> Word64Map a -> Bool
notMember Word64
kx Word64Map b
ys
disjoint Word64Map a
xs (Tip Word64
ky b
_) = Word64 -> Word64Map a -> Bool
forall a. Word64 -> Word64Map a -> Bool
notMember Word64
ky Word64Map a
xs
disjoint t1 :: Word64Map a
t1@(Bin Word64
p1 Word64
m1 Word64Map a
l1 Word64Map a
r1) t2 :: Word64Map b
t2@(Bin Word64
p2 Word64
m2 Word64Map b
l2 Word64Map b
r2)
  | Word64 -> Word64 -> Bool
shorter Word64
m1 Word64
m2 = Bool
disjoint1
  | Word64 -> Word64 -> Bool
shorter Word64
m2 Word64
m1 = Bool
disjoint2
  | Word64
p1 Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
p2      = Word64Map a -> Word64Map b -> Bool
forall a b. Word64Map a -> Word64Map b -> Bool
disjoint Word64Map a
l1 Word64Map b
l2 Bool -> Bool -> Bool
&& Word64Map a -> Word64Map b -> Bool
forall a b. Word64Map a -> Word64Map b -> Bool
disjoint Word64Map a
r1 Word64Map b
r2
  | Bool
otherwise     = Bool
True
  where
    disjoint1 :: Bool
disjoint1 | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
p2 Word64
p1 Word64
m1 = Bool
True
              | Word64 -> Word64 -> Bool
zero Word64
p2 Word64
m1       = Word64Map a -> Word64Map b -> Bool
forall a b. Word64Map a -> Word64Map b -> Bool
disjoint Word64Map a
l1 Word64Map b
t2
              | Bool
otherwise        = Word64Map a -> Word64Map b -> Bool
forall a b. Word64Map a -> Word64Map b -> Bool
disjoint Word64Map a
r1 Word64Map b
t2
    disjoint2 :: Bool
disjoint2 | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
p1 Word64
p2 Word64
m2 = Bool
True
              | Word64 -> Word64 -> Bool
zero Word64
p1 Word64
m2       = Word64Map a -> Word64Map b -> Bool
forall a b. Word64Map a -> Word64Map b -> Bool
disjoint Word64Map a
t1 Word64Map b
l2
              | Bool
otherwise        = Word64Map a -> Word64Map b -> Bool
forall a b. Word64Map a -> Word64Map b -> Bool
disjoint Word64Map a
t1 Word64Map b
r2

{--------------------------------------------------------------------
  Compose
--------------------------------------------------------------------}
-- | Relate the keys of one map to the values of
-- the other, by using the values of the former as keys for lookups
-- in the latter.
--
-- Complexity: \( O(n * \min(m,W)) \), where \(m\) is the size of the first argument
--
-- > compose (fromList [('a', "A"), ('b', "B")]) (fromList [(1,'a'),(2,'b'),(3,'z')]) = fromList [(1,"A"),(2,"B")]
--
-- @
-- ('compose' bc ab '!?') = (bc '!?') <=< (ab '!?')
-- @
--
-- __Note:__ Prior to v0.6.4, "Data.Word64Map.Strict" exposed a version of
-- 'compose' that forced the values of the output 'Word64Map'. This version does
-- not force these values.
--
-- @since 0.6.3.1
compose :: Word64Map c -> Word64Map Word64 -> Word64Map c
compose :: forall c. Word64Map c -> Word64Map Word64 -> Word64Map c
compose Word64Map c
bc !Word64Map Word64
ab
  | Word64Map c -> Bool
forall a. Word64Map a -> Bool
null Word64Map c
bc = Word64Map c
forall a. Word64Map a
empty
  | Bool
otherwise = (Word64 -> Maybe c) -> Word64Map Word64 -> Word64Map c
forall a b. (a -> Maybe b) -> Word64Map a -> Word64Map b
mapMaybe (Word64Map c
bc Word64Map c -> Word64 -> Maybe c
forall a. Word64Map a -> Word64 -> Maybe a
!?) Word64Map Word64
ab

{--------------------------------------------------------------------
  Construction
--------------------------------------------------------------------}
-- | \(O(1)\). The empty map.
--
-- > empty      == fromList []
-- > size empty == 0

empty :: Word64Map a
empty :: forall a. Word64Map a
empty
  = Word64Map a
forall a. Word64Map a
Nil
{-# INLINE empty #-}

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

singleton :: Key -> a -> Word64Map a
singleton :: forall a. Word64 -> a -> Word64Map a
singleton Word64
k a
x
  = Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
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 -> Word64Map a -> Word64Map a
insert :: forall a. Word64 -> a -> Word64Map a -> Word64Map a
insert !Word64
k a
x t :: Word64Map a
t@(Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
  | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
k Word64
p Word64
m = Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
link Word64
k (Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k a
x) Word64
p Word64Map a
t
  | Word64 -> Word64 -> Bool
zero Word64
k Word64
m      = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m (Word64 -> a -> Word64Map a -> Word64Map a
forall a. Word64 -> a -> Word64Map a -> Word64Map a
insert Word64
k a
x Word64Map a
l) Word64Map a
r
  | Bool
otherwise     = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m Word64Map a
l (Word64 -> a -> Word64Map a -> Word64Map a
forall a. Word64 -> a -> Word64Map a -> Word64Map a
insert Word64
k a
x Word64Map a
r)
insert Word64
k a
x t :: Word64Map a
t@(Tip Word64
ky a
_)
  | Word64
kWord64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
==Word64
ky         = Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k a
x
  | Bool
otherwise     = Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
link Word64
k (Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k a
x) Word64
ky Word64Map a
t
insert Word64
k a
x Word64Map a
Nil = Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
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 -> Word64Map a -> Word64Map a
insertWith :: forall a.
(a -> a -> a) -> Word64 -> a -> Word64Map a -> Word64Map a
insertWith a -> a -> a
f Word64
k a
x Word64Map a
t
  = (Word64 -> a -> a -> a)
-> Word64 -> a -> Word64Map a -> Word64Map a
forall a.
(Word64 -> a -> a -> a)
-> Word64 -> a -> Word64Map a -> Word64Map a
insertWithKey (\Word64
_ a
x' a
y' -> a -> a -> a
f a
x' a
y') Word64
k a
x Word64Map 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"

insertWithKey :: (Key -> a -> a -> a) -> Key -> a -> Word64Map a -> Word64Map a
insertWithKey :: forall a.
(Word64 -> a -> a -> a)
-> Word64 -> a -> Word64Map a -> Word64Map a
insertWithKey Word64 -> a -> a -> a
f !Word64
k a
x t :: Word64Map a
t@(Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
  | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
k Word64
p Word64
m = Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
link Word64
k (Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k a
x) Word64
p Word64Map a
t
  | Word64 -> Word64 -> Bool
zero Word64
k Word64
m      = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m ((Word64 -> a -> a -> a)
-> Word64 -> a -> Word64Map a -> Word64Map a
forall a.
(Word64 -> a -> a -> a)
-> Word64 -> a -> Word64Map a -> Word64Map a
insertWithKey Word64 -> a -> a -> a
f Word64
k a
x Word64Map a
l) Word64Map a
r
  | Bool
otherwise     = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m Word64Map a
l ((Word64 -> a -> a -> a)
-> Word64 -> a -> Word64Map a -> Word64Map a
forall a.
(Word64 -> a -> a -> a)
-> Word64 -> a -> Word64Map a -> Word64Map a
insertWithKey Word64 -> a -> a -> a
f Word64
k a
x Word64Map a
r)
insertWithKey Word64 -> a -> a -> a
f Word64
k a
x t :: Word64Map a
t@(Tip Word64
ky a
y)
  | Word64
k Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
ky       = Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k (Word64 -> a -> a -> a
f Word64
k a
x a
y)
  | Bool
otherwise     = Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
link Word64
k (Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k a
x) Word64
ky Word64Map a
t
insertWithKey Word64 -> a -> a -> a
_ Word64
k a
x Word64Map a
Nil = Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
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 -> Word64Map a -> (Maybe a, Word64Map a)
insertLookupWithKey :: forall a.
(Word64 -> a -> a -> a)
-> Word64 -> a -> Word64Map a -> (Maybe a, Word64Map a)
insertLookupWithKey Word64 -> a -> a -> a
f !Word64
k a
x t :: Word64Map a
t@(Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
  | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
k Word64
p Word64
m = (Maybe a
forall a. Maybe a
Nothing,Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
link Word64
k (Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k a
x) Word64
p Word64Map a
t)
  | Word64 -> Word64 -> Bool
zero Word64
k Word64
m      = let (Maybe a
found,Word64Map a
l') = (Word64 -> a -> a -> a)
-> Word64 -> a -> Word64Map a -> (Maybe a, Word64Map a)
forall a.
(Word64 -> a -> a -> a)
-> Word64 -> a -> Word64Map a -> (Maybe a, Word64Map a)
insertLookupWithKey Word64 -> a -> a -> a
f Word64
k a
x Word64Map a
l
                    in (Maybe a
found,Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m Word64Map a
l' Word64Map a
r)
  | Bool
otherwise     = let (Maybe a
found,Word64Map a
r') = (Word64 -> a -> a -> a)
-> Word64 -> a -> Word64Map a -> (Maybe a, Word64Map a)
forall a.
(Word64 -> a -> a -> a)
-> Word64 -> a -> Word64Map a -> (Maybe a, Word64Map a)
insertLookupWithKey Word64 -> a -> a -> a
f Word64
k a
x Word64Map a
r
                    in (Maybe a
found,Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m Word64Map a
l Word64Map a
r')
insertLookupWithKey Word64 -> a -> a -> a
f Word64
k a
x t :: Word64Map a
t@(Tip Word64
ky a
y)
  | Word64
k Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
ky       = (a -> Maybe a
forall a. a -> Maybe a
Just a
y,Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k (Word64 -> a -> a -> a
f Word64
k a
x a
y))
  | Bool
otherwise     = (Maybe a
forall a. Maybe a
Nothing,Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
link Word64
k (Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k a
x) Word64
ky Word64Map a
t)
insertLookupWithKey Word64 -> a -> a -> a
_ Word64
k a
x Word64Map a
Nil = (Maybe a
forall a. Maybe a
Nothing,Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k a
x)


{--------------------------------------------------------------------
  Deletion
--------------------------------------------------------------------}
-- | \(O(\min(n,W))\). Delete a key and its value from the map. When the key is not
-- a member of the map, the original map is returned.
--
-- > delete 5 (fromList [(5,"a"), (3,"b")]) == singleton 3 "b"
-- > delete 7 (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "a")]
-- > delete 5 empty                         == empty

delete :: Key -> Word64Map a -> Word64Map a
delete :: forall a. Word64 -> Word64Map a -> Word64Map a
delete !Word64
k t :: Word64Map a
t@(Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
  | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
k Word64
p Word64
m = Word64Map a
t
  | Word64 -> Word64 -> Bool
zero Word64
k Word64
m      = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckLeft Word64
p Word64
m (Word64 -> Word64Map a -> Word64Map a
forall a. Word64 -> Word64Map a -> Word64Map a
delete Word64
k Word64Map a
l) Word64Map a
r
  | Bool
otherwise     = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckRight Word64
p Word64
m Word64Map a
l (Word64 -> Word64Map a -> Word64Map a
forall a. Word64 -> Word64Map a -> Word64Map a
delete Word64
k Word64Map a
r)
delete Word64
k t :: Word64Map a
t@(Tip Word64
ky a
_)
  | Word64
k Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
ky       = Word64Map a
forall a. Word64Map a
Nil
  | Bool
otherwise     = Word64Map a
t
delete Word64
_k Word64Map a
Nil = Word64Map a
forall a. Word64Map a
Nil

-- | \(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 -> Word64Map a -> Word64Map a
adjust :: forall a. (a -> a) -> Word64 -> Word64Map a -> Word64Map a
adjust a -> a
f Word64
k Word64Map a
m
  = (Word64 -> a -> a) -> Word64 -> Word64Map a -> Word64Map a
forall a.
(Word64 -> a -> a) -> Word64 -> Word64Map a -> Word64Map a
adjustWithKey (\Word64
_ a
x -> a -> a
f a
x) Word64
k Word64Map 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 -> Word64Map a -> Word64Map a
adjustWithKey :: forall a.
(Word64 -> a -> a) -> Word64 -> Word64Map a -> Word64Map a
adjustWithKey Word64 -> a -> a
f !Word64
k (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
  | Word64 -> Word64 -> Bool
zero Word64
k Word64
m      = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m ((Word64 -> a -> a) -> Word64 -> Word64Map a -> Word64Map a
forall a.
(Word64 -> a -> a) -> Word64 -> Word64Map a -> Word64Map a
adjustWithKey Word64 -> a -> a
f Word64
k Word64Map a
l) Word64Map a
r
  | Bool
otherwise     = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m Word64Map a
l ((Word64 -> a -> a) -> Word64 -> Word64Map a -> Word64Map a
forall a.
(Word64 -> a -> a) -> Word64 -> Word64Map a -> Word64Map a
adjustWithKey Word64 -> a -> a
f Word64
k Word64Map a
r)
adjustWithKey Word64 -> a -> a
f Word64
k t :: Word64Map a
t@(Tip Word64
ky a
y)
  | Word64
k Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
ky       = Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
ky (Word64 -> a -> a
f Word64
k a
y)
  | Bool
otherwise     = Word64Map a
t
adjustWithKey Word64 -> a -> a
_ Word64
_ Word64Map a
Nil = Word64Map a
forall a. Word64Map 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 -> Word64Map a -> Word64Map a
update :: forall a. (a -> Maybe a) -> Word64 -> Word64Map a -> Word64Map a
update a -> Maybe a
f
  = (Word64 -> a -> Maybe a) -> Word64 -> Word64Map a -> Word64Map a
forall a.
(Word64 -> a -> Maybe a) -> Word64 -> Word64Map a -> Word64Map a
updateWithKey (\Word64
_ 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 -> Word64Map a -> Word64Map a
updateWithKey :: forall a.
(Word64 -> a -> Maybe a) -> Word64 -> Word64Map a -> Word64Map a
updateWithKey Word64 -> a -> Maybe a
f !Word64
k (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
  | Word64 -> Word64 -> Bool
zero Word64
k Word64
m      = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckLeft Word64
p Word64
m ((Word64 -> a -> Maybe a) -> Word64 -> Word64Map a -> Word64Map a
forall a.
(Word64 -> a -> Maybe a) -> Word64 -> Word64Map a -> Word64Map a
updateWithKey Word64 -> a -> Maybe a
f Word64
k Word64Map a
l) Word64Map a
r
  | Bool
otherwise     = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckRight Word64
p Word64
m Word64Map a
l ((Word64 -> a -> Maybe a) -> Word64 -> Word64Map a -> Word64Map a
forall a.
(Word64 -> a -> Maybe a) -> Word64 -> Word64Map a -> Word64Map a
updateWithKey Word64 -> a -> Maybe a
f Word64
k Word64Map a
r)
updateWithKey Word64 -> a -> Maybe a
f Word64
k t :: Word64Map a
t@(Tip Word64
ky a
y)
  | Word64
k Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
ky       = case (Word64 -> a -> Maybe a
f Word64
k a
y) of
                      Just a
y' -> Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
ky a
y'
                      Maybe a
Nothing -> Word64Map a
forall a. Word64Map a
Nil
  | Bool
otherwise     = Word64Map a
t
updateWithKey Word64 -> a -> Maybe a
_ Word64
_ Word64Map a
Nil = Word64Map a
forall a. Word64Map 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 -> Word64Map a -> (Maybe a,Word64Map a)
updateLookupWithKey :: forall a.
(Word64 -> a -> Maybe a)
-> Word64 -> Word64Map a -> (Maybe a, Word64Map a)
updateLookupWithKey Word64 -> a -> Maybe a
f !Word64
k (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
  | Word64 -> Word64 -> Bool
zero Word64
k Word64
m      = let !(Maybe a
found,Word64Map a
l') = (Word64 -> a -> Maybe a)
-> Word64 -> Word64Map a -> (Maybe a, Word64Map a)
forall a.
(Word64 -> a -> Maybe a)
-> Word64 -> Word64Map a -> (Maybe a, Word64Map a)
updateLookupWithKey Word64 -> a -> Maybe a
f Word64
k Word64Map a
l
                    in (Maybe a
found,Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckLeft Word64
p Word64
m Word64Map a
l' Word64Map a
r)
  | Bool
otherwise     = let !(Maybe a
found,Word64Map a
r') = (Word64 -> a -> Maybe a)
-> Word64 -> Word64Map a -> (Maybe a, Word64Map a)
forall a.
(Word64 -> a -> Maybe a)
-> Word64 -> Word64Map a -> (Maybe a, Word64Map a)
updateLookupWithKey Word64 -> a -> Maybe a
f Word64
k Word64Map a
r
                    in (Maybe a
found,Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckRight Word64
p Word64
m Word64Map a
l Word64Map a
r')
updateLookupWithKey Word64 -> a -> Maybe a
f Word64
k t :: Word64Map a
t@(Tip Word64
ky a
y)
  | Word64
kWord64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
==Word64
ky         = case (Word64 -> a -> Maybe a
f Word64
k a
y) of
                      Just a
y' -> (a -> Maybe a
forall a. a -> Maybe a
Just a
y,Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
ky a
y')
                      Maybe a
Nothing -> (a -> Maybe a
forall a. a -> Maybe a
Just a
y,Word64Map a
forall a. Word64Map a
Nil)
  | Bool
otherwise     = (Maybe a
forall a. Maybe a
Nothing,Word64Map a
t)
updateLookupWithKey Word64 -> a -> Maybe a
_ Word64
_ Word64Map a
Nil = (Maybe a
forall a. Maybe a
Nothing,Word64Map a
forall a. Word64Map 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 'Word64Map'.
-- In short : @'lookup' k ('alter' f k m) = f ('lookup' k m)@.
alter :: (Maybe a -> Maybe a) -> Key -> Word64Map a -> Word64Map a
alter :: forall a.
(Maybe a -> Maybe a) -> Word64 -> Word64Map a -> Word64Map a
alter Maybe a -> Maybe a
f !Word64
k t :: Word64Map a
t@(Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
  | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
k Word64
p Word64
m = case Maybe a -> Maybe a
f Maybe a
forall a. Maybe a
Nothing of
                      Maybe a
Nothing -> Word64Map a
t
                      Just a
x -> Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
link Word64
k (Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k a
x) Word64
p Word64Map a
t
  | Word64 -> Word64 -> Bool
zero Word64
k Word64
m      = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckLeft Word64
p Word64
m ((Maybe a -> Maybe a) -> Word64 -> Word64Map a -> Word64Map a
forall a.
(Maybe a -> Maybe a) -> Word64 -> Word64Map a -> Word64Map a
alter Maybe a -> Maybe a
f Word64
k Word64Map a
l) Word64Map a
r
  | Bool
otherwise     = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckRight Word64
p Word64
m Word64Map a
l ((Maybe a -> Maybe a) -> Word64 -> Word64Map a -> Word64Map a
forall a.
(Maybe a -> Maybe a) -> Word64 -> Word64Map a -> Word64Map a
alter Maybe a -> Maybe a
f Word64
k Word64Map a
r)
alter Maybe a -> Maybe a
f Word64
k t :: Word64Map a
t@(Tip Word64
ky a
y)
  | Word64
kWord64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
==Word64
ky         = case Maybe a -> Maybe a
f (a -> Maybe a
forall a. a -> Maybe a
Just a
y) of
                      Just a
x -> Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
ky a
x
                      Maybe a
Nothing -> Word64Map a
forall a. Word64Map a
Nil
  | Bool
otherwise     = case Maybe a -> Maybe a
f Maybe a
forall a. Maybe a
Nothing of
                      Just a
x -> Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
link Word64
k (Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k a
x) Word64
ky Word64Map a
t
                      Maybe a
Nothing -> Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
ky a
y
alter Maybe a -> Maybe a
f Word64
k Word64Map a
Nil     = case Maybe a -> Maybe a
f Maybe a
forall a. Maybe a
Nothing of
                      Just a
x -> Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k a
x
                      Maybe a
Nothing -> Word64Map a
forall a. Word64Map a
Nil

-- | \(O(\min(n,W))\). 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 'Word64Map'.  In short : @'lookup' k <$> 'alterF' f k m = f
-- ('lookup' k m)@.
--
-- Example:
--
-- @
-- interactiveAlter :: Int -> Word64Map String -> IO (Word64Map 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 -> Word64Map a -> f (Word64Map a)
-- This implementation was stolen from 'Control.Lens.At'.
alterF :: forall (f :: * -> *) a.
Functor f =>
(Maybe a -> f (Maybe a))
-> Word64 -> Word64Map a -> f (Word64Map a)
alterF Maybe a -> f (Maybe a)
f Word64
k Word64Map a
m = ((Maybe a -> Word64Map a) -> f (Maybe a) -> f (Word64Map a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a -> f (Maybe a)
f Maybe a
mv) ((Maybe a -> Word64Map a) -> f (Word64Map a))
-> (Maybe a -> Word64Map a) -> f (Word64Map a)
forall a b. (a -> b) -> a -> b
$ \Maybe a
fres ->
  case Maybe a
fres of
    Maybe a
Nothing -> Word64Map a -> (a -> Word64Map a) -> Maybe a -> Word64Map a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Word64Map a
m (Word64Map a -> a -> Word64Map a
forall a b. a -> b -> a
const (Word64 -> Word64Map a -> Word64Map a
forall a. Word64 -> Word64Map a -> Word64Map a
delete Word64
k Word64Map a
m)) Maybe a
mv
    Just a
v' -> Word64 -> a -> Word64Map a -> Word64Map a
forall a. Word64 -> a -> Word64Map a -> Word64Map a
insert Word64
k a
v' Word64Map a
m
  where mv :: Maybe a
mv = Word64 -> Word64Map a -> Maybe a
forall a. Word64 -> Word64Map a -> Maybe a
lookup Word64
k Word64Map a
m

{--------------------------------------------------------------------
  Union
--------------------------------------------------------------------}
-- | The union of a list of maps.
--
-- > unions [(fromList [(5, "a"), (3, "b")]), (fromList [(5, "A"), (7, "C")]), (fromList [(5, "A3"), (3, "B3")])]
-- >     == fromList [(3, "b"), (5, "a"), (7, "C")]
-- > unions [(fromList [(5, "A3"), (3, "B3")]), (fromList [(5, "A"), (7, "C")]), (fromList [(5, "a"), (3, "b")])]
-- >     == fromList [(3, "B3"), (5, "A3"), (7, "C")]

unions :: Foldable f => f (Word64Map a) -> Word64Map a
unions :: forall (f :: * -> *) a.
Foldable f =>
f (Word64Map a) -> Word64Map a
unions f (Word64Map a)
xs
  = (Word64Map a -> Word64Map a -> Word64Map a)
-> Word64Map a -> f (Word64Map a) -> Word64Map 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' Word64Map a -> Word64Map a -> Word64Map a
forall a. Word64Map a -> Word64Map a -> Word64Map a
union Word64Map a
forall a. Word64Map a
empty f (Word64Map a)
xs

-- | 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 (Word64Map a) -> Word64Map a
unionsWith :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> f (Word64Map a) -> Word64Map a
unionsWith a -> a -> a
f f (Word64Map a)
ts
  = (Word64Map a -> Word64Map a -> Word64Map a)
-> Word64Map a -> f (Word64Map a) -> Word64Map 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) -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
(a -> a -> a) -> Word64Map a -> Word64Map a -> Word64Map a
unionWith a -> a -> a
f) Word64Map a
forall a. Word64Map a
empty f (Word64Map a)
ts

-- | \(O(n+m)\). The (left-biased) union of two maps.
-- It prefers the first map when duplicate keys are encountered,
-- i.e. (@'union' == 'unionWith' 'const'@).
--
-- > union (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == fromList [(3, "b"), (5, "a"), (7, "C")]

union :: Word64Map a -> Word64Map a -> Word64Map a
union :: forall a. Word64Map a -> Word64Map a -> Word64Map a
union Word64Map a
m1 Word64Map a
m2
  = (Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a)
-> (Word64Map a -> Word64Map a -> Word64Map a)
-> (Word64Map a -> Word64Map a)
-> (Word64Map a -> Word64Map a)
-> Word64Map a
-> Word64Map a
-> Word64Map a
forall c a b.
(Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c)
-> (Word64Map a -> Word64Map b -> Word64Map c)
-> (Word64Map a -> Word64Map c)
-> (Word64Map b -> Word64Map c)
-> Word64Map a
-> Word64Map b
-> Word64Map c
mergeWithKey' Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64Map a -> Word64Map a -> Word64Map a
forall a b. a -> b -> a
const Word64Map a -> Word64Map a
forall a. a -> a
id Word64Map a -> Word64Map a
forall a. a -> a
id Word64Map a
m1 Word64Map a
m2

-- | \(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) -> Word64Map a -> Word64Map a -> Word64Map a
unionWith :: forall a.
(a -> a -> a) -> Word64Map a -> Word64Map a -> Word64Map a
unionWith a -> a -> a
f Word64Map a
m1 Word64Map a
m2
  = (Word64 -> a -> a -> a)
-> Word64Map a -> Word64Map a -> Word64Map a
forall a.
(Word64 -> a -> a -> a)
-> Word64Map a -> Word64Map a -> Word64Map a
unionWithKey (\Word64
_ a
x a
y -> a -> a -> a
f a
x a
y) Word64Map a
m1 Word64Map 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) -> Word64Map a -> Word64Map a -> Word64Map a
unionWithKey :: forall a.
(Word64 -> a -> a -> a)
-> Word64Map a -> Word64Map a -> Word64Map a
unionWithKey Word64 -> a -> a -> a
f Word64Map a
m1 Word64Map a
m2
  = (Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a)
-> (Word64Map a -> Word64Map a -> Word64Map a)
-> (Word64Map a -> Word64Map a)
-> (Word64Map a -> Word64Map a)
-> Word64Map a
-> Word64Map a
-> Word64Map a
forall c a b.
(Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c)
-> (Word64Map a -> Word64Map b -> Word64Map c)
-> (Word64Map a -> Word64Map c)
-> (Word64Map b -> Word64Map c)
-> Word64Map a
-> Word64Map b
-> Word64Map c
mergeWithKey' Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin (\(Tip Word64
k1 a
x1) (Tip Word64
_k2 a
x2) -> Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k1 (Word64 -> a -> a -> a
f Word64
k1 a
x1 a
x2)) Word64Map a -> Word64Map a
forall a. a -> a
id Word64Map a -> Word64Map a
forall a. a -> a
id Word64Map a
m1 Word64Map a
m2

{--------------------------------------------------------------------
  Difference
--------------------------------------------------------------------}
-- | \(O(n+m)\). Difference between two maps (based on keys).
--
-- > difference (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == singleton 3 "b"

difference :: Word64Map a -> Word64Map b -> Word64Map a
difference :: forall a b. Word64Map a -> Word64Map b -> Word64Map a
difference Word64Map a
m1 Word64Map b
m2
  = (Word64 -> a -> b -> Maybe a)
-> (Word64Map a -> Word64Map a)
-> (Word64Map b -> Word64Map a)
-> Word64Map a
-> Word64Map b
-> Word64Map a
forall a b c.
(Word64 -> a -> b -> Maybe c)
-> (Word64Map a -> Word64Map c)
-> (Word64Map b -> Word64Map c)
-> Word64Map a
-> Word64Map b
-> Word64Map c
mergeWithKey (\Word64
_ a
_ b
_ -> Maybe a
forall a. Maybe a
Nothing) Word64Map a -> Word64Map a
forall a. a -> a
id (Word64Map a -> Word64Map b -> Word64Map a
forall a b. a -> b -> a
const Word64Map a
forall a. Word64Map a
Nil) Word64Map a
m1 Word64Map b
m2

-- | \(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) -> Word64Map a -> Word64Map b -> Word64Map a
differenceWith :: forall a b.
(a -> b -> Maybe a) -> Word64Map a -> Word64Map b -> Word64Map a
differenceWith a -> b -> Maybe a
f Word64Map a
m1 Word64Map b
m2
  = (Word64 -> a -> b -> Maybe a)
-> Word64Map a -> Word64Map b -> Word64Map a
forall a b.
(Word64 -> a -> b -> Maybe a)
-> Word64Map a -> Word64Map b -> Word64Map a
differenceWithKey (\Word64
_ a
x b
y -> a -> b -> Maybe a
f a
x b
y) Word64Map a
m1 Word64Map 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) -> Word64Map a -> Word64Map b -> Word64Map a
differenceWithKey :: forall a b.
(Word64 -> a -> b -> Maybe a)
-> Word64Map a -> Word64Map b -> Word64Map a
differenceWithKey Word64 -> a -> b -> Maybe a
f Word64Map a
m1 Word64Map b
m2
  = (Word64 -> a -> b -> Maybe a)
-> (Word64Map a -> Word64Map a)
-> (Word64Map b -> Word64Map a)
-> Word64Map a
-> Word64Map b
-> Word64Map a
forall a b c.
(Word64 -> a -> b -> Maybe c)
-> (Word64Map a -> Word64Map c)
-> (Word64Map b -> Word64Map c)
-> Word64Map a
-> Word64Map b
-> Word64Map c
mergeWithKey Word64 -> a -> b -> Maybe a
f Word64Map a -> Word64Map a
forall a. a -> a
id (Word64Map a -> Word64Map b -> Word64Map a
forall a b. a -> b -> a
const Word64Map a
forall a. Word64Map a
Nil) Word64Map a
m1 Word64Map b
m2


-- TODO(wrengr): re-verify that asymptotic bound
-- | \(O(n+m)\). Remove all the keys in a given set from a map.
--
-- @
-- m \`withoutKeys\` s = 'filterWithKey' (\\k _ -> k ``Word64Set.notMember`` s) m
-- @
--
-- @since 0.5.8
withoutKeys :: Word64Map a -> Word64Set.Word64Set -> Word64Map a
withoutKeys :: forall a. Word64Map a -> Word64Set -> Word64Map a
withoutKeys t1 :: Word64Map a
t1@(Bin Word64
p1 Word64
m1 Word64Map a
l1 Word64Map a
r1) t2 :: Word64Set
t2@(Word64Set.Bin Word64
p2 Word64
m2 Word64Set
l2 Word64Set
r2)
    | Word64 -> Word64 -> Bool
shorter Word64
m1 Word64
m2  = Word64Map a
difference1
    | Word64 -> Word64 -> Bool
shorter Word64
m2 Word64
m1  = Word64Map a
difference2
    | Word64
p1 Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
p2       = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p1 Word64
m1 (Word64Map a -> Word64Set -> Word64Map a
forall a. Word64Map a -> Word64Set -> Word64Map a
withoutKeys Word64Map a
l1 Word64Set
l2) (Word64Map a -> Word64Set -> Word64Map a
forall a. Word64Map a -> Word64Set -> Word64Map a
withoutKeys Word64Map a
r1 Word64Set
r2)
    | Bool
otherwise      = Word64Map a
t1
    where
    difference1 :: Word64Map a
difference1
        | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
p2 Word64
p1 Word64
m1  = Word64Map a
t1
        | Word64 -> Word64 -> Bool
zero Word64
p2 Word64
m1        = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckLeft Word64
p1 Word64
m1 (Word64Map a -> Word64Set -> Word64Map a
forall a. Word64Map a -> Word64Set -> Word64Map a
withoutKeys Word64Map a
l1 Word64Set
t2) Word64Map a
r1
        | Bool
otherwise         = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckRight Word64
p1 Word64
m1 Word64Map a
l1 (Word64Map a -> Word64Set -> Word64Map a
forall a. Word64Map a -> Word64Set -> Word64Map a
withoutKeys Word64Map a
r1 Word64Set
t2)
    difference2 :: Word64Map a
difference2
        | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
p1 Word64
p2 Word64
m2  = Word64Map a
t1
        | Word64 -> Word64 -> Bool
zero Word64
p1 Word64
m2        = Word64Map a -> Word64Set -> Word64Map a
forall a. Word64Map a -> Word64Set -> Word64Map a
withoutKeys Word64Map a
t1 Word64Set
l2
        | Bool
otherwise         = Word64Map a -> Word64Set -> Word64Map a
forall a. Word64Map a -> Word64Set -> Word64Map a
withoutKeys Word64Map a
t1 Word64Set
r2
withoutKeys t1 :: Word64Map a
t1@(Bin Word64
p1 Word64
m1 Word64Map a
_ Word64Map a
_) (Word64Set.Tip Word64
p2 Word64
bm2) =
    let minbit :: Word64
minbit = Word64 -> Word64
bitmapOf Word64
p1
        lt_minbit :: Word64
lt_minbit = Word64
minbit Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- Word64
1
        maxbit :: Word64
maxbit = Word64 -> Word64
bitmapOf (Word64
p1 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.|. (Word64
m1 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.|. (Word64
m1 Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- Word64
1)))
        gt_maxbit :: Word64
gt_maxbit = (-Word64
maxbit) Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
`xor` Word64
maxbit
    -- TODO(wrengr): should we manually inline/unroll 'updatePrefix'
    -- and 'withoutBM' here, in order to avoid redundant case analyses?
    in Word64
-> Word64Map a -> (Word64Map a -> Word64Map a) -> Word64Map a
forall a.
Word64
-> Word64Map a -> (Word64Map a -> Word64Map a) -> Word64Map a
updatePrefix Word64
p2 Word64Map a
t1 ((Word64Map a -> Word64Map a) -> Word64Map a)
-> (Word64Map a -> Word64Map a) -> Word64Map a
forall a b. (a -> b) -> a -> b
$ Word64 -> Word64Map a -> Word64Map a
forall a. Word64 -> Word64Map a -> Word64Map a
withoutBM (Word64
bm2 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.|. Word64
lt_minbit Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.|. Word64
gt_maxbit)
withoutKeys t1 :: Word64Map a
t1@(Bin Word64
_ Word64
_ Word64Map a
_ Word64Map a
_) Word64Set
Word64Set.Nil = Word64Map a
t1
withoutKeys t1 :: Word64Map a
t1@(Tip Word64
k1 a
_) Word64Set
t2
    | Word64
k1 Word64 -> Word64Set -> Bool
`Word64Set.member` Word64Set
t2 = Word64Map a
forall a. Word64Map a
Nil
    | Bool
otherwise = Word64Map a
t1
withoutKeys Word64Map a
Nil Word64Set
_ = Word64Map a
forall a. Word64Map a
Nil


updatePrefix
    :: Word64SetPrefix -> Word64Map a -> (Word64Map a -> Word64Map a) -> Word64Map a
updatePrefix :: forall a.
Word64
-> Word64Map a -> (Word64Map a -> Word64Map a) -> Word64Map a
updatePrefix !Word64
kp t :: Word64Map a
t@(Bin Word64
p Word64
m Word64Map a
l Word64Map a
r) Word64Map a -> Word64Map a
f
    | Word64
m Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. Word64
Word64Set.suffixBitMask Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word64
0 =
        if Word64
p Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. Word64
Word64Set.prefixBitMask Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
kp then Word64Map a -> Word64Map a
f Word64Map a
t else Word64Map a
t
    | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
kp Word64
p Word64
m = Word64Map a
t
    | Word64 -> Word64 -> Bool
zero Word64
kp Word64
m      = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckLeft Word64
p Word64
m (Word64
-> Word64Map a -> (Word64Map a -> Word64Map a) -> Word64Map a
forall a.
Word64
-> Word64Map a -> (Word64Map a -> Word64Map a) -> Word64Map a
updatePrefix Word64
kp Word64Map a
l Word64Map a -> Word64Map a
f) Word64Map a
r
    | Bool
otherwise      = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckRight Word64
p Word64
m Word64Map a
l (Word64
-> Word64Map a -> (Word64Map a -> Word64Map a) -> Word64Map a
forall a.
Word64
-> Word64Map a -> (Word64Map a -> Word64Map a) -> Word64Map a
updatePrefix Word64
kp Word64Map a
r Word64Map a -> Word64Map a
f)
updatePrefix Word64
kp t :: Word64Map a
t@(Tip Word64
kx a
_) Word64Map a -> Word64Map a
f
    | Word64
kx Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. Word64
Word64Set.prefixBitMask Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
kp = Word64Map a -> Word64Map a
f Word64Map a
t
    | Bool
otherwise = Word64Map a
t
updatePrefix Word64
_ Word64Map a
Nil Word64Map a -> Word64Map a
_ = Word64Map a
forall a. Word64Map a
Nil


withoutBM :: Word64SetBitMap -> Word64Map a -> Word64Map a
withoutBM :: forall a. Word64 -> Word64Map a -> Word64Map a
withoutBM Word64
0 Word64Map a
t = Word64Map a
t
withoutBM Word64
bm (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r) =
    let leftBits :: Word64
leftBits = Word64 -> Word64
bitmapOf (Word64
p Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.|. Word64
m) Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- Word64
1
        bmL :: Word64
bmL = Word64
bm Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. Word64
leftBits
        bmR :: Word64
bmR = Word64
bm Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
`xor` Word64
bmL -- = (bm .&. complement leftBits)
    in  Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m (Word64 -> Word64Map a -> Word64Map a
forall a. Word64 -> Word64Map a -> Word64Map a
withoutBM Word64
bmL Word64Map a
l) (Word64 -> Word64Map a -> Word64Map a
forall a. Word64 -> Word64Map a -> Word64Map a
withoutBM Word64
bmR Word64Map a
r)
withoutBM Word64
bm t :: Word64Map a
t@(Tip Word64
k a
_)
    -- TODO(wrengr): need we manually inline 'Word64Set.Member' here?
    | Word64
k Word64 -> Word64Set -> Bool
`Word64Set.member` Word64 -> Word64 -> Word64Set
Word64Set.Tip (Word64
k Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. Word64
Word64Set.prefixBitMask) Word64
bm = Word64Map a
forall a. Word64Map a
Nil
    | Bool
otherwise = Word64Map a
t
withoutBM Word64
_ Word64Map a
Nil = Word64Map a
forall a. Word64Map a
Nil


{--------------------------------------------------------------------
  Intersection
--------------------------------------------------------------------}
-- | \(O(n+m)\). The (left-biased) intersection of two maps (based on keys).
--
-- > intersection (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == singleton 5 "a"

intersection :: Word64Map a -> Word64Map b -> Word64Map a
intersection :: forall a b. Word64Map a -> Word64Map b -> Word64Map a
intersection Word64Map a
m1 Word64Map b
m2
  = (Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a)
-> (Word64Map a -> Word64Map b -> Word64Map a)
-> (Word64Map a -> Word64Map a)
-> (Word64Map b -> Word64Map a)
-> Word64Map a
-> Word64Map b
-> Word64Map a
forall c a b.
(Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c)
-> (Word64Map a -> Word64Map b -> Word64Map c)
-> (Word64Map a -> Word64Map c)
-> (Word64Map b -> Word64Map c)
-> Word64Map a
-> Word64Map b
-> Word64Map c
mergeWithKey' Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64Map a -> Word64Map b -> Word64Map a
forall a b. a -> b -> a
const (Word64Map a -> Word64Map a -> Word64Map a
forall a b. a -> b -> a
const Word64Map a
forall a. Word64Map a
Nil) (Word64Map a -> Word64Map b -> Word64Map a
forall a b. a -> b -> a
const Word64Map a
forall a. Word64Map a
Nil) Word64Map a
m1 Word64Map b
m2


-- TODO(wrengr): re-verify that asymptotic bound
-- | \(O(n+m)\). The restriction of a map to the keys in a set.
--
-- @
-- m \`restrictKeys\` s = 'filterWithKey' (\\k _ -> k ``Word64Set.member`` s) m
-- @
--
-- @since 0.5.8
restrictKeys :: Word64Map a -> Word64Set.Word64Set -> Word64Map a
restrictKeys :: forall a. Word64Map a -> Word64Set -> Word64Map a
restrictKeys t1 :: Word64Map a
t1@(Bin Word64
p1 Word64
m1 Word64Map a
l1 Word64Map a
r1) t2 :: Word64Set
t2@(Word64Set.Bin Word64
p2 Word64
m2 Word64Set
l2 Word64Set
r2)
    | Word64 -> Word64 -> Bool
shorter Word64
m1 Word64
m2  = Word64Map a
intersection1
    | Word64 -> Word64 -> Bool
shorter Word64
m2 Word64
m1  = Word64Map a
intersection2
    | Word64
p1 Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
p2       = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p1 Word64
m1 (Word64Map a -> Word64Set -> Word64Map a
forall a. Word64Map a -> Word64Set -> Word64Map a
restrictKeys Word64Map a
l1 Word64Set
l2) (Word64Map a -> Word64Set -> Word64Map a
forall a. Word64Map a -> Word64Set -> Word64Map a
restrictKeys Word64Map a
r1 Word64Set
r2)
    | Bool
otherwise      = Word64Map a
forall a. Word64Map a
Nil
    where
    intersection1 :: Word64Map a
intersection1
        | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
p2 Word64
p1 Word64
m1  = Word64Map a
forall a. Word64Map a
Nil
        | Word64 -> Word64 -> Bool
zero Word64
p2 Word64
m1        = Word64Map a -> Word64Set -> Word64Map a
forall a. Word64Map a -> Word64Set -> Word64Map a
restrictKeys Word64Map a
l1 Word64Set
t2
        | Bool
otherwise         = Word64Map a -> Word64Set -> Word64Map a
forall a. Word64Map a -> Word64Set -> Word64Map a
restrictKeys Word64Map a
r1 Word64Set
t2
    intersection2 :: Word64Map a
intersection2
        | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
p1 Word64
p2 Word64
m2  = Word64Map a
forall a. Word64Map a
Nil
        | Word64 -> Word64 -> Bool
zero Word64
p1 Word64
m2        = Word64Map a -> Word64Set -> Word64Map a
forall a. Word64Map a -> Word64Set -> Word64Map a
restrictKeys Word64Map a
t1 Word64Set
l2
        | Bool
otherwise         = Word64Map a -> Word64Set -> Word64Map a
forall a. Word64Map a -> Word64Set -> Word64Map a
restrictKeys Word64Map a
t1 Word64Set
r2
restrictKeys t1 :: Word64Map a
t1@(Bin Word64
p1 Word64
m1 Word64Map a
_ Word64Map a
_) (Word64Set.Tip Word64
p2 Word64
bm2) =
    let minbit :: Word64
minbit = Word64 -> Word64
bitmapOf Word64
p1
        ge_minbit :: Word64
ge_minbit = Word64 -> Word64
forall a. Bits a => a -> a
complement (Word64
minbit Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- Word64
1)
        maxbit :: Word64
maxbit = Word64 -> Word64
bitmapOf (Word64
p1 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.|. (Word64
m1 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.|. (Word64
m1 Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- Word64
1)))
        le_maxbit :: Word64
le_maxbit = Word64
maxbit Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.|. (Word64
maxbit Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- Word64
1)
    -- TODO(wrengr): should we manually inline/unroll 'lookupPrefix'
    -- and 'restrictBM' here, in order to avoid redundant case analyses?
    in Word64 -> Word64Map a -> Word64Map a
forall a. Word64 -> Word64Map a -> Word64Map a
restrictBM (Word64
bm2 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. Word64
ge_minbit Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. Word64
le_maxbit) (Word64 -> Word64Map a -> Word64Map a
forall a. Word64 -> Word64Map a -> Word64Map a
lookupPrefix Word64
p2 Word64Map a
t1)
restrictKeys (Bin Word64
_ Word64
_ Word64Map a
_ Word64Map a
_) Word64Set
Word64Set.Nil = Word64Map a
forall a. Word64Map a
Nil
restrictKeys t1 :: Word64Map a
t1@(Tip Word64
k1 a
_) Word64Set
t2
    | Word64
k1 Word64 -> Word64Set -> Bool
`Word64Set.member` Word64Set
t2 = Word64Map a
t1
    | Bool
otherwise = Word64Map a
forall a. Word64Map a
Nil
restrictKeys Word64Map a
Nil Word64Set
_ = Word64Map a
forall a. Word64Map a
Nil


-- | \(O(\min(n,W))\). Restrict to the sub-map with all keys matching
-- a key prefix.
lookupPrefix :: Word64SetPrefix -> Word64Map a -> Word64Map a
lookupPrefix :: forall a. Word64 -> Word64Map a -> Word64Map a
lookupPrefix !Word64
kp t :: Word64Map a
t@(Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
    | Word64
m Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. Word64
Word64Set.suffixBitMask Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word64
0 =
        if Word64
p Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. Word64
Word64Set.prefixBitMask Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
kp then Word64Map a
t else Word64Map a
forall a. Word64Map a
Nil
    | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
kp Word64
p Word64
m = Word64Map a
forall a. Word64Map a
Nil
    | Word64 -> Word64 -> Bool
zero Word64
kp Word64
m      = Word64 -> Word64Map a -> Word64Map a
forall a. Word64 -> Word64Map a -> Word64Map a
lookupPrefix Word64
kp Word64Map a
l
    | Bool
otherwise      = Word64 -> Word64Map a -> Word64Map a
forall a. Word64 -> Word64Map a -> Word64Map a
lookupPrefix Word64
kp Word64Map a
r
lookupPrefix Word64
kp t :: Word64Map a
t@(Tip Word64
kx a
_)
    | (Word64
kx Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. Word64
Word64Set.prefixBitMask) Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
kp = Word64Map a
t
    | Bool
otherwise = Word64Map a
forall a. Word64Map a
Nil
lookupPrefix Word64
_ Word64Map a
Nil = Word64Map a
forall a. Word64Map a
Nil


restrictBM :: Word64SetBitMap -> Word64Map a -> Word64Map a
restrictBM :: forall a. Word64 -> Word64Map a -> Word64Map a
restrictBM Word64
0 Word64Map a
_ = Word64Map a
forall a. Word64Map a
Nil
restrictBM Word64
bm (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r) =
    let leftBits :: Word64
leftBits = Word64 -> Word64
bitmapOf (Word64
p Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.|. Word64
m) Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- Word64
1
        bmL :: Word64
bmL = Word64
bm Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. Word64
leftBits
        bmR :: Word64
bmR = Word64
bm Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
`xor` Word64
bmL -- = (bm .&. complement leftBits)
    in  Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m (Word64 -> Word64Map a -> Word64Map a
forall a. Word64 -> Word64Map a -> Word64Map a
restrictBM Word64
bmL Word64Map a
l) (Word64 -> Word64Map a -> Word64Map a
forall a. Word64 -> Word64Map a -> Word64Map a
restrictBM Word64
bmR Word64Map a
r)
restrictBM Word64
bm t :: Word64Map a
t@(Tip Word64
k a
_)
    -- TODO(wrengr): need we manually inline 'Word64Set.Member' here?
    | Word64
k Word64 -> Word64Set -> Bool
`Word64Set.member` Word64 -> Word64 -> Word64Set
Word64Set.Tip (Word64
k Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. Word64
Word64Set.prefixBitMask) Word64
bm = Word64Map a
t
    | Bool
otherwise = Word64Map a
forall a. Word64Map a
Nil
restrictBM Word64
_ Word64Map a
Nil = Word64Map a
forall a. Word64Map a
Nil


-- | \(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) -> Word64Map a -> Word64Map b -> Word64Map c
intersectionWith :: forall a b c.
(a -> b -> c) -> Word64Map a -> Word64Map b -> Word64Map c
intersectionWith a -> b -> c
f Word64Map a
m1 Word64Map b
m2
  = (Word64 -> a -> b -> c)
-> Word64Map a -> Word64Map b -> Word64Map c
forall a b c.
(Word64 -> a -> b -> c)
-> Word64Map a -> Word64Map b -> Word64Map c
intersectionWithKey (\Word64
_ a
x b
y -> a -> b -> c
f a
x b
y) Word64Map a
m1 Word64Map 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) -> Word64Map a -> Word64Map b -> Word64Map c
intersectionWithKey :: forall a b c.
(Word64 -> a -> b -> c)
-> Word64Map a -> Word64Map b -> Word64Map c
intersectionWithKey Word64 -> a -> b -> c
f Word64Map a
m1 Word64Map b
m2
  = (Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c)
-> (Word64Map a -> Word64Map b -> Word64Map c)
-> (Word64Map a -> Word64Map c)
-> (Word64Map b -> Word64Map c)
-> Word64Map a
-> Word64Map b
-> Word64Map c
forall c a b.
(Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c)
-> (Word64Map a -> Word64Map b -> Word64Map c)
-> (Word64Map a -> Word64Map c)
-> (Word64Map b -> Word64Map c)
-> Word64Map a
-> Word64Map b
-> Word64Map c
mergeWithKey' Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin (\(Tip Word64
k1 a
x1) (Tip Word64
_k2 b
x2) -> Word64 -> c -> Word64Map c
forall a. Word64 -> a -> Word64Map a
Tip Word64
k1 (Word64 -> a -> b -> c
f Word64
k1 a
x1 b
x2)) (Word64Map c -> Word64Map a -> Word64Map c
forall a b. a -> b -> a
const Word64Map c
forall a. Word64Map a
Nil) (Word64Map c -> Word64Map b -> Word64Map c
forall a b. a -> b -> a
const Word64Map c
forall a. Word64Map a
Nil) Word64Map a
m1 Word64Map 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
-- 'Word64Map'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) -> (Word64Map a -> Word64Map c) -> (Word64Map b -> Word64Map c)
             -> Word64Map a -> Word64Map b -> Word64Map c
mergeWithKey :: forall a b c.
(Word64 -> a -> b -> Maybe c)
-> (Word64Map a -> Word64Map c)
-> (Word64Map b -> Word64Map c)
-> Word64Map a
-> Word64Map b
-> Word64Map c
mergeWithKey Word64 -> a -> b -> Maybe c
f Word64Map a -> Word64Map c
g1 Word64Map b -> Word64Map c
g2 = (Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c)
-> (Word64Map a -> Word64Map b -> Word64Map c)
-> (Word64Map a -> Word64Map c)
-> (Word64Map b -> Word64Map c)
-> Word64Map a
-> Word64Map b
-> Word64Map c
forall c a b.
(Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c)
-> (Word64Map a -> Word64Map b -> Word64Map c)
-> (Word64Map a -> Word64Map c)
-> (Word64Map b -> Word64Map c)
-> Word64Map a
-> Word64Map b
-> Word64Map c
mergeWithKey' Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64Map a -> Word64Map b -> Word64Map c
combine Word64Map a -> Word64Map c
g1 Word64Map b -> Word64Map c
g2
  where -- We use the lambda form to avoid non-exhaustive pattern matches warning.
        combine :: Word64Map a -> Word64Map b -> Word64Map c
combine = \(Tip Word64
k1 a
x1) (Tip Word64
_k2 b
x2) ->
          case Word64 -> a -> b -> Maybe c
f Word64
k1 a
x1 b
x2 of
            Maybe c
Nothing -> Word64Map c
forall a. Word64Map a
Nil
            Just c
x -> Word64 -> c -> Word64Map c
forall a. Word64 -> a -> Word64Map a
Tip Word64
k1 c
x
        {-# INLINE combine #-}
{-# INLINE mergeWithKey #-}

-- Slightly more general version of mergeWithKey. It differs in the following:
--
-- * the combining function operates on maps instead of keys and values. The
--   reason is to enable sharing in union, difference and intersection.
--
-- * mergeWithKey' is given an equivalent of bin. The reason is that in union*,
--   Bin constructor can be used, because we know both subtrees are nonempty.

mergeWithKey' :: (Prefix -> Mask -> Word64Map c -> Word64Map c -> Word64Map c)
              -> (Word64Map a -> Word64Map b -> Word64Map c) -> (Word64Map a -> Word64Map c) -> (Word64Map b -> Word64Map c)
              -> Word64Map a -> Word64Map b -> Word64Map c
mergeWithKey' :: forall c a b.
(Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c)
-> (Word64Map a -> Word64Map b -> Word64Map c)
-> (Word64Map a -> Word64Map c)
-> (Word64Map b -> Word64Map c)
-> Word64Map a
-> Word64Map b
-> Word64Map c
mergeWithKey' Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c
bin' Word64Map a -> Word64Map b -> Word64Map c
f Word64Map a -> Word64Map c
g1 Word64Map b -> Word64Map c
g2 = Word64Map a -> Word64Map b -> Word64Map c
go
  where
    go :: Word64Map a -> Word64Map b -> Word64Map c
go t1 :: Word64Map a
t1@(Bin Word64
p1 Word64
m1 Word64Map a
l1 Word64Map a
r1) t2 :: Word64Map b
t2@(Bin Word64
p2 Word64
m2 Word64Map b
l2 Word64Map b
r2)
      | Word64 -> Word64 -> Bool
shorter Word64
m1 Word64
m2  = Word64Map c
merge1
      | Word64 -> Word64 -> Bool
shorter Word64
m2 Word64
m1  = Word64Map c
merge2
      | Word64
p1 Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
p2       = Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c
bin' Word64
p1 Word64
m1 (Word64Map a -> Word64Map b -> Word64Map c
go Word64Map a
l1 Word64Map b
l2) (Word64Map a -> Word64Map b -> Word64Map c
go Word64Map a
r1 Word64Map b
r2)
      | Bool
otherwise      = Word64 -> Word64Map c -> Word64 -> Word64Map c -> Word64Map c
forall a.
Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
maybe_link Word64
p1 (Word64Map a -> Word64Map c
g1 Word64Map a
t1) Word64
p2 (Word64Map b -> Word64Map c
g2 Word64Map b
t2)
      where
        merge1 :: Word64Map c
merge1 | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
p2 Word64
p1 Word64
m1  = Word64 -> Word64Map c -> Word64 -> Word64Map c -> Word64Map c
forall a.
Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
maybe_link Word64
p1 (Word64Map a -> Word64Map c
g1 Word64Map a
t1) Word64
p2 (Word64Map b -> Word64Map c
g2 Word64Map b
t2)
               | Word64 -> Word64 -> Bool
zero Word64
p2 Word64
m1        = Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c
bin' Word64
p1 Word64
m1 (Word64Map a -> Word64Map b -> Word64Map c
go Word64Map a
l1 Word64Map b
t2) (Word64Map a -> Word64Map c
g1 Word64Map a
r1)
               | Bool
otherwise         = Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c
bin' Word64
p1 Word64
m1 (Word64Map a -> Word64Map c
g1 Word64Map a
l1) (Word64Map a -> Word64Map b -> Word64Map c
go Word64Map a
r1 Word64Map b
t2)
        merge2 :: Word64Map c
merge2 | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
p1 Word64
p2 Word64
m2  = Word64 -> Word64Map c -> Word64 -> Word64Map c -> Word64Map c
forall a.
Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
maybe_link Word64
p1 (Word64Map a -> Word64Map c
g1 Word64Map a
t1) Word64
p2 (Word64Map b -> Word64Map c
g2 Word64Map b
t2)
               | Word64 -> Word64 -> Bool
zero Word64
p1 Word64
m2        = Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c
bin' Word64
p2 Word64
m2 (Word64Map a -> Word64Map b -> Word64Map c
go Word64Map a
t1 Word64Map b
l2) (Word64Map b -> Word64Map c
g2 Word64Map b
r2)
               | Bool
otherwise         = Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c
bin' Word64
p2 Word64
m2 (Word64Map b -> Word64Map c
g2 Word64Map b
l2) (Word64Map a -> Word64Map b -> Word64Map c
go Word64Map a
t1 Word64Map b
r2)

    go t1' :: Word64Map a
t1'@(Bin Word64
_ Word64
_ Word64Map a
_ Word64Map a
_) t2' :: Word64Map b
t2'@(Tip Word64
k2' b
_) = Word64Map b -> Word64 -> Word64Map a -> Word64Map c
merge0 Word64Map b
t2' Word64
k2' Word64Map a
t1'
      where
        merge0 :: Word64Map b -> Word64 -> Word64Map a -> Word64Map c
merge0 Word64Map b
t2 Word64
k2 t1 :: Word64Map a
t1@(Bin Word64
p1 Word64
m1 Word64Map a
l1 Word64Map a
r1)
          | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
k2 Word64
p1 Word64
m1 = Word64 -> Word64Map c -> Word64 -> Word64Map c -> Word64Map c
forall a.
Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
maybe_link Word64
p1 (Word64Map a -> Word64Map c
g1 Word64Map a
t1) Word64
k2 (Word64Map b -> Word64Map c
g2 Word64Map b
t2)
          | Word64 -> Word64 -> Bool
zero Word64
k2 Word64
m1 = Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c
bin' Word64
p1 Word64
m1 (Word64Map b -> Word64 -> Word64Map a -> Word64Map c
merge0 Word64Map b
t2 Word64
k2 Word64Map a
l1) (Word64Map a -> Word64Map c
g1 Word64Map a
r1)
          | Bool
otherwise  = Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c
bin' Word64
p1 Word64
m1 (Word64Map a -> Word64Map c
g1 Word64Map a
l1) (Word64Map b -> Word64 -> Word64Map a -> Word64Map c
merge0 Word64Map b
t2 Word64
k2 Word64Map a
r1)
        merge0 Word64Map b
t2 Word64
k2 t1 :: Word64Map a
t1@(Tip Word64
k1 a
_)
          | Word64
k1 Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
k2 = Word64Map a -> Word64Map b -> Word64Map c
f Word64Map a
t1 Word64Map b
t2
          | Bool
otherwise = Word64 -> Word64Map c -> Word64 -> Word64Map c -> Word64Map c
forall a.
Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
maybe_link Word64
k1 (Word64Map a -> Word64Map c
g1 Word64Map a
t1) Word64
k2 (Word64Map b -> Word64Map c
g2 Word64Map b
t2)
        merge0 Word64Map b
t2 Word64
_  Word64Map a
Nil = Word64Map b -> Word64Map c
g2 Word64Map b
t2

    go t1 :: Word64Map a
t1@(Bin Word64
_ Word64
_ Word64Map a
_ Word64Map a
_) Word64Map b
Nil = Word64Map a -> Word64Map c
g1 Word64Map a
t1

    go t1' :: Word64Map a
t1'@(Tip Word64
k1' a
_) Word64Map b
t2' = Word64Map a -> Word64 -> Word64Map b -> Word64Map c
merge0 Word64Map a
t1' Word64
k1' Word64Map b
t2'
      where
        merge0 :: Word64Map a -> Word64 -> Word64Map b -> Word64Map c
merge0 Word64Map a
t1 Word64
k1 t2 :: Word64Map b
t2@(Bin Word64
p2 Word64
m2 Word64Map b
l2 Word64Map b
r2)
          | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
k1 Word64
p2 Word64
m2 = Word64 -> Word64Map c -> Word64 -> Word64Map c -> Word64Map c
forall a.
Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
maybe_link Word64
k1 (Word64Map a -> Word64Map c
g1 Word64Map a
t1) Word64
p2 (Word64Map b -> Word64Map c
g2 Word64Map b
t2)
          | Word64 -> Word64 -> Bool
zero Word64
k1 Word64
m2 = Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c
bin' Word64
p2 Word64
m2 (Word64Map a -> Word64 -> Word64Map b -> Word64Map c
merge0 Word64Map a
t1 Word64
k1 Word64Map b
l2) (Word64Map b -> Word64Map c
g2 Word64Map b
r2)
          | Bool
otherwise  = Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c
bin' Word64
p2 Word64
m2 (Word64Map b -> Word64Map c
g2 Word64Map b
l2) (Word64Map a -> Word64 -> Word64Map b -> Word64Map c
merge0 Word64Map a
t1 Word64
k1 Word64Map b
r2)
        merge0 Word64Map a
t1 Word64
k1 t2 :: Word64Map b
t2@(Tip Word64
k2 b
_)
          | Word64
k1 Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
k2 = Word64Map a -> Word64Map b -> Word64Map c
f Word64Map a
t1 Word64Map b
t2
          | Bool
otherwise = Word64 -> Word64Map c -> Word64 -> Word64Map c -> Word64Map c
forall a.
Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
maybe_link Word64
k1 (Word64Map a -> Word64Map c
g1 Word64Map a
t1) Word64
k2 (Word64Map b -> Word64Map c
g2 Word64Map b
t2)
        merge0 Word64Map a
t1 Word64
_  Word64Map b
Nil = Word64Map a -> Word64Map c
g1 Word64Map a
t1

    go Word64Map a
Nil Word64Map b
t2 = Word64Map b -> Word64Map c
g2 Word64Map b
t2

    maybe_link :: Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
maybe_link Word64
_ Word64Map a
Nil Word64
_ Word64Map a
t2 = Word64Map a
t2
    maybe_link Word64
_ Word64Map a
t1 Word64
_ Word64Map a
Nil = Word64Map a
t1
    maybe_link Word64
p1 Word64Map a
t1 Word64
p2 Word64Map a
t2 = Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
link Word64
p1 Word64Map a
t1 Word64
p2 Word64Map a
t2
    {-# INLINE maybe_link #-}
{-# INLINE mergeWithKey' #-}


{--------------------------------------------------------------------
  mergeA
--------------------------------------------------------------------}

-- | A tactic for dealing with keys present in one map but not the
-- other in 'merge' or 'mergeA'.
--
-- A tactic of type @WhenMissing f k x z@ is an abstract representation
-- of a function of type @Key -> x -> f (Maybe z)@.
--
-- @since 0.5.9

data WhenMissing f x y = WhenMissing
  { forall (f :: * -> *) x y.
WhenMissing f x y -> Word64Map x -> f (Word64Map y)
missingSubtree :: Word64Map x -> f (Word64Map y)
  , forall (f :: * -> *) x y.
WhenMissing f x y -> Word64 -> x -> f (Maybe y)
missingKey :: Key -> x -> f (Maybe y)}

-- | @since 0.5.9
instance (Applicative f, Monad f) => Functor (WhenMissing f x) where
  fmap :: forall a b. (a -> b) -> WhenMissing f x a -> WhenMissing f x b
fmap = (a -> b) -> WhenMissing f x a -> WhenMissing f x b
forall (f :: * -> *) a b x.
(Applicative f, Monad f) =>
(a -> b) -> WhenMissing f x a -> WhenMissing f x b
mapWhenMissing
  {-# INLINE fmap #-}


-- | @since 0.5.9
instance (Applicative f, Monad f) => Category.Category (WhenMissing f)
  where
    id :: forall a. WhenMissing f a a
id = WhenMissing f a a
forall (f :: * -> *) x. Applicative f => WhenMissing f x x
preserveMissing
    WhenMissing f b c
f . :: forall b c a.
WhenMissing f b c -> WhenMissing f a b -> WhenMissing f a c
. WhenMissing f a b
g =
      (Word64 -> a -> f (Maybe c)) -> WhenMissing f a c
forall (f :: * -> *) x y.
Applicative f =>
(Word64 -> x -> f (Maybe y)) -> WhenMissing f x y
traverseMaybeMissing ((Word64 -> a -> f (Maybe c)) -> WhenMissing f a c)
-> (Word64 -> a -> f (Maybe c)) -> WhenMissing f a c
forall a b. (a -> b) -> a -> b
$ \ Word64
k a
x -> do
        Maybe b
y <- WhenMissing f a b -> Word64 -> a -> f (Maybe b)
forall (f :: * -> *) x y.
WhenMissing f x y -> Word64 -> x -> f (Maybe y)
missingKey WhenMissing f a b
g Word64
k a
x
        case Maybe b
y of
          Maybe b
Nothing -> Maybe c -> f (Maybe c)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe c
forall a. Maybe a
Nothing
          Just b
q  -> WhenMissing f b c -> Word64 -> b -> f (Maybe c)
forall (f :: * -> *) x y.
WhenMissing f x y -> Word64 -> x -> f (Maybe y)
missingKey WhenMissing f b c
f Word64
k b
q
    {-# INLINE id #-}
    {-# INLINE (.) #-}


-- | Equivalent to @ReaderT k (ReaderT x (MaybeT f))@.
--
-- @since 0.5.9
instance (Applicative f, Monad f) => Applicative (WhenMissing f x) where
  pure :: forall a. a -> WhenMissing f x a
pure a
x = (Word64 -> x -> a) -> WhenMissing f x a
forall (f :: * -> *) x y.
Applicative f =>
(Word64 -> x -> y) -> WhenMissing f x y
mapMissing (\ Word64
_ x
_ -> a
x)
  WhenMissing f x (a -> b)
f <*> :: forall a b.
WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b
<*> WhenMissing f x a
g =
    (Word64 -> x -> f (Maybe b)) -> WhenMissing f x b
forall (f :: * -> *) x y.
Applicative f =>
(Word64 -> x -> f (Maybe y)) -> WhenMissing f x y
traverseMaybeMissing ((Word64 -> x -> f (Maybe b)) -> WhenMissing f x b)
-> (Word64 -> x -> f (Maybe b)) -> WhenMissing f x b
forall a b. (a -> b) -> a -> b
$ \Word64
k x
x -> do
      Maybe (a -> b)
res1 <- WhenMissing f x (a -> b) -> Word64 -> x -> f (Maybe (a -> b))
forall (f :: * -> *) x y.
WhenMissing f x y -> Word64 -> x -> f (Maybe y)
missingKey WhenMissing f x (a -> b)
f Word64
k x
x
      case Maybe (a -> b)
res1 of
        Maybe (a -> b)
Nothing -> Maybe b -> f (Maybe b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe b
forall a. Maybe a
Nothing
        Just a -> b
r  -> (Maybe b -> f (Maybe b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe b -> f (Maybe b)) -> Maybe b -> f (Maybe b)
forall a b. (a -> b) -> a -> b
$!) (Maybe b -> f (Maybe b))
-> (Maybe a -> Maybe b) -> Maybe a -> f (Maybe b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> Maybe a -> Maybe b
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
r (Maybe a -> f (Maybe b)) -> f (Maybe a) -> f (Maybe b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WhenMissing f x a -> Word64 -> x -> f (Maybe a)
forall (f :: * -> *) x y.
WhenMissing f x y -> Word64 -> x -> f (Maybe y)
missingKey WhenMissing f x a
g Word64
k x
x
  {-# INLINE pure #-}
  {-# INLINE (<*>) #-}


-- | Equivalent to @ReaderT k (ReaderT x (MaybeT f))@.
--
-- @since 0.5.9
instance (Applicative f, Monad f) => Monad (WhenMissing f x) where
  WhenMissing f x a
m >>= :: forall a b.
WhenMissing f x a -> (a -> WhenMissing f x b) -> WhenMissing f x b
>>= a -> WhenMissing f x b
f =
    (Word64 -> x -> f (Maybe b)) -> WhenMissing f x b
forall (f :: * -> *) x y.
Applicative f =>
(Word64 -> x -> f (Maybe y)) -> WhenMissing f x y
traverseMaybeMissing ((Word64 -> x -> f (Maybe b)) -> WhenMissing f x b)
-> (Word64 -> x -> f (Maybe b)) -> WhenMissing f x b
forall a b. (a -> b) -> a -> b
$ \Word64
k x
x -> do
      Maybe a
res1 <- WhenMissing f x a -> Word64 -> x -> f (Maybe a)
forall (f :: * -> *) x y.
WhenMissing f x y -> Word64 -> x -> f (Maybe y)
missingKey WhenMissing f x a
m Word64
k x
x
      case Maybe a
res1 of
        Maybe a
Nothing -> Maybe b -> f (Maybe b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe b
forall a. Maybe a
Nothing
        Just a
r  -> WhenMissing f x b -> Word64 -> x -> f (Maybe b)
forall (f :: * -> *) x y.
WhenMissing f x y -> Word64 -> x -> f (Maybe y)
missingKey (a -> WhenMissing f x b
f a
r) Word64
k x
x
  {-# INLINE (>>=) #-}


-- | Map covariantly over a @'WhenMissing' f x@.
--
-- @since 0.5.9
mapWhenMissing
  :: (Applicative f, Monad f)
  => (a -> b)
  -> WhenMissing f x a
  -> WhenMissing f x b
mapWhenMissing :: forall (f :: * -> *) a b x.
(Applicative f, Monad f) =>
(a -> b) -> WhenMissing f x a -> WhenMissing f x b
mapWhenMissing a -> b
f WhenMissing f x a
t = WhenMissing
  { missingSubtree :: Word64Map x -> f (Word64Map b)
missingSubtree = \Word64Map x
m -> WhenMissing f x a -> Word64Map x -> f (Word64Map a)
forall (f :: * -> *) x y.
WhenMissing f x y -> Word64Map x -> f (Word64Map y)
missingSubtree WhenMissing f x a
t Word64Map x
m f (Word64Map a)
-> (Word64Map a -> f (Word64Map b)) -> f (Word64Map b)
forall a b. f a -> (a -> f b) -> f b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Word64Map a
m' -> Word64Map b -> f (Word64Map b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word64Map b -> f (Word64Map b)) -> Word64Map b -> f (Word64Map b)
forall a b. (a -> b) -> a -> b
$! (a -> b) -> Word64Map a -> Word64Map b
forall a b. (a -> b) -> Word64Map a -> Word64Map b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Word64Map a
m'
  , missingKey :: Word64 -> x -> f (Maybe b)
missingKey     = \Word64
k x
x -> WhenMissing f x a -> Word64 -> x -> f (Maybe a)
forall (f :: * -> *) x y.
WhenMissing f x y -> Word64 -> x -> f (Maybe y)
missingKey WhenMissing f x a
t Word64
k x
x f (Maybe a) -> (Maybe a -> f (Maybe b)) -> f (Maybe b)
forall a b. f a -> (a -> f b) -> f b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe a
q -> (Maybe b -> f (Maybe b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe b -> f (Maybe b)) -> Maybe b -> f (Maybe b)
forall a b. (a -> b) -> a -> b
$! (a -> b) -> Maybe a -> Maybe b
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Maybe a
q) }
{-# INLINE mapWhenMissing #-}


-- | Map covariantly over a @'WhenMissing' f x@, using only a
-- 'Functor f' constraint.
mapGentlyWhenMissing
  :: Functor f
  => (a -> b)
  -> WhenMissing f x a
  -> WhenMissing f x b
mapGentlyWhenMissing :: forall (f :: * -> *) a b x.
Functor f =>
(a -> b) -> WhenMissing f x a -> WhenMissing f x b
mapGentlyWhenMissing a -> b
f WhenMissing f x a
t = WhenMissing
  { missingSubtree :: Word64Map x -> f (Word64Map b)
missingSubtree = \Word64Map x
m -> (a -> b) -> Word64Map a -> Word64Map b
forall a b. (a -> b) -> Word64Map a -> Word64Map b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f (Word64Map a -> Word64Map b) -> f (Word64Map a) -> f (Word64Map b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WhenMissing f x a -> Word64Map x -> f (Word64Map a)
forall (f :: * -> *) x y.
WhenMissing f x y -> Word64Map x -> f (Word64Map y)
missingSubtree WhenMissing f x a
t Word64Map x
m
  , missingKey :: Word64 -> x -> f (Maybe b)
missingKey     = \Word64
k x
x -> (a -> b) -> Maybe a -> Maybe b
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f (Maybe a -> Maybe b) -> f (Maybe a) -> f (Maybe b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WhenMissing f x a -> Word64 -> x -> f (Maybe a)
forall (f :: * -> *) x y.
WhenMissing f x y -> Word64 -> x -> f (Maybe y)
missingKey WhenMissing f x a
t Word64
k x
x }
{-# INLINE mapGentlyWhenMissing #-}


-- | Map covariantly over a @'WhenMatched' f k x@, using only a
-- 'Functor f' constraint.
mapGentlyWhenMatched
  :: Functor f
  => (a -> b)
  -> WhenMatched f x y a
  -> WhenMatched f x y b
mapGentlyWhenMatched :: forall (f :: * -> *) a b x y.
Functor f =>
(a -> b) -> WhenMatched f x y a -> WhenMatched f x y b
mapGentlyWhenMatched a -> b
f WhenMatched f x y a
t =
  (Word64 -> x -> y -> f (Maybe b)) -> WhenMatched f x y b
forall x y (f :: * -> *) z.
(Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
zipWithMaybeAMatched ((Word64 -> x -> y -> f (Maybe b)) -> WhenMatched f x y b)
-> (Word64 -> x -> y -> f (Maybe b)) -> WhenMatched f x y b
forall a b. (a -> b) -> a -> b
$ \Word64
k x
x y
y -> (a -> b) -> Maybe a -> Maybe b
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f (Maybe a -> Maybe b) -> f (Maybe a) -> f (Maybe b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WhenMatched f x y a -> Word64 -> x -> y -> f (Maybe a)
forall (f :: * -> *) x y z.
WhenMatched f x y z -> Word64 -> x -> y -> f (Maybe z)
runWhenMatched WhenMatched f x y a
t Word64
k x
x y
y
{-# INLINE mapGentlyWhenMatched #-}


-- | Map contravariantly over a @'WhenMissing' f _ x@.
--
-- @since 0.5.9
lmapWhenMissing :: (b -> a) -> WhenMissing f a x -> WhenMissing f b x
lmapWhenMissing :: forall b a (f :: * -> *) x.
(b -> a) -> WhenMissing f a x -> WhenMissing f b x
lmapWhenMissing b -> a
f WhenMissing f a x
t = WhenMissing
  { missingSubtree :: Word64Map b -> f (Word64Map x)
missingSubtree = \Word64Map b
m -> WhenMissing f a x -> Word64Map a -> f (Word64Map x)
forall (f :: * -> *) x y.
WhenMissing f x y -> Word64Map x -> f (Word64Map y)
missingSubtree WhenMissing f a x
t ((b -> a) -> Word64Map b -> Word64Map a
forall a b. (a -> b) -> Word64Map a -> Word64Map b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap b -> a
f Word64Map b
m)
  , missingKey :: Word64 -> b -> f (Maybe x)
missingKey     = \Word64
k b
x -> WhenMissing f a x -> Word64 -> a -> f (Maybe x)
forall (f :: * -> *) x y.
WhenMissing f x y -> Word64 -> x -> f (Maybe y)
missingKey WhenMissing f a x
t Word64
k (b -> a
f b
x) }
{-# INLINE lmapWhenMissing #-}


-- | Map contravariantly over a @'WhenMatched' f _ y z@.
--
-- @since 0.5.9
contramapFirstWhenMatched
  :: (b -> a)
  -> WhenMatched f a y z
  -> WhenMatched f b y z
contramapFirstWhenMatched :: forall b a (f :: * -> *) y z.
(b -> a) -> WhenMatched f a y z -> WhenMatched f b y z
contramapFirstWhenMatched b -> a
f WhenMatched f a y z
t =
  (Word64 -> b -> y -> f (Maybe z)) -> WhenMatched f b y z
forall (f :: * -> *) x y z.
(Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
WhenMatched ((Word64 -> b -> y -> f (Maybe z)) -> WhenMatched f b y z)
-> (Word64 -> b -> y -> f (Maybe z)) -> WhenMatched f b y z
forall a b. (a -> b) -> a -> b
$ \Word64
k b
x y
y -> WhenMatched f a y z -> Word64 -> a -> y -> f (Maybe z)
forall (f :: * -> *) x y z.
WhenMatched f x y z -> Word64 -> x -> y -> f (Maybe z)
runWhenMatched WhenMatched f a y z
t Word64
k (b -> a
f b
x) y
y
{-# INLINE contramapFirstWhenMatched #-}


-- | Map contravariantly over a @'WhenMatched' f x _ z@.
--
-- @since 0.5.9
contramapSecondWhenMatched
  :: (b -> a)
  -> WhenMatched f x a z
  -> WhenMatched f x b z
contramapSecondWhenMatched :: forall b a (f :: * -> *) x z.
(b -> a) -> WhenMatched f x a z -> WhenMatched f x b z
contramapSecondWhenMatched b -> a
f WhenMatched f x a z
t =
  (Word64 -> x -> b -> f (Maybe z)) -> WhenMatched f x b z
forall (f :: * -> *) x y z.
(Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
WhenMatched ((Word64 -> x -> b -> f (Maybe z)) -> WhenMatched f x b z)
-> (Word64 -> x -> b -> f (Maybe z)) -> WhenMatched f x b z
forall a b. (a -> b) -> a -> b
$ \Word64
k x
x b
y -> WhenMatched f x a z -> Word64 -> x -> a -> f (Maybe z)
forall (f :: * -> *) x y z.
WhenMatched f x y z -> Word64 -> x -> y -> f (Maybe z)
runWhenMatched WhenMatched f x a z
t Word64
k x
x (b -> a
f b
y)
{-# INLINE contramapSecondWhenMatched #-}


-- | A tactic for dealing with keys present in one map but not the
-- other in 'merge'.
--
-- A tactic of type @SimpleWhenMissing x z@ is an abstract
-- representation of a function of type @Key -> x -> Maybe z@.
--
-- @since 0.5.9
type SimpleWhenMissing = WhenMissing Identity


-- | A tactic for dealing with keys present in both maps in 'merge'
-- or 'mergeA'.
--
-- A tactic of type @WhenMatched f x y z@ is an abstract representation
-- of a function of type @Key -> x -> y -> f (Maybe z)@.
--
-- @since 0.5.9
newtype WhenMatched f x y z = WhenMatched
  { forall (f :: * -> *) x y z.
WhenMatched f x y z -> Word64 -> x -> y -> f (Maybe z)
matchedKey :: Key -> x -> y -> f (Maybe z) }


-- | Along with zipWithMaybeAMatched, witnesses the isomorphism
-- between @WhenMatched f x y z@ and @Key -> x -> y -> f (Maybe z)@.
--
-- @since 0.5.9
runWhenMatched :: WhenMatched f x y z -> Key -> x -> y -> f (Maybe z)
runWhenMatched :: forall (f :: * -> *) x y z.
WhenMatched f x y z -> Word64 -> x -> y -> f (Maybe z)
runWhenMatched = WhenMatched f x y z -> Word64 -> x -> y -> f (Maybe z)
forall (f :: * -> *) x y z.
WhenMatched f x y z -> Word64 -> x -> y -> f (Maybe z)
matchedKey
{-# INLINE runWhenMatched #-}


-- | Along with traverseMaybeMissing, witnesses the isomorphism
-- between @WhenMissing f x y@ and @Key -> x -> f (Maybe y)@.
--
-- @since 0.5.9
runWhenMissing :: WhenMissing f x y -> Key-> x -> f (Maybe y)
runWhenMissing :: forall (f :: * -> *) x y.
WhenMissing f x y -> Word64 -> x -> f (Maybe y)
runWhenMissing = WhenMissing f x y -> Word64 -> x -> f (Maybe y)
forall (f :: * -> *) x y.
WhenMissing f x y -> Word64 -> x -> f (Maybe y)
missingKey
{-# INLINE runWhenMissing #-}


-- | @since 0.5.9
instance Functor f => Functor (WhenMatched f x y) where
  fmap :: forall a b. (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b
fmap = (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b
forall (f :: * -> *) a b x y.
Functor f =>
(a -> b) -> WhenMatched f x y a -> WhenMatched f x y b
mapWhenMatched
  {-# INLINE fmap #-}


-- | @since 0.5.9
instance (Monad f, Applicative f) => Category.Category (WhenMatched f x)
  where
    id :: forall a. WhenMatched f x a a
id = (Word64 -> x -> a -> a) -> WhenMatched f x a a
forall (f :: * -> *) x y z.
Applicative f =>
(Word64 -> x -> y -> z) -> WhenMatched f x y z
zipWithMatched (\Word64
_ x
_ a
y -> a
y)
    WhenMatched f x b c
f . :: forall b c a.
WhenMatched f x b c -> WhenMatched f x a b -> WhenMatched f x a c
. WhenMatched f x a b
g =
      (Word64 -> x -> a -> f (Maybe c)) -> WhenMatched f x a c
forall x y (f :: * -> *) z.
(Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
zipWithMaybeAMatched ((Word64 -> x -> a -> f (Maybe c)) -> WhenMatched f x a c)
-> (Word64 -> x -> a -> f (Maybe c)) -> WhenMatched f x a c
forall a b. (a -> b) -> a -> b
$ \Word64
k x
x a
y -> do
        Maybe b
res <- WhenMatched f x a b -> Word64 -> x -> a -> f (Maybe b)
forall (f :: * -> *) x y z.
WhenMatched f x y z -> Word64 -> x -> y -> f (Maybe z)
runWhenMatched WhenMatched f x a b
g Word64
k x
x a
y
        case Maybe b
res of
          Maybe b
Nothing -> Maybe c -> f (Maybe c)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe c
forall a. Maybe a
Nothing
          Just b
r  -> WhenMatched f x b c -> Word64 -> x -> b -> f (Maybe c)
forall (f :: * -> *) x y z.
WhenMatched f x y z -> Word64 -> x -> y -> f (Maybe z)
runWhenMatched WhenMatched f x b c
f Word64
k x
x b
r
    {-# INLINE id #-}
    {-# INLINE (.) #-}


-- | Equivalent to @ReaderT Key (ReaderT x (ReaderT y (MaybeT f)))@
--
-- @since 0.5.9
instance (Monad f, Applicative f) => Applicative (WhenMatched f x y) where
  pure :: forall a. a -> WhenMatched f x y a
pure a
x = (Word64 -> x -> y -> a) -> WhenMatched f x y a
forall (f :: * -> *) x y z.
Applicative f =>
(Word64 -> x -> y -> z) -> WhenMatched f x y z
zipWithMatched (\Word64
_ x
_ y
_ -> a
x)
  WhenMatched f x y (a -> b)
fs <*> :: forall a b.
WhenMatched f x y (a -> b)
-> WhenMatched f x y a -> WhenMatched f x y b
<*> WhenMatched f x y a
xs =
    (Word64 -> x -> y -> f (Maybe b)) -> WhenMatched f x y b
forall x y (f :: * -> *) z.
(Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
zipWithMaybeAMatched ((Word64 -> x -> y -> f (Maybe b)) -> WhenMatched f x y b)
-> (Word64 -> x -> y -> f (Maybe b)) -> WhenMatched f x y b
forall a b. (a -> b) -> a -> b
$ \Word64
k x
x y
y -> do
      Maybe (a -> b)
res <- WhenMatched f x y (a -> b)
-> Word64 -> x -> y -> f (Maybe (a -> b))
forall (f :: * -> *) x y z.
WhenMatched f x y z -> Word64 -> x -> y -> f (Maybe z)
runWhenMatched WhenMatched f x y (a -> b)
fs Word64
k x
x y
y
      case Maybe (a -> b)
res of
        Maybe (a -> b)
Nothing -> Maybe b -> f (Maybe b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe b
forall a. Maybe a
Nothing
        Just a -> b
r  -> (Maybe b -> f (Maybe b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe b -> f (Maybe b)) -> Maybe b -> f (Maybe b)
forall a b. (a -> b) -> a -> b
$!) (Maybe b -> f (Maybe b))
-> (Maybe a -> Maybe b) -> Maybe a -> f (Maybe b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> Maybe a -> Maybe b
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
r (Maybe a -> f (Maybe b)) -> f (Maybe a) -> f (Maybe b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WhenMatched f x y a -> Word64 -> x -> y -> f (Maybe a)
forall (f :: * -> *) x y z.
WhenMatched f x y z -> Word64 -> x -> y -> f (Maybe z)
runWhenMatched WhenMatched f x y a
xs Word64
k x
x y
y
  {-# INLINE pure #-}
  {-# INLINE (<*>) #-}


-- | Equivalent to @ReaderT Key (ReaderT x (ReaderT y (MaybeT f)))@
--
-- @since 0.5.9
instance (Monad f, Applicative f) => Monad (WhenMatched f x y) where
  WhenMatched f x y a
m >>= :: forall a b.
WhenMatched f x y a
-> (a -> WhenMatched f x y b) -> WhenMatched f x y b
>>= a -> WhenMatched f x y b
f =
    (Word64 -> x -> y -> f (Maybe b)) -> WhenMatched f x y b
forall x y (f :: * -> *) z.
(Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
zipWithMaybeAMatched ((Word64 -> x -> y -> f (Maybe b)) -> WhenMatched f x y b)
-> (Word64 -> x -> y -> f (Maybe b)) -> WhenMatched f x y b
forall a b. (a -> b) -> a -> b
$ \Word64
k x
x y
y -> do
      Maybe a
res <- WhenMatched f x y a -> Word64 -> x -> y -> f (Maybe a)
forall (f :: * -> *) x y z.
WhenMatched f x y z -> Word64 -> x -> y -> f (Maybe z)
runWhenMatched WhenMatched f x y a
m Word64
k x
x y
y
      case Maybe a
res of
        Maybe a
Nothing -> Maybe b -> f (Maybe b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe b
forall a. Maybe a
Nothing
        Just a
r  -> WhenMatched f x y b -> Word64 -> x -> y -> f (Maybe b)
forall (f :: * -> *) x y z.
WhenMatched f x y z -> Word64 -> x -> y -> f (Maybe z)
runWhenMatched (a -> WhenMatched f x y b
f a
r) Word64
k x
x y
y
  {-# INLINE (>>=) #-}


-- | Map covariantly over a @'WhenMatched' f x y@.
--
-- @since 0.5.9
mapWhenMatched
  :: Functor f
  => (a -> b)
  -> WhenMatched f x y a
  -> WhenMatched f x y b
mapWhenMatched :: forall (f :: * -> *) a b x y.
Functor f =>
(a -> b) -> WhenMatched f x y a -> WhenMatched f x y b
mapWhenMatched a -> b
f (WhenMatched Word64 -> x -> y -> f (Maybe a)
g) =
  (Word64 -> x -> y -> f (Maybe b)) -> WhenMatched f x y b
forall (f :: * -> *) x y z.
(Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
WhenMatched ((Word64 -> x -> y -> f (Maybe b)) -> WhenMatched f x y b)
-> (Word64 -> x -> y -> f (Maybe b)) -> WhenMatched f x y b
forall a b. (a -> b) -> a -> b
$ \Word64
k x
x y
y -> (Maybe a -> Maybe b) -> f (Maybe a) -> f (Maybe b)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Maybe a -> Maybe b
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f) (Word64 -> x -> y -> f (Maybe a)
g Word64
k x
x y
y)
{-# INLINE mapWhenMatched #-}


-- | A tactic for dealing with keys present in both maps in 'merge'.
--
-- A tactic of type @SimpleWhenMatched x y z@ is an abstract
-- representation of a function of type @Key -> x -> y -> Maybe z@.
--
-- @since 0.5.9
type SimpleWhenMatched = WhenMatched Identity


-- | When a key is found in both maps, apply a function to the key
-- and values and use the result in the merged map.
--
-- > zipWithMatched
-- >   :: (Key -> x -> y -> z)
-- >   -> SimpleWhenMatched x y z
--
-- @since 0.5.9
zipWithMatched
  :: Applicative f
  => (Key -> x -> y -> z)
  -> WhenMatched f x y z
zipWithMatched :: forall (f :: * -> *) x y z.
Applicative f =>
(Word64 -> x -> y -> z) -> WhenMatched f x y z
zipWithMatched Word64 -> x -> y -> z
f = (Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
forall (f :: * -> *) x y z.
(Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
WhenMatched ((Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z)
-> (Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
forall a b. (a -> b) -> a -> b
$ \ Word64
k x
x y
y -> Maybe z -> f (Maybe z)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe z -> f (Maybe z)) -> (z -> Maybe z) -> z -> f (Maybe z)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. z -> Maybe z
forall a. a -> Maybe a
Just (z -> f (Maybe z)) -> z -> f (Maybe z)
forall a b. (a -> b) -> a -> b
$ Word64 -> x -> y -> z
f Word64
k x
x y
y
{-# INLINE zipWithMatched #-}


-- | When a key is found in both maps, apply a function to the key
-- and values to produce an action and use its result in the merged
-- map.
--
-- @since 0.5.9
zipWithAMatched
  :: Applicative f
  => (Key -> x -> y -> f z)
  -> WhenMatched f x y z
zipWithAMatched :: forall (f :: * -> *) x y z.
Applicative f =>
(Word64 -> x -> y -> f z) -> WhenMatched f x y z
zipWithAMatched Word64 -> x -> y -> f z
f = (Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
forall (f :: * -> *) x y z.
(Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
WhenMatched ((Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z)
-> (Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
forall a b. (a -> b) -> a -> b
$ \ Word64
k x
x y
y -> z -> Maybe z
forall a. a -> Maybe a
Just (z -> Maybe z) -> f z -> f (Maybe z)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word64 -> x -> y -> f z
f Word64
k x
x y
y
{-# INLINE zipWithAMatched #-}


-- | When a key is found in both maps, apply a function to the key
-- and values and maybe use the result in the merged map.
--
-- > zipWithMaybeMatched
-- >   :: (Key -> x -> y -> Maybe z)
-- >   -> SimpleWhenMatched x y z
--
-- @since 0.5.9
zipWithMaybeMatched
  :: Applicative f
  => (Key -> x -> y -> Maybe z)
  -> WhenMatched f x y z
zipWithMaybeMatched :: forall (f :: * -> *) x y z.
Applicative f =>
(Word64 -> x -> y -> Maybe z) -> WhenMatched f x y z
zipWithMaybeMatched Word64 -> x -> y -> Maybe z
f = (Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
forall (f :: * -> *) x y z.
(Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
WhenMatched ((Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z)
-> (Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
forall a b. (a -> b) -> a -> b
$ \ Word64
k x
x y
y -> Maybe z -> f (Maybe z)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe z -> f (Maybe z)) -> Maybe z -> f (Maybe z)
forall a b. (a -> b) -> a -> b
$ Word64 -> x -> y -> Maybe z
f Word64
k x
x y
y
{-# INLINE zipWithMaybeMatched #-}


-- | When a key is found in both maps, apply a function to the key
-- and values, perform the resulting action, and maybe use the
-- result in the merged map.
--
-- This is the fundamental 'WhenMatched' tactic.
--
-- @since 0.5.9
zipWithMaybeAMatched
  :: (Key -> x -> y -> f (Maybe z))
  -> WhenMatched f x y z
zipWithMaybeAMatched :: forall x y (f :: * -> *) z.
(Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
zipWithMaybeAMatched Word64 -> x -> y -> f (Maybe z)
f = (Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
forall (f :: * -> *) x y z.
(Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
WhenMatched ((Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z)
-> (Word64 -> x -> y -> f (Maybe z)) -> WhenMatched f x y z
forall a b. (a -> b) -> a -> b
$ \ Word64
k x
x y
y -> Word64 -> x -> y -> f (Maybe z)
f Word64
k x
x y
y
{-# INLINE zipWithMaybeAMatched #-}


-- | Drop all the entries whose keys are missing from the other
-- map.
--
-- > dropMissing :: SimpleWhenMissing x y
--
-- prop> dropMissing = mapMaybeMissing (\_ _ -> Nothing)
--
-- but @dropMissing@ is much faster.
--
-- @since 0.5.9
dropMissing :: Applicative f => WhenMissing f x y
dropMissing :: forall (f :: * -> *) x y. Applicative f => WhenMissing f x y
dropMissing = WhenMissing
  { missingSubtree :: Word64Map x -> f (Word64Map y)
missingSubtree = f (Word64Map y) -> Word64Map x -> f (Word64Map y)
forall a b. a -> b -> a
const (Word64Map y -> f (Word64Map y)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word64Map y
forall a. Word64Map a
Nil)
  , missingKey :: Word64 -> x -> f (Maybe y)
missingKey     = \Word64
_ x
_ -> Maybe y -> f (Maybe y)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe y
forall a. Maybe a
Nothing }
{-# INLINE dropMissing #-}


-- | Preserve, unchanged, the entries whose keys are missing from
-- the other map.
--
-- > preserveMissing :: SimpleWhenMissing x x
--
-- prop> preserveMissing = Merge.Lazy.mapMaybeMissing (\_ x -> Just x)
--
-- but @preserveMissing@ is much faster.
--
-- @since 0.5.9
preserveMissing :: Applicative f => WhenMissing f x x
preserveMissing :: forall (f :: * -> *) x. Applicative f => WhenMissing f x x
preserveMissing = WhenMissing
  { missingSubtree :: Word64Map x -> f (Word64Map x)
missingSubtree = Word64Map x -> f (Word64Map x)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
  , missingKey :: Word64 -> x -> f (Maybe x)
missingKey     = \Word64
_ x
v -> Maybe x -> f (Maybe x)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (x -> Maybe x
forall a. a -> Maybe a
Just x
v) }
{-# INLINE preserveMissing #-}


-- | Map over the entries whose keys are missing from the other map.
--
-- > mapMissing :: (k -> x -> y) -> SimpleWhenMissing x y
--
-- prop> mapMissing f = mapMaybeMissing (\k x -> Just $ f k x)
--
-- but @mapMissing@ is somewhat faster.
--
-- @since 0.5.9
mapMissing :: Applicative f => (Key -> x -> y) -> WhenMissing f x y
mapMissing :: forall (f :: * -> *) x y.
Applicative f =>
(Word64 -> x -> y) -> WhenMissing f x y
mapMissing Word64 -> x -> y
f = WhenMissing
  { missingSubtree :: Word64Map x -> f (Word64Map y)
missingSubtree = \Word64Map x
m -> Word64Map y -> f (Word64Map y)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word64Map y -> f (Word64Map y)) -> Word64Map y -> f (Word64Map y)
forall a b. (a -> b) -> a -> b
$! (Word64 -> x -> y) -> Word64Map x -> Word64Map y
forall a b. (Word64 -> a -> b) -> Word64Map a -> Word64Map b
mapWithKey Word64 -> x -> y
f Word64Map x
m
  , missingKey :: Word64 -> x -> f (Maybe y)
missingKey     = \Word64
k x
x -> Maybe y -> f (Maybe y)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe y -> f (Maybe y)) -> Maybe y -> f (Maybe y)
forall a b. (a -> b) -> a -> b
$ y -> Maybe y
forall a. a -> Maybe a
Just (Word64 -> x -> y
f Word64
k x
x) }
{-# INLINE mapMissing #-}


-- | Map over the entries whose keys are missing from the other
-- map, optionally removing some. This is the most powerful
-- 'SimpleWhenMissing' tactic, but others are usually more efficient.
--
-- > mapMaybeMissing :: (Key -> x -> Maybe y) -> SimpleWhenMissing x y
--
-- prop> mapMaybeMissing f = traverseMaybeMissing (\k x -> pure (f k x))
--
-- but @mapMaybeMissing@ uses fewer unnecessary 'Applicative'
-- operations.
--
-- @since 0.5.9
mapMaybeMissing
  :: Applicative f => (Key -> x -> Maybe y) -> WhenMissing f x y
mapMaybeMissing :: forall (f :: * -> *) x y.
Applicative f =>
(Word64 -> x -> Maybe y) -> WhenMissing f x y
mapMaybeMissing Word64 -> x -> Maybe y
f = WhenMissing
  { missingSubtree :: Word64Map x -> f (Word64Map y)
missingSubtree = \Word64Map x
m -> Word64Map y -> f (Word64Map y)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word64Map y -> f (Word64Map y)) -> Word64Map y -> f (Word64Map y)
forall a b. (a -> b) -> a -> b
$! (Word64 -> x -> Maybe y) -> Word64Map x -> Word64Map y
forall a b. (Word64 -> a -> Maybe b) -> Word64Map a -> Word64Map b
mapMaybeWithKey Word64 -> x -> Maybe y
f Word64Map x
m
  , missingKey :: Word64 -> x -> f (Maybe y)
missingKey     = \Word64
k x
x -> Maybe y -> f (Maybe y)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe y -> f (Maybe y)) -> Maybe y -> f (Maybe y)
forall a b. (a -> b) -> a -> b
$! Word64 -> x -> Maybe y
f Word64
k x
x }
{-# INLINE mapMaybeMissing #-}


-- | Filter the entries whose keys are missing from the other map.
--
-- > filterMissing :: (k -> x -> Bool) -> SimpleWhenMissing x x
--
-- prop> filterMissing f = Merge.Lazy.mapMaybeMissing $ \k x -> guard (f k x) *> Just x
--
-- but this should be a little faster.
--
-- @since 0.5.9
filterMissing
  :: Applicative f => (Key -> x -> Bool) -> WhenMissing f x x
filterMissing :: forall (f :: * -> *) x.
Applicative f =>
(Word64 -> x -> Bool) -> WhenMissing f x x
filterMissing Word64 -> x -> Bool
f = WhenMissing
  { missingSubtree :: Word64Map x -> f (Word64Map x)
missingSubtree = \Word64Map x
m -> Word64Map x -> f (Word64Map x)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word64Map x -> f (Word64Map x)) -> Word64Map x -> f (Word64Map x)
forall a b. (a -> b) -> a -> b
$! (Word64 -> x -> Bool) -> Word64Map x -> Word64Map x
forall a. (Word64 -> a -> Bool) -> Word64Map a -> Word64Map a
filterWithKey Word64 -> x -> Bool
f Word64Map x
m
  , missingKey :: Word64 -> x -> f (Maybe x)
missingKey     = \Word64
k x
x -> Maybe x -> f (Maybe x)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe x -> f (Maybe x)) -> Maybe x -> f (Maybe x)
forall a b. (a -> b) -> a -> b
$! if Word64 -> x -> Bool
f Word64
k x
x then x -> Maybe x
forall a. a -> Maybe a
Just x
x else Maybe x
forall a. Maybe a
Nothing }
{-# INLINE filterMissing #-}


-- | Filter the entries whose keys are missing from the other map
-- using some 'Applicative' action.
--
-- > filterAMissing f = Merge.Lazy.traverseMaybeMissing $
-- >   \k x -> (\b -> guard b *> Just x) <$> f k x
--
-- but this should be a little faster.
--
-- @since 0.5.9
filterAMissing
  :: Applicative f => (Key -> x -> f Bool) -> WhenMissing f x x
filterAMissing :: forall (f :: * -> *) x.
Applicative f =>
(Word64 -> x -> f Bool) -> WhenMissing f x x
filterAMissing Word64 -> x -> f Bool
f = WhenMissing
  { missingSubtree :: Word64Map x -> f (Word64Map x)
missingSubtree = \Word64Map x
m -> (Word64 -> x -> f Bool) -> Word64Map x -> f (Word64Map x)
forall (f :: * -> *) a.
Applicative f =>
(Word64 -> a -> f Bool) -> Word64Map a -> f (Word64Map a)
filterWithKeyA Word64 -> x -> f Bool
f Word64Map x
m
  , missingKey :: Word64 -> x -> f (Maybe x)
missingKey     = \Word64
k x
x -> Maybe x -> Maybe x -> Bool -> Maybe x
forall a. a -> a -> Bool -> a
bool Maybe x
forall a. Maybe a
Nothing (x -> Maybe x
forall a. a -> Maybe a
Just x
x) (Bool -> Maybe x) -> f Bool -> f (Maybe x)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word64 -> x -> f Bool
f Word64
k x
x }
{-# INLINE filterAMissing #-}


-- | \(O(n)\). Filter keys and values using an 'Applicative' predicate.
filterWithKeyA
  :: Applicative f => (Key -> a -> f Bool) -> Word64Map a -> f (Word64Map a)
filterWithKeyA :: forall (f :: * -> *) a.
Applicative f =>
(Word64 -> a -> f Bool) -> Word64Map a -> f (Word64Map a)
filterWithKeyA Word64 -> a -> f Bool
_ Word64Map a
Nil           = Word64Map a -> f (Word64Map a)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word64Map a
forall a. Word64Map a
Nil
filterWithKeyA Word64 -> a -> f Bool
f t :: Word64Map a
t@(Tip Word64
k a
x)   = (\Bool
b -> if Bool
b then Word64Map a
t else Word64Map a
forall a. Word64Map a
Nil) (Bool -> Word64Map a) -> f Bool -> f (Word64Map a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word64 -> a -> f Bool
f Word64
k a
x
filterWithKeyA Word64 -> a -> f Bool
f (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
  | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0     = (Word64Map a -> Word64Map a -> Word64Map a)
-> f (Word64Map a) -> f (Word64Map a) -> f (Word64Map a)
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 ((Word64Map a -> Word64Map a -> Word64Map a)
-> Word64Map a -> Word64Map a -> Word64Map a
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m)) ((Word64 -> a -> f Bool) -> Word64Map a -> f (Word64Map a)
forall (f :: * -> *) a.
Applicative f =>
(Word64 -> a -> f Bool) -> Word64Map a -> f (Word64Map a)
filterWithKeyA Word64 -> a -> f Bool
f Word64Map a
r) ((Word64 -> a -> f Bool) -> Word64Map a -> f (Word64Map a)
forall (f :: * -> *) a.
Applicative f =>
(Word64 -> a -> f Bool) -> Word64Map a -> f (Word64Map a)
filterWithKeyA Word64 -> a -> f Bool
f Word64Map a
l)
  | Bool
otherwise = (Word64Map a -> Word64Map a -> Word64Map a)
-> f (Word64Map a) -> f (Word64Map a) -> f (Word64Map a)
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 (Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m) ((Word64 -> a -> f Bool) -> Word64Map a -> f (Word64Map a)
forall (f :: * -> *) a.
Applicative f =>
(Word64 -> a -> f Bool) -> Word64Map a -> f (Word64Map a)
filterWithKeyA Word64 -> a -> f Bool
f Word64Map a
l) ((Word64 -> a -> f Bool) -> Word64Map a -> f (Word64Map a)
forall (f :: * -> *) a.
Applicative f =>
(Word64 -> a -> f Bool) -> Word64Map a -> f (Word64Map a)
filterWithKeyA Word64 -> a -> f Bool
f Word64Map a
r)

-- | This wasn't in Data.Bool until 4.7.0, so we define it here
bool :: a -> a -> Bool -> a
bool :: forall a. a -> a -> Bool -> a
bool a
f a
_ Bool
False = a
f
bool a
_ a
t Bool
True  = a
t


-- | Traverse over the entries whose keys are missing from the other
-- map.
--
-- @since 0.5.9
traverseMissing
  :: Applicative f => (Key -> x -> f y) -> WhenMissing f x y
traverseMissing :: forall (f :: * -> *) x y.
Applicative f =>
(Word64 -> x -> f y) -> WhenMissing f x y
traverseMissing Word64 -> x -> f y
f = WhenMissing
  { missingSubtree :: Word64Map x -> f (Word64Map y)
missingSubtree = (Word64 -> x -> f y) -> Word64Map x -> f (Word64Map y)
forall (t :: * -> *) a b.
Applicative t =>
(Word64 -> a -> t b) -> Word64Map a -> t (Word64Map b)
traverseWithKey Word64 -> x -> f y
f
  , missingKey :: Word64 -> x -> f (Maybe y)
missingKey = \Word64
k x
x -> y -> Maybe y
forall a. a -> Maybe a
Just (y -> Maybe y) -> f y -> f (Maybe y)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word64 -> x -> f y
f Word64
k x
x }
{-# INLINE traverseMissing #-}


-- | Traverse over the entries whose keys are missing from the other
-- map, optionally producing values to put in the result. This is
-- the most powerful 'WhenMissing' tactic, but others are usually
-- more efficient.
--
-- @since 0.5.9
traverseMaybeMissing
  :: Applicative f => (Key -> x -> f (Maybe y)) -> WhenMissing f x y
traverseMaybeMissing :: forall (f :: * -> *) x y.
Applicative f =>
(Word64 -> x -> f (Maybe y)) -> WhenMissing f x y
traverseMaybeMissing Word64 -> x -> f (Maybe y)
f = WhenMissing
  { missingSubtree :: Word64Map x -> f (Word64Map y)
missingSubtree = (Word64 -> x -> f (Maybe y)) -> Word64Map x -> f (Word64Map y)
forall (f :: * -> *) a b.
Applicative f =>
(Word64 -> a -> f (Maybe b)) -> Word64Map a -> f (Word64Map b)
traverseMaybeWithKey Word64 -> x -> f (Maybe y)
f
  , missingKey :: Word64 -> x -> f (Maybe y)
missingKey = Word64 -> x -> f (Maybe y)
f }
{-# INLINE traverseMaybeMissing #-}


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


-- | Merge two maps.
--
-- 'merge' takes two 'WhenMissing' tactics, a 'WhenMatched' tactic
-- and two maps. It uses the tactics to merge the maps. Its behavior
-- is best understood via its fundamental tactics, 'mapMaybeMissing'
-- and 'zipWithMaybeMatched'.
--
-- Consider
--
-- @
-- merge (mapMaybeMissing g1)
--              (mapMaybeMissing g2)
--              (zipWithMaybeMatched f)
--              m1 m2
-- @
--
-- Take, for example,
--
-- @
-- m1 = [(0, \'a\'), (1, \'b\'), (3, \'c\'), (4, \'d\')]
-- m2 = [(1, "one"), (2, "two"), (4, "three")]
-- @
--
-- 'merge' will first \"align\" these maps by key:
--
-- @
-- m1 = [(0, \'a\'), (1, \'b\'),               (3, \'c\'), (4, \'d\')]
-- m2 =           [(1, "one"), (2, "two"),           (4, "three")]
-- @
--
-- It will then pass the individual entries and pairs of entries
-- to @g1@, @g2@, or @f@ as appropriate:
--
-- @
-- maybes = [g1 0 \'a\', f 1 \'b\' "one", g2 2 "two", g1 3 \'c\', f 4 \'d\' "three"]
-- @
--
-- This produces a 'Maybe' for each key:
--
-- @
-- keys =     0        1          2           3        4
-- results = [Nothing, Just True, Just False, Nothing, Just True]
-- @
--
-- Finally, the @Just@ results are collected into a map:
--
-- @
-- return value = [(1, True), (2, False), (4, True)]
-- @
--
-- The other tactics below are optimizations or simplifications of
-- 'mapMaybeMissing' for special cases. Most importantly,
--
-- * 'dropMissing' drops all the keys.
-- * 'preserveMissing' leaves all the entries alone.
--
-- When 'merge' is given three arguments, it is inlined at the call
-- site. To prevent excessive inlining, you should typically use
-- 'merge' to define your custom combining functions.
--
--
-- Examples:
--
-- prop> unionWithKey f = merge preserveMissing preserveMissing (zipWithMatched f)
-- prop> intersectionWithKey f = merge dropMissing dropMissing (zipWithMatched f)
-- prop> differenceWith f = merge diffPreserve diffDrop f
-- prop> symmetricDifference = merge diffPreserve diffPreserve (\ _ _ _ -> Nothing)
-- prop> mapEachPiece f g h = merge (diffMapWithKey f) (diffMapWithKey g)
--
-- @since 0.5.9
merge
  :: SimpleWhenMissing a c -- ^ What to do with keys in @m1@ but not @m2@
  -> SimpleWhenMissing b c -- ^ What to do with keys in @m2@ but not @m1@
  -> SimpleWhenMatched a b c -- ^ What to do with keys in both @m1@ and @m2@
  -> Word64Map a -- ^ Map @m1@
  -> Word64Map b -- ^ Map @m2@
  -> Word64Map c
merge :: forall a c b.
SimpleWhenMissing a c
-> SimpleWhenMissing b c
-> SimpleWhenMatched a b c
-> Word64Map a
-> Word64Map b
-> Word64Map c
merge SimpleWhenMissing a c
g1 SimpleWhenMissing b c
g2 SimpleWhenMatched a b c
f Word64Map a
m1 Word64Map b
m2 =
  Identity (Word64Map c) -> Word64Map c
forall a. Identity a -> a
runIdentity (Identity (Word64Map c) -> Word64Map c)
-> Identity (Word64Map c) -> Word64Map c
forall a b. (a -> b) -> a -> b
$ SimpleWhenMissing a c
-> SimpleWhenMissing b c
-> SimpleWhenMatched a b c
-> Word64Map a
-> Word64Map b
-> Identity (Word64Map c)
forall (f :: * -> *) a c b.
Applicative f =>
WhenMissing f a c
-> WhenMissing f b c
-> WhenMatched f a b c
-> Word64Map a
-> Word64Map b
-> f (Word64Map c)
mergeA SimpleWhenMissing a c
g1 SimpleWhenMissing b c
g2 SimpleWhenMatched a b c
f Word64Map a
m1 Word64Map b
m2
{-# INLINE merge #-}


-- | An applicative version of 'merge'.
--
-- 'mergeA' takes two 'WhenMissing' tactics, a 'WhenMatched'
-- tactic and two maps. It uses the tactics to merge the maps.
-- Its behavior is best understood via its fundamental tactics,
-- 'traverseMaybeMissing' and 'zipWithMaybeAMatched'.
--
-- Consider
--
-- @
-- mergeA (traverseMaybeMissing g1)
--               (traverseMaybeMissing g2)
--               (zipWithMaybeAMatched f)
--               m1 m2
-- @
--
-- Take, for example,
--
-- @
-- m1 = [(0, \'a\'), (1, \'b\'), (3,\'c\'), (4, \'d\')]
-- m2 = [(1, "one"), (2, "two"), (4, "three")]
-- @
--
-- 'mergeA' will first \"align\" these maps by key:
--
-- @
-- m1 = [(0, \'a\'), (1, \'b\'),               (3, \'c\'), (4, \'d\')]
-- m2 =           [(1, "one"), (2, "two"),           (4, "three")]
-- @
--
-- It will then pass the individual entries and pairs of entries
-- to @g1@, @g2@, or @f@ as appropriate:
--
-- @
-- actions = [g1 0 \'a\', f 1 \'b\' "one", g2 2 "two", g1 3 \'c\', f 4 \'d\' "three"]
-- @
--
-- Next, it will perform the actions in the @actions@ list in order from
-- left to right.
--
-- @
-- keys =     0        1          2           3        4
-- results = [Nothing, Just True, Just False, Nothing, Just True]
-- @
--
-- Finally, the @Just@ results are collected into a map:
--
-- @
-- return value = [(1, True), (2, False), (4, True)]
-- @
--
-- The other tactics below are optimizations or simplifications of
-- 'traverseMaybeMissing' for special cases. Most importantly,
--
-- * 'dropMissing' drops all the keys.
-- * 'preserveMissing' leaves all the entries alone.
-- * 'mapMaybeMissing' does not use the 'Applicative' context.
--
-- When 'mergeA' is given three arguments, it is inlined at the call
-- site. To prevent excessive inlining, you should generally only use
-- 'mergeA' to define custom combining functions.
--
-- @since 0.5.9
mergeA
  :: (Applicative f)
  => WhenMissing f a c -- ^ What to do with keys in @m1@ but not @m2@
  -> WhenMissing f b c -- ^ What to do with keys in @m2@ but not @m1@
  -> WhenMatched f a b c -- ^ What to do with keys in both @m1@ and @m2@
  -> Word64Map a -- ^ Map @m1@
  -> Word64Map b -- ^ Map @m2@
  -> f (Word64Map c)
mergeA :: forall (f :: * -> *) a c b.
Applicative f =>
WhenMissing f a c
-> WhenMissing f b c
-> WhenMatched f a b c
-> Word64Map a
-> Word64Map b
-> f (Word64Map c)
mergeA
    WhenMissing{missingSubtree :: forall (f :: * -> *) x y.
WhenMissing f x y -> Word64Map x -> f (Word64Map y)
missingSubtree = Word64Map a -> f (Word64Map c)
g1t, missingKey :: forall (f :: * -> *) x y.
WhenMissing f x y -> Word64 -> x -> f (Maybe y)
missingKey = Word64 -> a -> f (Maybe c)
g1k}
    WhenMissing{missingSubtree :: forall (f :: * -> *) x y.
WhenMissing f x y -> Word64Map x -> f (Word64Map y)
missingSubtree = Word64Map b -> f (Word64Map c)
g2t, missingKey :: forall (f :: * -> *) x y.
WhenMissing f x y -> Word64 -> x -> f (Maybe y)
missingKey = Word64 -> b -> f (Maybe c)
g2k}
    WhenMatched{matchedKey :: forall (f :: * -> *) x y z.
WhenMatched f x y z -> Word64 -> x -> y -> f (Maybe z)
matchedKey = Word64 -> a -> b -> f (Maybe c)
f}
    = Word64Map a -> Word64Map b -> f (Word64Map c)
go
  where
    go :: Word64Map a -> Word64Map b -> f (Word64Map c)
go Word64Map a
t1  Word64Map b
Nil = Word64Map a -> f (Word64Map c)
g1t Word64Map a
t1
    go Word64Map a
Nil Word64Map b
t2  = Word64Map b -> f (Word64Map c)
g2t Word64Map b
t2

    -- This case is already covered below.
    -- go (Tip k1 x1) (Tip k2 x2) = mergeTips k1 x1 k2 x2

    go (Tip Word64
k1 a
x1) Word64Map b
t2' = Word64Map b -> f (Word64Map c)
merge2 Word64Map b
t2'
      where
        merge2 :: Word64Map b -> f (Word64Map c)
merge2 t2 :: Word64Map b
t2@(Bin Word64
p2 Word64
m2 Word64Map b
l2 Word64Map b
r2)
          | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
k1 Word64
p2 Word64
m2 = Word64
-> f (Word64Map c) -> Word64 -> f (Word64Map c) -> f (Word64Map c)
forall (f :: * -> *) a.
Applicative f =>
Word64
-> f (Word64Map a) -> Word64 -> f (Word64Map a) -> f (Word64Map a)
linkA Word64
k1 ((Word64 -> a -> f (Maybe c)) -> Word64 -> a -> f (Word64Map c)
forall {f :: * -> *} {t} {a}.
Functor f =>
(Word64 -> t -> f (Maybe a)) -> Word64 -> t -> f (Word64Map a)
subsingletonBy Word64 -> a -> f (Maybe c)
g1k Word64
k1 a
x1) Word64
p2 (Word64Map b -> f (Word64Map c)
g2t Word64Map b
t2)
          | Word64 -> Word64 -> Bool
zero Word64
k1 Word64
m2       = Word64
-> Word64 -> f (Word64Map c) -> f (Word64Map c) -> f (Word64Map c)
forall (f :: * -> *) a.
Applicative f =>
Word64
-> Word64 -> f (Word64Map a) -> f (Word64Map a) -> f (Word64Map a)
binA Word64
p2 Word64
m2 (Word64Map b -> f (Word64Map c)
merge2 Word64Map b
l2) (Word64Map b -> f (Word64Map c)
g2t Word64Map b
r2)
          | Bool
otherwise        = Word64
-> Word64 -> f (Word64Map c) -> f (Word64Map c) -> f (Word64Map c)
forall (f :: * -> *) a.
Applicative f =>
Word64
-> Word64 -> f (Word64Map a) -> f (Word64Map a) -> f (Word64Map a)
binA Word64
p2 Word64
m2 (Word64Map b -> f (Word64Map c)
g2t Word64Map b
l2) (Word64Map b -> f (Word64Map c)
merge2 Word64Map b
r2)
        merge2 (Tip Word64
k2 b
x2)   = Word64 -> a -> Word64 -> b -> f (Word64Map c)
mergeTips Word64
k1 a
x1 Word64
k2 b
x2
        merge2 Word64Map b
Nil           = (Word64 -> a -> f (Maybe c)) -> Word64 -> a -> f (Word64Map c)
forall {f :: * -> *} {t} {a}.
Functor f =>
(Word64 -> t -> f (Maybe a)) -> Word64 -> t -> f (Word64Map a)
subsingletonBy Word64 -> a -> f (Maybe c)
g1k Word64
k1 a
x1

    go Word64Map a
t1' (Tip Word64
k2 b
x2) = Word64Map a -> f (Word64Map c)
merge1 Word64Map a
t1'
      where
        merge1 :: Word64Map a -> f (Word64Map c)
merge1 t1 :: Word64Map a
t1@(Bin Word64
p1 Word64
m1 Word64Map a
l1 Word64Map a
r1)
          | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
k2 Word64
p1 Word64
m1 = Word64
-> f (Word64Map c) -> Word64 -> f (Word64Map c) -> f (Word64Map c)
forall (f :: * -> *) a.
Applicative f =>
Word64
-> f (Word64Map a) -> Word64 -> f (Word64Map a) -> f (Word64Map a)
linkA Word64
p1 (Word64Map a -> f (Word64Map c)
g1t Word64Map a
t1) Word64
k2 ((Word64 -> b -> f (Maybe c)) -> Word64 -> b -> f (Word64Map c)
forall {f :: * -> *} {t} {a}.
Functor f =>
(Word64 -> t -> f (Maybe a)) -> Word64 -> t -> f (Word64Map a)
subsingletonBy Word64 -> b -> f (Maybe c)
g2k Word64
k2 b
x2)
          | Word64 -> Word64 -> Bool
zero Word64
k2 Word64
m1       = Word64
-> Word64 -> f (Word64Map c) -> f (Word64Map c) -> f (Word64Map c)
forall (f :: * -> *) a.
Applicative f =>
Word64
-> Word64 -> f (Word64Map a) -> f (Word64Map a) -> f (Word64Map a)
binA Word64
p1 Word64
m1 (Word64Map a -> f (Word64Map c)
merge1 Word64Map a
l1) (Word64Map a -> f (Word64Map c)
g1t Word64Map a
r1)
          | Bool
otherwise        = Word64
-> Word64 -> f (Word64Map c) -> f (Word64Map c) -> f (Word64Map c)
forall (f :: * -> *) a.
Applicative f =>
Word64
-> Word64 -> f (Word64Map a) -> f (Word64Map a) -> f (Word64Map a)
binA Word64
p1 Word64
m1 (Word64Map a -> f (Word64Map c)
g1t Word64Map a
l1) (Word64Map a -> f (Word64Map c)
merge1 Word64Map a
r1)
        merge1 (Tip Word64
k1 a
x1)   = Word64 -> a -> Word64 -> b -> f (Word64Map c)
mergeTips Word64
k1 a
x1 Word64
k2 b
x2
        merge1 Word64Map a
Nil           = (Word64 -> b -> f (Maybe c)) -> Word64 -> b -> f (Word64Map c)
forall {f :: * -> *} {t} {a}.
Functor f =>
(Word64 -> t -> f (Maybe a)) -> Word64 -> t -> f (Word64Map a)
subsingletonBy Word64 -> b -> f (Maybe c)
g2k Word64
k2 b
x2

    go t1 :: Word64Map a
t1@(Bin Word64
p1 Word64
m1 Word64Map a
l1 Word64Map a
r1) t2 :: Word64Map b
t2@(Bin Word64
p2 Word64
m2 Word64Map b
l2 Word64Map b
r2)
      | Word64 -> Word64 -> Bool
shorter Word64
m1 Word64
m2  = f (Word64Map c)
merge1
      | Word64 -> Word64 -> Bool
shorter Word64
m2 Word64
m1  = f (Word64Map c)
merge2
      | Word64
p1 Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
p2       = Word64
-> Word64 -> f (Word64Map c) -> f (Word64Map c) -> f (Word64Map c)
forall (f :: * -> *) a.
Applicative f =>
Word64
-> Word64 -> f (Word64Map a) -> f (Word64Map a) -> f (Word64Map a)
binA Word64
p1 Word64
m1 (Word64Map a -> Word64Map b -> f (Word64Map c)
go Word64Map a
l1 Word64Map b
l2) (Word64Map a -> Word64Map b -> f (Word64Map c)
go Word64Map a
r1 Word64Map b
r2)
      | Bool
otherwise      = Word64
-> f (Word64Map c) -> Word64 -> f (Word64Map c) -> f (Word64Map c)
forall (f :: * -> *) a.
Applicative f =>
Word64
-> f (Word64Map a) -> Word64 -> f (Word64Map a) -> f (Word64Map a)
linkA Word64
p1 (Word64Map a -> f (Word64Map c)
g1t Word64Map a
t1) Word64
p2 (Word64Map b -> f (Word64Map c)
g2t Word64Map b
t2)
      where
        merge1 :: f (Word64Map c)
merge1 | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
p2 Word64
p1 Word64
m1  = Word64
-> f (Word64Map c) -> Word64 -> f (Word64Map c) -> f (Word64Map c)
forall (f :: * -> *) a.
Applicative f =>
Word64
-> f (Word64Map a) -> Word64 -> f (Word64Map a) -> f (Word64Map a)
linkA Word64
p1 (Word64Map a -> f (Word64Map c)
g1t Word64Map a
t1) Word64
p2 (Word64Map b -> f (Word64Map c)
g2t Word64Map b
t2)
               | Word64 -> Word64 -> Bool
zero Word64
p2 Word64
m1        = Word64
-> Word64 -> f (Word64Map c) -> f (Word64Map c) -> f (Word64Map c)
forall (f :: * -> *) a.
Applicative f =>
Word64
-> Word64 -> f (Word64Map a) -> f (Word64Map a) -> f (Word64Map a)
binA Word64
p1 Word64
m1 (Word64Map a -> Word64Map b -> f (Word64Map c)
go  Word64Map a
l1 Word64Map b
t2) (Word64Map a -> f (Word64Map c)
g1t Word64Map a
r1)
               | Bool
otherwise         = Word64
-> Word64 -> f (Word64Map c) -> f (Word64Map c) -> f (Word64Map c)
forall (f :: * -> *) a.
Applicative f =>
Word64
-> Word64 -> f (Word64Map a) -> f (Word64Map a) -> f (Word64Map a)
binA Word64
p1 Word64
m1 (Word64Map a -> f (Word64Map c)
g1t Word64Map a
l1)    (Word64Map a -> Word64Map b -> f (Word64Map c)
go  Word64Map a
r1 Word64Map b
t2)
        merge2 :: f (Word64Map c)
merge2 | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
p1 Word64
p2 Word64
m2  = Word64
-> f (Word64Map c) -> Word64 -> f (Word64Map c) -> f (Word64Map c)
forall (f :: * -> *) a.
Applicative f =>
Word64
-> f (Word64Map a) -> Word64 -> f (Word64Map a) -> f (Word64Map a)
linkA Word64
p1 (Word64Map a -> f (Word64Map c)
g1t Word64Map a
t1) Word64
p2 (Word64Map b -> f (Word64Map c)
g2t Word64Map b
t2)
               | Word64 -> Word64 -> Bool
zero Word64
p1 Word64
m2        = Word64
-> Word64 -> f (Word64Map c) -> f (Word64Map c) -> f (Word64Map c)
forall (f :: * -> *) a.
Applicative f =>
Word64
-> Word64 -> f (Word64Map a) -> f (Word64Map a) -> f (Word64Map a)
binA Word64
p2 Word64
m2 (Word64Map a -> Word64Map b -> f (Word64Map c)
go  Word64Map a
t1 Word64Map b
l2) (Word64Map b -> f (Word64Map c)
g2t    Word64Map b
r2)
               | Bool
otherwise         = Word64
-> Word64 -> f (Word64Map c) -> f (Word64Map c) -> f (Word64Map c)
forall (f :: * -> *) a.
Applicative f =>
Word64
-> Word64 -> f (Word64Map a) -> f (Word64Map a) -> f (Word64Map a)
binA Word64
p2 Word64
m2 (Word64Map b -> f (Word64Map c)
g2t    Word64Map b
l2) (Word64Map a -> Word64Map b -> f (Word64Map c)
go  Word64Map a
t1 Word64Map b
r2)

    subsingletonBy :: (Word64 -> t -> f (Maybe a)) -> Word64 -> t -> f (Word64Map a)
subsingletonBy Word64 -> t -> f (Maybe a)
gk Word64
k t
x = Word64Map a -> (a -> Word64Map a) -> Maybe a -> Word64Map a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Word64Map a
forall a. Word64Map a
Nil (Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k) (Maybe a -> Word64Map a) -> f (Maybe a) -> f (Word64Map a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word64 -> t -> f (Maybe a)
gk Word64
k t
x
    {-# INLINE subsingletonBy #-}

    mergeTips :: Word64 -> a -> Word64 -> b -> f (Word64Map c)
mergeTips Word64
k1 a
x1 Word64
k2 b
x2
      | Word64
k1 Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
k2  = Word64Map c -> (c -> Word64Map c) -> Maybe c -> Word64Map c
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Word64Map c
forall a. Word64Map a
Nil (Word64 -> c -> Word64Map c
forall a. Word64 -> a -> Word64Map a
Tip Word64
k1) (Maybe c -> Word64Map c) -> f (Maybe c) -> f (Word64Map c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word64 -> a -> b -> f (Maybe c)
f Word64
k1 a
x1 b
x2
      | Word64
k1 Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
<  Word64
k2  = (Maybe c -> Maybe c -> Word64Map c)
-> f (Maybe c) -> f (Maybe c) -> f (Word64Map c)
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 (Word64 -> Word64 -> Maybe c -> Maybe c -> Word64Map c
forall {a}. Word64 -> Word64 -> Maybe a -> Maybe a -> Word64Map a
subdoubleton Word64
k1 Word64
k2) (Word64 -> a -> f (Maybe c)
g1k Word64
k1 a
x1) (Word64 -> b -> f (Maybe c)
g2k Word64
k2 b
x2)
        {-
        = link_ k1 k2 <$> subsingletonBy g1k k1 x1 <*> subsingletonBy g2k k2 x2
        -}
      | Bool
otherwise = (Maybe c -> Maybe c -> Word64Map c)
-> f (Maybe c) -> f (Maybe c) -> f (Word64Map c)
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 (Word64 -> Word64 -> Maybe c -> Maybe c -> Word64Map c
forall {a}. Word64 -> Word64 -> Maybe a -> Maybe a -> Word64Map a
subdoubleton Word64
k2 Word64
k1) (Word64 -> b -> f (Maybe c)
g2k Word64
k2 b
x2) (Word64 -> a -> f (Maybe c)
g1k Word64
k1 a
x1)
    {-# INLINE mergeTips #-}

    subdoubleton :: Word64 -> Word64 -> Maybe a -> Maybe a -> Word64Map a
subdoubleton Word64
_ Word64
_   Maybe a
Nothing Maybe a
Nothing     = Word64Map a
forall a. Word64Map a
Nil
    subdoubleton Word64
_ Word64
k2  Maybe a
Nothing (Just a
y2)   = Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k2 a
y2
    subdoubleton Word64
k1 Word64
_  (Just a
y1) Maybe a
Nothing   = Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k1 a
y1
    subdoubleton Word64
k1 Word64
k2 (Just a
y1) (Just a
y2) = Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
link Word64
k1 (Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k1 a
y1) Word64
k2 (Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k2 a
y2)
    {-# INLINE subdoubleton #-}

    -- A variant of 'link_' which makes sure to execute side-effects
    -- in the right order.
    linkA
        :: Applicative f
        => Prefix -> f (Word64Map a)
        -> Prefix -> f (Word64Map a)
        -> f (Word64Map a)
    linkA :: forall (f :: * -> *) a.
Applicative f =>
Word64
-> f (Word64Map a) -> Word64 -> f (Word64Map a) -> f (Word64Map a)
linkA Word64
p1 f (Word64Map a)
t1 Word64
p2 f (Word64Map a)
t2
      | Word64 -> Word64 -> Bool
zero Word64
p1 Word64
m = Word64
-> Word64 -> f (Word64Map a) -> f (Word64Map a) -> f (Word64Map a)
forall (f :: * -> *) a.
Applicative f =>
Word64
-> Word64 -> f (Word64Map a) -> f (Word64Map a) -> f (Word64Map a)
binA Word64
p Word64
m f (Word64Map a)
t1 f (Word64Map a)
t2
      | Bool
otherwise = Word64
-> Word64 -> f (Word64Map a) -> f (Word64Map a) -> f (Word64Map a)
forall (f :: * -> *) a.
Applicative f =>
Word64
-> Word64 -> f (Word64Map a) -> f (Word64Map a) -> f (Word64Map a)
binA Word64
p Word64
m f (Word64Map a)
t2 f (Word64Map a)
t1
      where
        m :: Word64
m = Word64 -> Word64 -> Word64
branchMask Word64
p1 Word64
p2
        p :: Word64
p = Word64 -> Word64 -> Word64
mask Word64
p1 Word64
m
    {-# INLINE linkA #-}

    -- A variant of 'bin' that ensures that effects for negative keys are executed
    -- first.
    binA
        :: Applicative f
        => Prefix
        -> Mask
        -> f (Word64Map a)
        -> f (Word64Map a)
        -> f (Word64Map a)
    binA :: forall (f :: * -> *) a.
Applicative f =>
Word64
-> Word64 -> f (Word64Map a) -> f (Word64Map a) -> f (Word64Map a)
binA Word64
p Word64
m f (Word64Map a)
a f (Word64Map a)
b
      | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0     = (Word64Map a -> Word64Map a -> Word64Map a)
-> f (Word64Map a) -> f (Word64Map a) -> f (Word64Map a)
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 ((Word64Map a -> Word64Map a -> Word64Map a)
-> Word64Map a -> Word64Map a -> Word64Map a
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m)) f (Word64Map a)
b f (Word64Map a)
a
      | Bool
otherwise = (Word64Map a -> Word64Map a -> Word64Map a)
-> f (Word64Map a) -> f (Word64Map a) -> f (Word64Map a)
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       (Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m)  f (Word64Map a)
a f (Word64Map a)
b
    {-# INLINE binA #-}
{-# INLINE mergeA #-}


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

-- | \(O(\min(n,W))\). 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) -> Word64Map a -> Word64Map a
updateMinWithKey :: forall a. (Word64 -> a -> Maybe a) -> Word64Map a -> Word64Map a
updateMinWithKey Word64 -> a -> Maybe a
f Word64Map a
t =
  case Word64Map a
t of Bin Word64
p Word64
m Word64Map a
l Word64Map a
r | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 -> Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckRight Word64
p Word64
m Word64Map a
l ((Word64 -> a -> Maybe a) -> Word64Map a -> Word64Map a
forall a. (Word64 -> a -> Maybe a) -> Word64Map a -> Word64Map a
go Word64 -> a -> Maybe a
f Word64Map a
r)
            Word64Map a
_ -> (Word64 -> a -> Maybe a) -> Word64Map a -> Word64Map a
forall a. (Word64 -> a -> Maybe a) -> Word64Map a -> Word64Map a
go Word64 -> a -> Maybe a
f Word64Map a
t
  where
    go :: (Word64 -> t -> Maybe t) -> Word64Map t -> Word64Map t
go Word64 -> t -> Maybe t
f' (Bin Word64
p Word64
m Word64Map t
l Word64Map t
r) = Word64 -> Word64 -> Word64Map t -> Word64Map t -> Word64Map t
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckLeft Word64
p Word64
m ((Word64 -> t -> Maybe t) -> Word64Map t -> Word64Map t
go Word64 -> t -> Maybe t
f' Word64Map t
l) Word64Map t
r
    go Word64 -> t -> Maybe t
f' (Tip Word64
k t
y) = case Word64 -> t -> Maybe t
f' Word64
k t
y of
                        Just t
y' -> Word64 -> t -> Word64Map t
forall a. Word64 -> a -> Word64Map a
Tip Word64
k t
y'
                        Maybe t
Nothing -> Word64Map t
forall a. Word64Map a
Nil
    go Word64 -> t -> Maybe t
_ Word64Map t
Nil = [Char] -> Word64Map t
forall a. HasCallStack => [Char] -> a
error [Char]
"updateMinWithKey Nil"

-- | \(O(\min(n,W))\). 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) -> Word64Map a -> Word64Map a
updateMaxWithKey :: forall a. (Word64 -> a -> Maybe a) -> Word64Map a -> Word64Map a
updateMaxWithKey Word64 -> a -> Maybe a
f Word64Map a
t =
  case Word64Map a
t of Bin Word64
p Word64
m Word64Map a
l Word64Map a
r | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 -> Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckLeft Word64
p Word64
m ((Word64 -> a -> Maybe a) -> Word64Map a -> Word64Map a
forall a. (Word64 -> a -> Maybe a) -> Word64Map a -> Word64Map a
go Word64 -> a -> Maybe a
f Word64Map a
l) Word64Map a
r
            Word64Map a
_ -> (Word64 -> a -> Maybe a) -> Word64Map a -> Word64Map a
forall a. (Word64 -> a -> Maybe a) -> Word64Map a -> Word64Map a
go Word64 -> a -> Maybe a
f Word64Map a
t
  where
    go :: (Word64 -> t -> Maybe t) -> Word64Map t -> Word64Map t
go Word64 -> t -> Maybe t
f' (Bin Word64
p Word64
m Word64Map t
l Word64Map t
r) = Word64 -> Word64 -> Word64Map t -> Word64Map t -> Word64Map t
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckRight Word64
p Word64
m Word64Map t
l ((Word64 -> t -> Maybe t) -> Word64Map t -> Word64Map t
go Word64 -> t -> Maybe t
f' Word64Map t
r)
    go Word64 -> t -> Maybe t
f' (Tip Word64
k t
y) = case Word64 -> t -> Maybe t
f' Word64
k t
y of
                        Just t
y' -> Word64 -> t -> Word64Map t
forall a. Word64 -> a -> Word64Map a
Tip Word64
k t
y'
                        Maybe t
Nothing -> Word64Map t
forall a. Word64Map a
Nil
    go Word64 -> t -> Maybe t
_ Word64Map t
Nil = [Char] -> Word64Map t
forall a. HasCallStack => [Char] -> a
error [Char]
"updateMaxWithKey Nil"


data View a = View {-# UNPACK #-} !Key a !(Word64Map a)

-- | \(O(\min(n,W))\). Retrieves the maximal (key,value) pair of the map, and
-- the map stripped of that element, or 'Nothing' if passed an empty map.
--
-- > maxViewWithKey (fromList [(5,"a"), (3,"b")]) == Just ((5,"a"), singleton 3 "b")
-- > maxViewWithKey empty == Nothing

maxViewWithKey :: Word64Map a -> Maybe ((Key, a), Word64Map a)
maxViewWithKey :: forall a. Word64Map a -> Maybe ((Word64, a), Word64Map a)
maxViewWithKey Word64Map a
t = case Word64Map a
t of
  Word64Map a
Nil -> Maybe ((Word64, a), Word64Map a)
forall a. Maybe a
Nothing
  Word64Map a
_ -> ((Word64, a), Word64Map a) -> Maybe ((Word64, a), Word64Map a)
forall a. a -> Maybe a
Just (((Word64, a), Word64Map a) -> Maybe ((Word64, a), Word64Map a))
-> ((Word64, a), Word64Map a) -> Maybe ((Word64, a), Word64Map a)
forall a b. (a -> b) -> a -> b
$ case Word64Map a -> View a
forall a. Word64Map a -> View a
maxViewWithKeySure Word64Map a
t of
                View Word64
k a
v Word64Map a
t' -> ((Word64
k, a
v), Word64Map a
t')
{-# INLINE maxViewWithKey #-}

maxViewWithKeySure :: Word64Map a -> View a
maxViewWithKeySure :: forall a. Word64Map a -> View a
maxViewWithKeySure Word64Map a
t =
  case Word64Map a
t of
    Word64Map a
Nil -> [Char] -> View a
forall a. HasCallStack => [Char] -> a
error [Char]
"maxViewWithKeySure Nil"
    Bin Word64
p Word64
m Word64Map a
l Word64Map a
r | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 ->
      case Word64Map a -> View a
forall a. Word64Map a -> View a
go Word64Map a
l of View Word64
k a
a Word64Map a
l' -> Word64 -> a -> Word64Map a -> View a
forall a. Word64 -> a -> Word64Map a -> View a
View Word64
k a
a (Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckLeft Word64
p Word64
m Word64Map a
l' Word64Map a
r)
    Word64Map a
_ -> Word64Map a -> View a
forall a. Word64Map a -> View a
go Word64Map a
t
  where
    go :: Word64Map a -> View a
go (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r) =
        case Word64Map a -> View a
go Word64Map a
r of View Word64
k a
a Word64Map a
r' -> Word64 -> a -> Word64Map a -> View a
forall a. Word64 -> a -> Word64Map a -> View a
View Word64
k a
a (Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckRight Word64
p Word64
m Word64Map a
l Word64Map a
r')
    go (Tip Word64
k a
y) = Word64 -> a -> Word64Map a -> View a
forall a. Word64 -> a -> Word64Map a -> View a
View Word64
k a
y Word64Map a
forall a. Word64Map a
Nil
    go Word64Map a
Nil = [Char] -> View a
forall a. HasCallStack => [Char] -> a
error [Char]
"maxViewWithKey_go Nil"
-- See note on NOINLINE at minViewWithKeySure
{-# NOINLINE maxViewWithKeySure #-}

-- | \(O(\min(n,W))\). Retrieves the minimal (key,value) pair of the map, and
-- the map stripped of that element, or 'Nothing' if passed an empty map.
--
-- > minViewWithKey (fromList [(5,"a"), (3,"b")]) == Just ((3,"b"), singleton 5 "a")
-- > minViewWithKey empty == Nothing

minViewWithKey :: Word64Map a -> Maybe ((Key, a), Word64Map a)
minViewWithKey :: forall a. Word64Map a -> Maybe ((Word64, a), Word64Map a)
minViewWithKey Word64Map a
t =
  case Word64Map a
t of
    Word64Map a
Nil -> Maybe ((Word64, a), Word64Map a)
forall a. Maybe a
Nothing
    Word64Map a
_ -> ((Word64, a), Word64Map a) -> Maybe ((Word64, a), Word64Map a)
forall a. a -> Maybe a
Just (((Word64, a), Word64Map a) -> Maybe ((Word64, a), Word64Map a))
-> ((Word64, a), Word64Map a) -> Maybe ((Word64, a), Word64Map a)
forall a b. (a -> b) -> a -> b
$ case Word64Map a -> View a
forall a. Word64Map a -> View a
minViewWithKeySure Word64Map a
t of
                  View Word64
k a
v Word64Map a
t' -> ((Word64
k, a
v), Word64Map a
t')
-- We inline this to give GHC the best possible chance of
-- getting rid of the Maybe, pair, and Int constructors, as
-- well as a thunk under the Just. That is, we really want to
-- be certain this inlines!
{-# INLINE minViewWithKey #-}

minViewWithKeySure :: Word64Map a -> View a
minViewWithKeySure :: forall a. Word64Map a -> View a
minViewWithKeySure Word64Map a
t =
  case Word64Map a
t of
    Word64Map a
Nil -> [Char] -> View a
forall a. HasCallStack => [Char] -> a
error [Char]
"minViewWithKeySure Nil"
    Bin Word64
p Word64
m Word64Map a
l Word64Map a
r | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 ->
      case Word64Map a -> View a
forall a. Word64Map a -> View a
go Word64Map a
r of
        View Word64
k a
a Word64Map a
r' -> Word64 -> a -> Word64Map a -> View a
forall a. Word64 -> a -> Word64Map a -> View a
View Word64
k a
a (Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckRight Word64
p Word64
m Word64Map a
l Word64Map a
r')
    Word64Map a
_ -> Word64Map a -> View a
forall a. Word64Map a -> View a
go Word64Map a
t
  where
    go :: Word64Map a -> View a
go (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r) =
        case Word64Map a -> View a
go Word64Map a
l of View Word64
k a
a Word64Map a
l' -> Word64 -> a -> Word64Map a -> View a
forall a. Word64 -> a -> Word64Map a -> View a
View Word64
k a
a (Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckLeft Word64
p Word64
m Word64Map a
l' Word64Map a
r)
    go (Tip Word64
k a
y) = Word64 -> a -> Word64Map a -> View a
forall a. Word64 -> a -> Word64Map a -> View a
View Word64
k a
y Word64Map a
forall a. Word64Map a
Nil
    go Word64Map a
Nil = [Char] -> View a
forall a. HasCallStack => [Char] -> a
error [Char]
"minViewWithKey_go Nil"
-- There's never anything significant to be gained by inlining
-- this. Sufficiently recent GHC versions will inline the wrapper
-- anyway, which should be good enough.
{-# NOINLINE minViewWithKeySure #-}

-- | \(O(\min(n,W))\). 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) -> Word64Map a -> Word64Map a
updateMax :: forall a. (a -> Maybe a) -> Word64Map a -> Word64Map a
updateMax a -> Maybe a
f = (Word64 -> a -> Maybe a) -> Word64Map a -> Word64Map a
forall a. (Word64 -> a -> Maybe a) -> Word64Map a -> Word64Map a
updateMaxWithKey ((a -> Maybe a) -> Word64 -> a -> Maybe a
forall a b. a -> b -> a
const a -> Maybe a
f)

-- | \(O(\min(n,W))\). 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) -> Word64Map a -> Word64Map a
updateMin :: forall a. (a -> Maybe a) -> Word64Map a -> Word64Map a
updateMin a -> Maybe a
f = (Word64 -> a -> Maybe a) -> Word64Map a -> Word64Map a
forall a. (Word64 -> a -> Maybe a) -> Word64Map a -> Word64Map a
updateMinWithKey ((a -> Maybe a) -> Word64 -> a -> Maybe a
forall a b. a -> b -> a
const a -> Maybe a
f)

-- | \(O(\min(n,W))\). Retrieves the maximal key of the map, and the map
-- stripped of that element, or 'Nothing' if passed an empty map.
maxView :: Word64Map a -> Maybe (a, Word64Map a)
maxView :: forall a. Word64Map a -> Maybe (a, Word64Map a)
maxView Word64Map a
t = (((Word64, a), Word64Map a) -> (a, Word64Map a))
-> Maybe ((Word64, a), Word64Map a) -> Maybe (a, Word64Map a)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\((Word64
_, a
x), Word64Map a
t') -> (a
x, Word64Map a
t')) (Word64Map a -> Maybe ((Word64, a), Word64Map a)
forall a. Word64Map a -> Maybe ((Word64, a), Word64Map a)
maxViewWithKey Word64Map a
t)

-- | \(O(\min(n,W))\). Retrieves the minimal key of the map, and the map
-- stripped of that element, or 'Nothing' if passed an empty map.
minView :: Word64Map a -> Maybe (a, Word64Map a)
minView :: forall a. Word64Map a -> Maybe (a, Word64Map a)
minView Word64Map a
t = (((Word64, a), Word64Map a) -> (a, Word64Map a))
-> Maybe ((Word64, a), Word64Map a) -> Maybe (a, Word64Map a)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\((Word64
_, a
x), Word64Map a
t') -> (a
x, Word64Map a
t')) (Word64Map a -> Maybe ((Word64, a), Word64Map a)
forall a. Word64Map a -> Maybe ((Word64, a), Word64Map a)
minViewWithKey Word64Map a
t)

-- | \(O(\min(n,W))\). Delete and find the maximal element.
-- This function throws an error if the map is empty. Use 'maxViewWithKey'
-- if the map may be empty.
deleteFindMax :: Word64Map a -> ((Key, a), Word64Map a)
deleteFindMax :: forall a. Word64Map a -> ((Word64, a), Word64Map a)
deleteFindMax = ((Word64, a), Word64Map a)
-> Maybe ((Word64, a), Word64Map a) -> ((Word64, a), Word64Map a)
forall a. a -> Maybe a -> a
fromMaybe ([Char] -> ((Word64, a), Word64Map a)
forall a. HasCallStack => [Char] -> a
error [Char]
"deleteFindMax: empty map has no maximal element") (Maybe ((Word64, a), Word64Map a) -> ((Word64, a), Word64Map a))
-> (Word64Map a -> Maybe ((Word64, a), Word64Map a))
-> Word64Map a
-> ((Word64, a), Word64Map a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64Map a -> Maybe ((Word64, a), Word64Map a)
forall a. Word64Map a -> Maybe ((Word64, a), Word64Map a)
maxViewWithKey

-- | \(O(\min(n,W))\). Delete and find the minimal element.
-- This function throws an error if the map is empty. Use 'minViewWithKey'
-- if the map may be empty.
deleteFindMin :: Word64Map a -> ((Key, a), Word64Map a)
deleteFindMin :: forall a. Word64Map a -> ((Word64, a), Word64Map a)
deleteFindMin = ((Word64, a), Word64Map a)
-> Maybe ((Word64, a), Word64Map a) -> ((Word64, a), Word64Map a)
forall a. a -> Maybe a -> a
fromMaybe ([Char] -> ((Word64, a), Word64Map a)
forall a. HasCallStack => [Char] -> a
error [Char]
"deleteFindMin: empty map has no minimal element") (Maybe ((Word64, a), Word64Map a) -> ((Word64, a), Word64Map a))
-> (Word64Map a -> Maybe ((Word64, a), Word64Map a))
-> Word64Map a
-> ((Word64, a), Word64Map a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64Map a -> Maybe ((Word64, a), Word64Map a)
forall a. Word64Map a -> Maybe ((Word64, a), Word64Map a)
minViewWithKey

-- | \(O(\min(n,W))\). The minimal key of the map. Returns 'Nothing' if the map is empty.
lookupMin :: Word64Map a -> Maybe (Key, a)
lookupMin :: forall a. Word64Map a -> Maybe (Word64, a)
lookupMin Word64Map a
Nil = Maybe (Word64, a)
forall a. Maybe a
Nothing
lookupMin (Tip Word64
k a
v) = (Word64, a) -> Maybe (Word64, a)
forall a. a -> Maybe a
Just (Word64
k,a
v)
lookupMin (Bin Word64
_ Word64
m Word64Map a
l Word64Map a
r)
  | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0     = Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
go Word64Map a
r
  | Bool
otherwise = Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
go Word64Map a
l
    where go :: Word64Map b -> Maybe (Word64, b)
go (Tip Word64
k b
v)      = (Word64, b) -> Maybe (Word64, b)
forall a. a -> Maybe a
Just (Word64
k,b
v)
          go (Bin Word64
_ Word64
_ Word64Map b
l' Word64Map b
_) = Word64Map b -> Maybe (Word64, b)
go Word64Map b
l'
          go Word64Map b
Nil            = Maybe (Word64, b)
forall a. Maybe a
Nothing

-- | \(O(\min(n,W))\). The minimal key of the map. Calls 'error' if the map is empty.
-- Use 'minViewWithKey' if the map may be empty.
findMin :: Word64Map a -> (Key, a)
findMin :: forall a. Word64Map a -> (Word64, a)
findMin Word64Map a
t
  | Just (Word64, a)
r <- Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
lookupMin Word64Map a
t = (Word64, a)
r
  | Bool
otherwise = [Char] -> (Word64, a)
forall a. HasCallStack => [Char] -> a
error [Char]
"findMin: empty map has no minimal element"

-- | \(O(\min(n,W))\). The maximal key of the map. Returns 'Nothing' if the map is empty.
lookupMax :: Word64Map a -> Maybe (Key, a)
lookupMax :: forall a. Word64Map a -> Maybe (Word64, a)
lookupMax Word64Map a
Nil = Maybe (Word64, a)
forall a. Maybe a
Nothing
lookupMax (Tip Word64
k a
v) = (Word64, a) -> Maybe (Word64, a)
forall a. a -> Maybe a
Just (Word64
k,a
v)
lookupMax (Bin Word64
_ Word64
m Word64Map a
l Word64Map a
r)
  | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0     = Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
go Word64Map a
l
  | Bool
otherwise = Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
go Word64Map a
r
    where go :: Word64Map b -> Maybe (Word64, b)
go (Tip Word64
k b
v)      = (Word64, b) -> Maybe (Word64, b)
forall a. a -> Maybe a
Just (Word64
k,b
v)
          go (Bin Word64
_ Word64
_ Word64Map b
_ Word64Map b
r') = Word64Map b -> Maybe (Word64, b)
go Word64Map b
r'
          go Word64Map b
Nil            = Maybe (Word64, b)
forall a. Maybe a
Nothing

-- | \(O(\min(n,W))\). The maximal key of the map. Calls 'error' if the map is empty.
-- Use 'maxViewWithKey' if the map may be empty.
findMax :: Word64Map a -> (Key, a)
findMax :: forall a. Word64Map a -> (Word64, a)
findMax Word64Map a
t
  | Just (Word64, a)
r <- Word64Map a -> Maybe (Word64, a)
forall a. Word64Map a -> Maybe (Word64, a)
lookupMax Word64Map a
t = (Word64, a)
r
  | Bool
otherwise = [Char] -> (Word64, a)
forall a. HasCallStack => [Char] -> a
error [Char]
"findMax: empty map has no maximal element"

-- | \(O(\min(n,W))\). Delete the minimal key. Returns an empty map if the map is empty.
--
-- Note that this is a change of behaviour for consistency with 'Data.Map.Map' &#8211;
-- versions prior to 0.5 threw an error if the 'Word64Map' was already empty.
deleteMin :: Word64Map a -> Word64Map a
deleteMin :: forall a. Word64Map a -> Word64Map a
deleteMin = Word64Map a
-> ((a, Word64Map a) -> Word64Map a)
-> Maybe (a, Word64Map a)
-> Word64Map a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Word64Map a
forall a. Word64Map a
Nil (a, Word64Map a) -> Word64Map a
forall a b. (a, b) -> b
snd (Maybe (a, Word64Map a) -> Word64Map a)
-> (Word64Map a -> Maybe (a, Word64Map a))
-> Word64Map a
-> Word64Map a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64Map a -> Maybe (a, Word64Map a)
forall a. Word64Map a -> Maybe (a, Word64Map a)
minView

-- | \(O(\min(n,W))\). Delete the maximal key. Returns an empty map if the map is empty.
--
-- Note that this is a change of behaviour for consistency with 'Data.Map.Map' &#8211;
-- versions prior to 0.5 threw an error if the 'Word64Map' was already empty.
deleteMax :: Word64Map a -> Word64Map a
deleteMax :: forall a. Word64Map a -> Word64Map a
deleteMax = Word64Map a
-> ((a, Word64Map a) -> Word64Map a)
-> Maybe (a, Word64Map a)
-> Word64Map a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Word64Map a
forall a. Word64Map a
Nil (a, Word64Map a) -> Word64Map a
forall a b. (a, b) -> b
snd (Maybe (a, Word64Map a) -> Word64Map a)
-> (Word64Map a -> Maybe (a, Word64Map a))
-> Word64Map a
-> Word64Map a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64Map a -> Maybe (a, Word64Map a)
forall a. Word64Map a -> Maybe (a, Word64Map a)
maxView


{--------------------------------------------------------------------
  Submap
--------------------------------------------------------------------}
-- | \(O(n+m)\). Is this a proper submap? (ie. a submap but not equal).
-- Defined as (@'isProperSubmapOf' = 'isProperSubmapOfBy' (==)@).
isProperSubmapOf :: Eq a => Word64Map a -> Word64Map a -> Bool
isProperSubmapOf :: forall a. Eq a => Word64Map a -> Word64Map a -> Bool
isProperSubmapOf Word64Map a
m1 Word64Map a
m2
  = (a -> a -> Bool) -> Word64Map a -> Word64Map a -> Bool
forall a b. (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
isProperSubmapOfBy a -> a -> Bool
forall a. Eq a => a -> a -> Bool
(==) Word64Map a
m1 Word64Map a
m2

{- | \(O(n+m)\). Is this a proper submap? (ie. a submap but not equal).
 The expression (@'isProperSubmapOfBy' f m1 m2@) returns 'True' when
 @keys m1@ and @keys m2@ are not equal,
 all keys in @m1@ are in @m2@, and when @f@ returns 'True' when
 applied to their respective values. For example, the following
 expressions are all 'True':

  > isProperSubmapOfBy (==) (fromList [(1,1)]) (fromList [(1,1),(2,2)])
  > isProperSubmapOfBy (<=) (fromList [(1,1)]) (fromList [(1,1),(2,2)])

 But the following are all 'False':

  > isProperSubmapOfBy (==) (fromList [(1,1),(2,2)]) (fromList [(1,1),(2,2)])
  > isProperSubmapOfBy (==) (fromList [(1,1),(2,2)]) (fromList [(1,1)])
  > isProperSubmapOfBy (<)  (fromList [(1,1)])       (fromList [(1,1),(2,2)])
-}
isProperSubmapOfBy :: (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
isProperSubmapOfBy :: forall a b. (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
isProperSubmapOfBy a -> b -> Bool
predicate Word64Map a
t1 Word64Map b
t2
  = case (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Ordering
forall a b.
(a -> b -> Bool) -> Word64Map a -> Word64Map b -> Ordering
submapCmp a -> b -> Bool
predicate Word64Map a
t1 Word64Map b
t2 of
      Ordering
LT -> Bool
True
      Ordering
_  -> Bool
False

submapCmp :: (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Ordering
submapCmp :: forall a b.
(a -> b -> Bool) -> Word64Map a -> Word64Map b -> Ordering
submapCmp a -> b -> Bool
predicate t1 :: Word64Map a
t1@(Bin Word64
p1 Word64
m1 Word64Map a
l1 Word64Map a
r1) (Bin Word64
p2 Word64
m2 Word64Map b
l2 Word64Map b
r2)
  | Word64 -> Word64 -> Bool
shorter Word64
m1 Word64
m2  = Ordering
GT
  | Word64 -> Word64 -> Bool
shorter Word64
m2 Word64
m1  = Ordering
submapCmpLt
  | Word64
p1 Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
p2       = Ordering
submapCmpEq
  | Bool
otherwise      = Ordering
GT  -- disjoint
  where
    submapCmpLt :: Ordering
submapCmpLt | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
p1 Word64
p2 Word64
m2  = Ordering
GT
                | Word64 -> Word64 -> Bool
zero Word64
p1 Word64
m2        = (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Ordering
forall a b.
(a -> b -> Bool) -> Word64Map a -> Word64Map b -> Ordering
submapCmp a -> b -> Bool
predicate Word64Map a
t1 Word64Map b
l2
                | Bool
otherwise         = (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Ordering
forall a b.
(a -> b -> Bool) -> Word64Map a -> Word64Map b -> Ordering
submapCmp a -> b -> Bool
predicate Word64Map a
t1 Word64Map b
r2
    submapCmpEq :: Ordering
submapCmpEq = case ((a -> b -> Bool) -> Word64Map a -> Word64Map b -> Ordering
forall a b.
(a -> b -> Bool) -> Word64Map a -> Word64Map b -> Ordering
submapCmp a -> b -> Bool
predicate Word64Map a
l1 Word64Map b
l2, (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Ordering
forall a b.
(a -> b -> Bool) -> Word64Map a -> Word64Map b -> Ordering
submapCmp a -> b -> Bool
predicate Word64Map a
r1 Word64Map b
r2) of
                    (Ordering
GT,Ordering
_ ) -> Ordering
GT
                    (Ordering
_ ,Ordering
GT) -> Ordering
GT
                    (Ordering
EQ,Ordering
EQ) -> Ordering
EQ
                    (Ordering, Ordering)
_       -> Ordering
LT

submapCmp a -> b -> Bool
_         (Bin Word64
_ Word64
_ Word64Map a
_ Word64Map a
_) Word64Map b
_  = Ordering
GT
submapCmp a -> b -> Bool
predicate (Tip Word64
kx a
x) (Tip Word64
ky b
y)
  | (Word64
kx Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
ky) Bool -> Bool -> Bool
&& a -> b -> Bool
predicate a
x b
y = Ordering
EQ
  | Bool
otherwise                   = Ordering
GT  -- disjoint
submapCmp a -> b -> Bool
predicate (Tip Word64
k a
x) Word64Map b
t
  = case Word64 -> Word64Map b -> Maybe b
forall a. Word64 -> Word64Map a -> Maybe a
lookup Word64
k Word64Map b
t of
     Just b
y | a -> b -> Bool
predicate a
x b
y -> Ordering
LT
     Maybe b
_                      -> Ordering
GT -- disjoint
submapCmp a -> b -> Bool
_    Word64Map a
Nil Word64Map b
Nil = Ordering
EQ
submapCmp a -> b -> Bool
_    Word64Map a
Nil Word64Map b
_   = Ordering
LT

-- | \(O(n+m)\). Is this a submap?
-- Defined as (@'isSubmapOf' = 'isSubmapOfBy' (==)@).
isSubmapOf :: Eq a => Word64Map a -> Word64Map a -> Bool
isSubmapOf :: forall a. Eq a => Word64Map a -> Word64Map a -> Bool
isSubmapOf Word64Map a
m1 Word64Map a
m2
  = (a -> a -> Bool) -> Word64Map a -> Word64Map a -> Bool
forall a b. (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
isSubmapOfBy a -> a -> Bool
forall a. Eq a => a -> a -> Bool
(==) Word64Map a
m1 Word64Map a
m2

{- | \(O(n+m)\).
 The expression (@'isSubmapOfBy' f m1 m2@) returns 'True' if
 all keys in @m1@ are in @m2@, and when @f@ returns 'True' when
 applied to their respective values. For example, the following
 expressions are all 'True':

  > isSubmapOfBy (==) (fromList [(1,1)]) (fromList [(1,1),(2,2)])
  > isSubmapOfBy (<=) (fromList [(1,1)]) (fromList [(1,1),(2,2)])
  > isSubmapOfBy (==) (fromList [(1,1),(2,2)]) (fromList [(1,1),(2,2)])

 But the following are all 'False':

  > isSubmapOfBy (==) (fromList [(1,2)]) (fromList [(1,1),(2,2)])
  > isSubmapOfBy (<) (fromList [(1,1)]) (fromList [(1,1),(2,2)])
  > isSubmapOfBy (==) (fromList [(1,1),(2,2)]) (fromList [(1,1)])
-}
isSubmapOfBy :: (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
isSubmapOfBy :: forall a b. (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
isSubmapOfBy a -> b -> Bool
predicate t1 :: Word64Map a
t1@(Bin Word64
p1 Word64
m1 Word64Map a
l1 Word64Map a
r1) (Bin Word64
p2 Word64
m2 Word64Map b
l2 Word64Map b
r2)
  | Word64 -> Word64 -> Bool
shorter Word64
m1 Word64
m2  = Bool
False
  | Word64 -> Word64 -> Bool
shorter Word64
m2 Word64
m1  = Word64 -> Word64 -> Word64 -> Bool
match Word64
p1 Word64
p2 Word64
m2 Bool -> Bool -> Bool
&&
                       if Word64 -> Word64 -> Bool
zero Word64
p1 Word64
m2
                       then (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
forall a b. (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
isSubmapOfBy a -> b -> Bool
predicate Word64Map a
t1 Word64Map b
l2
                       else (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
forall a b. (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
isSubmapOfBy a -> b -> Bool
predicate Word64Map a
t1 Word64Map b
r2
  | Bool
otherwise      = (Word64
p1Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
==Word64
p2) Bool -> Bool -> Bool
&& (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
forall a b. (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
isSubmapOfBy a -> b -> Bool
predicate Word64Map a
l1 Word64Map b
l2 Bool -> Bool -> Bool
&& (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
forall a b. (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
isSubmapOfBy a -> b -> Bool
predicate Word64Map a
r1 Word64Map b
r2
isSubmapOfBy a -> b -> Bool
_         (Bin Word64
_ Word64
_ Word64Map a
_ Word64Map a
_) Word64Map b
_ = Bool
False
isSubmapOfBy a -> b -> Bool
predicate (Tip Word64
k a
x) Word64Map b
t     = case Word64 -> Word64Map b -> Maybe b
forall a. Word64 -> Word64Map a -> Maybe a
lookup Word64
k Word64Map b
t of
                                         Just b
y  -> a -> b -> Bool
predicate a
x b
y
                                         Maybe b
Nothing -> Bool
False
isSubmapOfBy a -> b -> Bool
_         Word64Map a
Nil Word64Map b
_           = Bool
True

{--------------------------------------------------------------------
  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) -> Word64Map a -> Word64Map b
map :: forall a b. (a -> b) -> Word64Map a -> Word64Map b
map a -> b
f = Word64Map a -> Word64Map b
go
  where
    go :: Word64Map a -> Word64Map b
go (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r) = Word64 -> Word64 -> Word64Map b -> Word64Map b -> Word64Map b
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m (Word64Map a -> Word64Map b
go Word64Map a
l) (Word64Map a -> Word64Map b
go Word64Map a
r)
    go (Tip Word64
k a
x)     = Word64 -> b -> Word64Map b
forall a. Word64 -> a -> Word64Map a
Tip Word64
k (a -> b
f a
x)
    go Word64Map a
Nil           = Word64Map b
forall a. Word64Map a
Nil

#ifdef __GLASGOW_HASKELL__
{-# NOINLINE [1] map #-}
{-# RULES
"map/map" forall f g xs . map f (map g xs) = map (f . g) xs
"map/coerce" map coerce = coerce
 #-}
#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) -> Word64Map a -> Word64Map b
mapWithKey :: forall a b. (Word64 -> a -> b) -> Word64Map a -> Word64Map b
mapWithKey Word64 -> a -> b
f Word64Map a
t
  = case Word64Map a
t of
      Bin Word64
p Word64
m Word64Map a
l Word64Map a
r -> Word64 -> Word64 -> Word64Map b -> Word64Map b -> Word64Map b
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m ((Word64 -> a -> b) -> Word64Map a -> Word64Map b
forall a b. (Word64 -> a -> b) -> Word64Map a -> Word64Map b
mapWithKey Word64 -> a -> b
f Word64Map a
l) ((Word64 -> a -> b) -> Word64Map a -> Word64Map b
forall a b. (Word64 -> a -> b) -> Word64Map a -> Word64Map b
mapWithKey Word64 -> a -> b
f Word64Map a
r)
      Tip Word64
k a
x     -> Word64 -> b -> Word64Map b
forall a. Word64 -> a -> Word64Map a
Tip Word64
k (Word64 -> a -> b
f Word64
k a
x)
      Word64Map a
Nil         -> Word64Map b
forall a. Word64Map a
Nil

#ifdef __GLASGOW_HASKELL__
{-# 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/map" forall f g xs . mapWithKey f (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
 #-}
#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) -> Word64Map a -> t (Word64Map b)
traverseWithKey :: forall (t :: * -> *) a b.
Applicative t =>
(Word64 -> a -> t b) -> Word64Map a -> t (Word64Map b)
traverseWithKey Word64 -> a -> t b
f = Word64Map a -> t (Word64Map b)
go
  where
    go :: Word64Map a -> t (Word64Map b)
go Word64Map a
Nil = Word64Map b -> t (Word64Map b)
forall a. a -> t a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word64Map b
forall a. Word64Map a
Nil
    go (Tip Word64
k a
v) = Word64 -> b -> Word64Map b
forall a. Word64 -> a -> Word64Map a
Tip Word64
k (b -> Word64Map b) -> t b -> t (Word64Map b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word64 -> a -> t b
f Word64
k a
v
    go (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
      | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0     = (Word64Map b -> Word64Map b -> Word64Map b)
-> t (Word64Map b) -> t (Word64Map b) -> t (Word64Map 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 ((Word64Map b -> Word64Map b -> Word64Map b)
-> Word64Map b -> Word64Map b -> Word64Map b
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Word64 -> Word64 -> Word64Map b -> Word64Map b -> Word64Map b
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m)) (Word64Map a -> t (Word64Map b)
go Word64Map a
r) (Word64Map a -> t (Word64Map b)
go Word64Map a
l)
      | Bool
otherwise = (Word64Map b -> Word64Map b -> Word64Map b)
-> t (Word64Map b) -> t (Word64Map b) -> t (Word64Map 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 (Word64 -> Word64 -> Word64Map b -> Word64Map b -> Word64Map b
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m) (Word64Map a -> t (Word64Map b)
go Word64Map a
l) (Word64Map a -> t (Word64Map b)
go Word64Map a
r)
{-# INLINE traverseWithKey #-}

-- | \(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 -> Word64Map b -> (a,Word64Map c)
mapAccum :: forall a b c.
(a -> b -> (a, c)) -> a -> Word64Map b -> (a, Word64Map c)
mapAccum a -> b -> (a, c)
f = (a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
forall a b c.
(a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
mapAccumWithKey (\a
a' Word64
_ 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 -> Word64Map b -> (a,Word64Map c)
mapAccumWithKey :: forall a b c.
(a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
mapAccumWithKey a -> Word64 -> b -> (a, c)
f a
a Word64Map b
t
  = (a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
forall a b c.
(a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
mapAccumL a -> Word64 -> b -> (a, c)
f a
a Word64Map b
t

-- | \(O(n)\). The function @'mapAccumL'@ threads an accumulating
-- argument through the map in ascending order of keys.
mapAccumL :: (a -> Key -> b -> (a,c)) -> a -> Word64Map b -> (a,Word64Map c)
mapAccumL :: forall a b c.
(a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
mapAccumL a -> Word64 -> b -> (a, c)
f a
a Word64Map b
t
  = case Word64Map b
t of
      Bin Word64
p Word64
m Word64Map b
l Word64Map b
r
        | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 ->
            let (a
a1,Word64Map c
r') = (a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
forall a b c.
(a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
mapAccumL a -> Word64 -> b -> (a, c)
f a
a Word64Map b
r
                (a
a2,Word64Map c
l') = (a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
forall a b c.
(a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
mapAccumL a -> Word64 -> b -> (a, c)
f a
a1 Word64Map b
l
            in (a
a2,Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m Word64Map c
l' Word64Map c
r')
        | Bool
otherwise  ->
            let (a
a1,Word64Map c
l') = (a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
forall a b c.
(a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
mapAccumL a -> Word64 -> b -> (a, c)
f a
a Word64Map b
l
                (a
a2,Word64Map c
r') = (a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
forall a b c.
(a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
mapAccumL a -> Word64 -> b -> (a, c)
f a
a1 Word64Map b
r
            in (a
a2,Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m Word64Map c
l' Word64Map c
r')
      Tip Word64
k b
x     -> let (a
a',c
x') = a -> Word64 -> b -> (a, c)
f a
a Word64
k b
x in (a
a',Word64 -> c -> Word64Map c
forall a. Word64 -> a -> Word64Map a
Tip Word64
k c
x')
      Word64Map b
Nil         -> (a
a,Word64Map c
forall a. Word64Map 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 -> Word64Map b -> (a,Word64Map c)
mapAccumRWithKey :: forall a b c.
(a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
mapAccumRWithKey a -> Word64 -> b -> (a, c)
f a
a Word64Map b
t
  = case Word64Map b
t of
      Bin Word64
p Word64
m Word64Map b
l Word64Map b
r
        | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 ->
            let (a
a1,Word64Map c
l') = (a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
forall a b c.
(a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
mapAccumRWithKey a -> Word64 -> b -> (a, c)
f a
a Word64Map b
l
                (a
a2,Word64Map c
r') = (a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
forall a b c.
(a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
mapAccumRWithKey a -> Word64 -> b -> (a, c)
f a
a1 Word64Map b
r
            in (a
a2,Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m Word64Map c
l' Word64Map c
r')
        | Bool
otherwise  ->
            let (a
a1,Word64Map c
r') = (a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
forall a b c.
(a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
mapAccumRWithKey a -> Word64 -> b -> (a, c)
f a
a Word64Map b
r
                (a
a2,Word64Map c
l') = (a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
forall a b c.
(a -> Word64 -> b -> (a, c))
-> a -> Word64Map b -> (a, Word64Map c)
mapAccumRWithKey a -> Word64 -> b -> (a, c)
f a
a1 Word64Map b
l
            in (a
a2,Word64 -> Word64 -> Word64Map c -> Word64Map c -> Word64Map c
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m Word64Map c
l' Word64Map c
r')
      Tip Word64
k b
x     -> let (a
a',c
x') = a -> Word64 -> b -> (a, c)
f a
a Word64
k b
x in (a
a',Word64 -> c -> Word64Map c
forall a. Word64 -> a -> Word64Map a
Tip Word64
k c
x')
      Word64Map b
Nil         -> (a
a,Word64Map c
forall a. Word64Map a
Nil)

-- | \(O(n \min(n,W))\).
-- @'mapKeys' 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 value at the greatest of the
-- original keys is retained.
--
-- > mapKeys (+ 1) (fromList [(5,"a"), (3,"b")])                        == fromList [(4, "b"), (6, "a")]
-- > mapKeys (\ _ -> 1) (fromList [(1,"b"), (2,"a"), (3,"d"), (4,"c")]) == singleton 1 "c"
-- > mapKeys (\ _ -> 3) (fromList [(1,"b"), (2,"a"), (3,"d"), (4,"c")]) == singleton 3 "c"

mapKeys :: (Key->Key) -> Word64Map a -> Word64Map a
mapKeys :: forall a. (Word64 -> Word64) -> Word64Map a -> Word64Map a
mapKeys Word64 -> Word64
f = [(Word64, a)] -> Word64Map a
forall a. [(Word64, a)] -> Word64Map a
fromList ([(Word64, a)] -> Word64Map a)
-> (Word64Map a -> [(Word64, a)]) -> Word64Map a -> Word64Map a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word64 -> a -> [(Word64, a)] -> [(Word64, a)])
-> [(Word64, a)] -> Word64Map a -> [(Word64, a)]
forall a b. (Word64 -> a -> b -> b) -> b -> Word64Map a -> b
foldrWithKey (\Word64
k a
x [(Word64, a)]
xs -> (Word64 -> Word64
f Word64
k, a
x) (Word64, a) -> [(Word64, a)] -> [(Word64, a)]
forall a. a -> [a] -> [a]
: [(Word64, a)]
xs) []

-- | \(O(n \min(n,W))\).
-- @'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) -> Word64Map a -> Word64Map a
mapKeysWith :: forall a.
(a -> a -> a) -> (Word64 -> Word64) -> Word64Map a -> Word64Map a
mapKeysWith a -> a -> a
c Word64 -> Word64
f
  = (a -> a -> a) -> [(Word64, a)] -> Word64Map a
forall a. (a -> a -> a) -> [(Word64, a)] -> Word64Map a
fromListWith a -> a -> a
c ([(Word64, a)] -> Word64Map a)
-> (Word64Map a -> [(Word64, a)]) -> Word64Map a -> Word64Map a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word64 -> a -> [(Word64, a)] -> [(Word64, a)])
-> [(Word64, a)] -> Word64Map a -> [(Word64, a)]
forall a b. (Word64 -> a -> b -> b) -> b -> Word64Map a -> b
foldrWithKey (\Word64
k a
x [(Word64, a)]
xs -> (Word64 -> Word64
f Word64
k, a
x) (Word64, a) -> [(Word64, a)] -> [(Word64, a)]
forall a. a -> [a] -> [a]
: [(Word64, a)]
xs) []

-- | \(O(n \min(n,W))\).
-- @'mapKeysMonotonic' f s == 'mapKeys' f s@, but works only when @f@
-- is strictly monotonic.
-- That is, for any values @x@ and @y@, if @x@ < @y@ then @f x@ < @f y@.
-- /The precondition is not checked./
-- Semi-formally, we have:
--
-- > and [x < y ==> f x < f y | x <- ls, y <- ls]
-- >                     ==> mapKeysMonotonic f s == mapKeys f s
-- >     where ls = keys s
--
-- This means that @f@ maps distinct original keys to distinct resulting keys.
-- This function has slightly better performance than 'mapKeys'.
--
-- > mapKeysMonotonic (\ k -> k * 2) (fromList [(5,"a"), (3,"b")]) == fromList [(6, "b"), (10, "a")]

mapKeysMonotonic :: (Key->Key) -> Word64Map a -> Word64Map a
mapKeysMonotonic :: forall a. (Word64 -> Word64) -> Word64Map a -> Word64Map a
mapKeysMonotonic Word64 -> Word64
f
  = [(Word64, a)] -> Word64Map a
forall a. [(Word64, a)] -> Word64Map a
fromDistinctAscList ([(Word64, a)] -> Word64Map a)
-> (Word64Map a -> [(Word64, a)]) -> Word64Map a -> Word64Map a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word64 -> a -> [(Word64, a)] -> [(Word64, a)])
-> [(Word64, a)] -> Word64Map a -> [(Word64, a)]
forall a b. (Word64 -> a -> b -> b) -> b -> Word64Map a -> b
foldrWithKey (\Word64
k a
x [(Word64, a)]
xs -> (Word64 -> Word64
f Word64
k, a
x) (Word64, a) -> [(Word64, a)] -> [(Word64, a)]
forall a. a -> [a] -> [a]
: [(Word64, a)]
xs) []

{--------------------------------------------------------------------
  Filter
--------------------------------------------------------------------}
-- | \(O(n)\). Filter all values that satisfy some predicate.
--
-- > filter (> "a") (fromList [(5,"a"), (3,"b")]) == singleton 3 "b"
-- > filter (> "x") (fromList [(5,"a"), (3,"b")]) == empty
-- > filter (< "a") (fromList [(5,"a"), (3,"b")]) == empty

filter :: (a -> Bool) -> Word64Map a -> Word64Map a
filter :: forall a. (a -> Bool) -> Word64Map a -> Word64Map a
filter a -> Bool
p Word64Map a
m
  = (Word64 -> a -> Bool) -> Word64Map a -> Word64Map a
forall a. (Word64 -> a -> Bool) -> Word64Map a -> Word64Map a
filterWithKey (\Word64
_ a
x -> a -> Bool
p a
x) Word64Map a
m

-- | \(O(n)\). Filter all keys\/values that satisfy some predicate.
--
-- > filterWithKey (\k _ -> k > 4) (fromList [(5,"a"), (3,"b")]) == singleton 5 "a"

filterWithKey :: (Key -> a -> Bool) -> Word64Map a -> Word64Map a
filterWithKey :: forall a. (Word64 -> a -> Bool) -> Word64Map a -> Word64Map a
filterWithKey Word64 -> a -> Bool
predicate = Word64Map a -> Word64Map a
go
    where
    go :: Word64Map a -> Word64Map a
go Word64Map a
Nil           = Word64Map a
forall a. Word64Map a
Nil
    go t :: Word64Map a
t@(Tip Word64
k a
x)   = if Word64 -> a -> Bool
predicate Word64
k a
x then Word64Map a
t else Word64Map a
forall a. Word64Map a
Nil
    go (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r) = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m (Word64Map a -> Word64Map a
go Word64Map a
l) (Word64Map a -> Word64Map a
go Word64Map a
r)

-- | \(O(n)\). Partition the map according to some predicate. The first
-- map contains all elements that satisfy the predicate, the second all
-- elements that fail the predicate. See also 'split'.
--
-- > partition (> "a") (fromList [(5,"a"), (3,"b")]) == (singleton 3 "b", singleton 5 "a")
-- > partition (< "x") (fromList [(5,"a"), (3,"b")]) == (fromList [(3, "b"), (5, "a")], empty)
-- > partition (> "x") (fromList [(5,"a"), (3,"b")]) == (empty, fromList [(3, "b"), (5, "a")])

partition :: (a -> Bool) -> Word64Map a -> (Word64Map a,Word64Map a)
partition :: forall a. (a -> Bool) -> Word64Map a -> (Word64Map a, Word64Map a)
partition a -> Bool
p Word64Map a
m
  = (Word64 -> a -> Bool) -> Word64Map a -> (Word64Map a, Word64Map a)
forall a.
(Word64 -> a -> Bool) -> Word64Map a -> (Word64Map a, Word64Map a)
partitionWithKey (\Word64
_ a
x -> a -> Bool
p a
x) Word64Map a
m

-- | \(O(n)\). Partition the map according to some predicate. The first
-- map contains all elements that satisfy the predicate, the second all
-- elements that fail the predicate. See also 'split'.
--
-- > partitionWithKey (\ k _ -> k > 3) (fromList [(5,"a"), (3,"b")]) == (singleton 5 "a", singleton 3 "b")
-- > partitionWithKey (\ k _ -> k < 7) (fromList [(5,"a"), (3,"b")]) == (fromList [(3, "b"), (5, "a")], empty)
-- > partitionWithKey (\ k _ -> k > 7) (fromList [(5,"a"), (3,"b")]) == (empty, fromList [(3, "b"), (5, "a")])

partitionWithKey :: (Key -> a -> Bool) -> Word64Map a -> (Word64Map a,Word64Map a)
partitionWithKey :: forall a.
(Word64 -> a -> Bool) -> Word64Map a -> (Word64Map a, Word64Map a)
partitionWithKey Word64 -> a -> Bool
predicate0 Word64Map a
t0 = StrictPair (Word64Map a) (Word64Map a)
-> (Word64Map a, Word64Map a)
forall a b. StrictPair a b -> (a, b)
toPair (StrictPair (Word64Map a) (Word64Map a)
 -> (Word64Map a, Word64Map a))
-> StrictPair (Word64Map a) (Word64Map a)
-> (Word64Map a, Word64Map a)
forall a b. (a -> b) -> a -> b
$ (Word64 -> a -> Bool)
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall {a}.
(Word64 -> a -> Bool)
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
go Word64 -> a -> Bool
predicate0 Word64Map a
t0
  where
    go :: (Word64 -> a -> Bool)
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
go Word64 -> a -> Bool
predicate Word64Map a
t =
      case Word64Map a
t of
        Bin Word64
p Word64
m Word64Map a
l Word64Map a
r ->
          let (Word64Map a
l1 :*: Word64Map a
l2) = (Word64 -> a -> Bool)
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
go Word64 -> a -> Bool
predicate Word64Map a
l
              (Word64Map a
r1 :*: Word64Map a
r2) = (Word64 -> a -> Bool)
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
go Word64 -> a -> Bool
predicate Word64Map a
r
          in Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m Word64Map a
l1 Word64Map a
r1 Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m Word64Map a
l2 Word64Map a
r2
        Tip Word64
k a
x
          | Word64 -> a -> Bool
predicate Word64
k a
x -> (Word64Map a
t Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64Map a
forall a. Word64Map a
Nil)
          | Bool
otherwise     -> (Word64Map a
forall a. Word64Map a
Nil Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64Map a
t)
        Word64Map a
Nil -> (Word64Map a
forall a. Word64Map a
Nil Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64Map a
forall a. Word64Map a
Nil)

-- | \(O(\min(n,W))\). Take while a predicate on the keys holds.
-- The user is responsible for ensuring that for all @Int@s, @j \< k ==\> p j \>= p k@.
-- See note at 'spanAntitone'.
--
-- @
-- takeWhileAntitone p = 'fromDistinctAscList' . 'Data.List.takeWhile' (p . fst) . 'toList'
-- takeWhileAntitone p = 'filterWithKey' (\\k _ -> p k)
-- @
--
-- @since 0.6.7
takeWhileAntitone :: (Key -> Bool) -> Word64Map a -> Word64Map a
takeWhileAntitone :: forall a. (Word64 -> Bool) -> Word64Map a -> Word64Map a
takeWhileAntitone Word64 -> Bool
predicate Word64Map a
t =
  case Word64Map a
t of
    Bin Word64
p Word64
m Word64Map a
l Word64Map a
r
      | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 ->
        if Word64 -> Bool
predicate Word64
0 -- handle negative numbers.
        then Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m ((Word64 -> Bool) -> Word64Map a -> Word64Map a
forall a. (Word64 -> Bool) -> Word64Map a -> Word64Map a
go Word64 -> Bool
predicate Word64Map a
l) Word64Map a
r
        else (Word64 -> Bool) -> Word64Map a -> Word64Map a
forall a. (Word64 -> Bool) -> Word64Map a -> Word64Map a
go Word64 -> Bool
predicate Word64Map a
r
    Word64Map a
_ -> (Word64 -> Bool) -> Word64Map a -> Word64Map a
forall a. (Word64 -> Bool) -> Word64Map a -> Word64Map a
go Word64 -> Bool
predicate Word64Map a
t
  where
    go :: (Word64 -> Bool) -> Word64Map a -> Word64Map a
go Word64 -> Bool
predicate' (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
      | Word64 -> Bool
predicate' (Word64 -> Bool) -> Word64 -> Bool
forall a b. (a -> b) -> a -> b
$! Word64
pWord64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
+Word64
m = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m Word64Map a
l ((Word64 -> Bool) -> Word64Map a -> Word64Map a
go Word64 -> Bool
predicate' Word64Map a
r)
      | Bool
otherwise         = (Word64 -> Bool) -> Word64Map a -> Word64Map a
go Word64 -> Bool
predicate' Word64Map a
l
    go Word64 -> Bool
predicate' t' :: Word64Map a
t'@(Tip Word64
ky a
_)
      | Word64 -> Bool
predicate' Word64
ky = Word64Map a
t'
      | Bool
otherwise     = Word64Map a
forall a. Word64Map a
Nil
    go Word64 -> Bool
_ Word64Map a
Nil = Word64Map a
forall a. Word64Map a
Nil

-- | \(O(\min(n,W))\). Drop while a predicate on the keys holds.
-- The user is responsible for ensuring that for all @Int@s, @j \< k ==\> p j \>= p k@.
-- See note at 'spanAntitone'.
--
-- @
-- dropWhileAntitone p = 'fromDistinctAscList' . 'Data.List.dropWhile' (p . fst) . 'toList'
-- dropWhileAntitone p = 'filterWithKey' (\\k _ -> not (p k))
-- @
--
-- @since 0.6.7
dropWhileAntitone :: (Key -> Bool) -> Word64Map a -> Word64Map a
dropWhileAntitone :: forall a. (Word64 -> Bool) -> Word64Map a -> Word64Map a
dropWhileAntitone Word64 -> Bool
predicate Word64Map a
t =
  case Word64Map a
t of
    Bin Word64
p Word64
m Word64Map a
l Word64Map a
r
      | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 ->
        if Word64 -> Bool
predicate Word64
0 -- handle negative numbers.
        then (Word64 -> Bool) -> Word64Map a -> Word64Map a
forall a. (Word64 -> Bool) -> Word64Map a -> Word64Map a
go Word64 -> Bool
predicate Word64Map a
l
        else Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m Word64Map a
l ((Word64 -> Bool) -> Word64Map a -> Word64Map a
forall a. (Word64 -> Bool) -> Word64Map a -> Word64Map a
go Word64 -> Bool
predicate Word64Map a
r)
    Word64Map a
_ -> (Word64 -> Bool) -> Word64Map a -> Word64Map a
forall a. (Word64 -> Bool) -> Word64Map a -> Word64Map a
go Word64 -> Bool
predicate Word64Map a
t
  where
    go :: (Word64 -> Bool) -> Word64Map a -> Word64Map a
go Word64 -> Bool
predicate' (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
      | Word64 -> Bool
predicate' (Word64 -> Bool) -> Word64 -> Bool
forall a b. (a -> b) -> a -> b
$! Word64
pWord64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
+Word64
m = (Word64 -> Bool) -> Word64Map a -> Word64Map a
go Word64 -> Bool
predicate' Word64Map a
r
      | Bool
otherwise         = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m ((Word64 -> Bool) -> Word64Map a -> Word64Map a
go Word64 -> Bool
predicate' Word64Map a
l) Word64Map a
r
    go Word64 -> Bool
predicate' t' :: Word64Map a
t'@(Tip Word64
ky a
_)
      | Word64 -> Bool
predicate' Word64
ky = Word64Map a
forall a. Word64Map a
Nil
      | Bool
otherwise     = Word64Map a
t'
    go Word64 -> Bool
_ Word64Map a
Nil = Word64Map a
forall a. Word64Map a
Nil

-- | \(O(\min(n,W))\). Divide a map at the point where a predicate on the keys stops holding.
-- The user is responsible for ensuring that for all @Int@s, @j \< k ==\> p j \>= p k@.
--
-- @
-- spanAntitone p xs = ('takeWhileAntitone' p xs, 'dropWhileAntitone' p xs)
-- spanAntitone p xs = 'partitionWithKey' (\\k _ -> p k) xs
-- @
--
-- Note: if @p@ is not actually antitone, then @spanAntitone@ will split the map
-- at some /unspecified/ point.
--
-- @since 0.6.7
spanAntitone :: (Key -> Bool) -> Word64Map a -> (Word64Map a, Word64Map a)
spanAntitone :: forall a.
(Word64 -> Bool) -> Word64Map a -> (Word64Map a, Word64Map a)
spanAntitone Word64 -> Bool
predicate Word64Map a
t =
  case Word64Map a
t of
    Bin Word64
p Word64
m Word64Map a
l Word64Map a
r
      | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 ->
        if Word64 -> Bool
predicate Word64
0 -- handle negative numbers.
        then
          case (Word64 -> Bool)
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall {a}.
(Word64 -> Bool)
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
go Word64 -> Bool
predicate Word64Map a
l of
            (Word64Map a
lt :*: Word64Map a
gt) ->
              let !lt' :: Word64Map a
lt' = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m Word64Map a
lt Word64Map a
r
              in (Word64Map a
lt', Word64Map a
gt)
        else
          case (Word64 -> Bool)
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall {a}.
(Word64 -> Bool)
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
go Word64 -> Bool
predicate Word64Map a
r of
            (Word64Map a
lt :*: Word64Map a
gt) ->
              let !gt' :: Word64Map a
gt' = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m Word64Map a
l Word64Map a
gt
              in (Word64Map a
lt, Word64Map a
gt')
    Word64Map a
_ -> case (Word64 -> Bool)
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall {a}.
(Word64 -> Bool)
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
go Word64 -> Bool
predicate Word64Map a
t of
          (Word64Map a
lt :*: Word64Map a
gt) -> (Word64Map a
lt, Word64Map a
gt)
  where
    go :: (Word64 -> Bool)
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
go Word64 -> Bool
predicate' (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
      | Word64 -> Bool
predicate' (Word64 -> Bool) -> Word64 -> Bool
forall a b. (a -> b) -> a -> b
$! Word64
pWord64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
+Word64
m = case (Word64 -> Bool)
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
go Word64 -> Bool
predicate' Word64Map a
r of (Word64Map a
lt :*: Word64Map a
gt) -> Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m Word64Map a
l Word64Map a
lt Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64Map a
gt
      | Bool
otherwise         = case (Word64 -> Bool)
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
go Word64 -> Bool
predicate' Word64Map a
l of (Word64Map a
lt :*: Word64Map a
gt) -> Word64Map a
lt Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m Word64Map a
gt Word64Map a
r
    go Word64 -> Bool
predicate' t' :: Word64Map a
t'@(Tip Word64
ky a
_)
      | Word64 -> Bool
predicate' Word64
ky = (Word64Map a
t' Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64Map a
forall a. Word64Map a
Nil)
      | Bool
otherwise     = (Word64Map a
forall a. Word64Map a
Nil Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64Map a
t')
    go Word64 -> Bool
_ Word64Map a
Nil = (Word64Map a
forall a. Word64Map a
Nil Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64Map a
forall a. Word64Map a
Nil)

-- | \(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) -> Word64Map a -> Word64Map b
mapMaybe :: forall a b. (a -> Maybe b) -> Word64Map a -> Word64Map b
mapMaybe a -> Maybe b
f = (Word64 -> a -> Maybe b) -> Word64Map a -> Word64Map b
forall a b. (Word64 -> a -> Maybe b) -> Word64Map a -> Word64Map b
mapMaybeWithKey (\Word64
_ 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) -> Word64Map a -> Word64Map b
mapMaybeWithKey :: forall a b. (Word64 -> a -> Maybe b) -> Word64Map a -> Word64Map b
mapMaybeWithKey Word64 -> a -> Maybe b
f (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
  = Word64 -> Word64 -> Word64Map b -> Word64Map b -> Word64Map b
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m ((Word64 -> a -> Maybe b) -> Word64Map a -> Word64Map b
forall a b. (Word64 -> a -> Maybe b) -> Word64Map a -> Word64Map b
mapMaybeWithKey Word64 -> a -> Maybe b
f Word64Map a
l) ((Word64 -> a -> Maybe b) -> Word64Map a -> Word64Map b
forall a b. (Word64 -> a -> Maybe b) -> Word64Map a -> Word64Map b
mapMaybeWithKey Word64 -> a -> Maybe b
f Word64Map a
r)
mapMaybeWithKey Word64 -> a -> Maybe b
f (Tip Word64
k a
x) = case Word64 -> a -> Maybe b
f Word64
k a
x of
  Just b
y  -> Word64 -> b -> Word64Map b
forall a. Word64 -> a -> Word64Map a
Tip Word64
k b
y
  Maybe b
Nothing -> Word64Map b
forall a. Word64Map a
Nil
mapMaybeWithKey Word64 -> a -> Maybe b
_ Word64Map a
Nil = Word64Map b
forall a. Word64Map 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) -> Word64Map a -> (Word64Map b, Word64Map c)
mapEither :: forall a b c.
(a -> Either b c) -> Word64Map a -> (Word64Map b, Word64Map c)
mapEither a -> Either b c
f Word64Map a
m
  = (Word64 -> a -> Either b c)
-> Word64Map a -> (Word64Map b, Word64Map c)
forall a b c.
(Word64 -> a -> Either b c)
-> Word64Map a -> (Word64Map b, Word64Map c)
mapEitherWithKey (\Word64
_ a
x -> a -> Either b c
f a
x) Word64Map 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) -> Word64Map a -> (Word64Map b, Word64Map c)
mapEitherWithKey :: forall a b c.
(Word64 -> a -> Either b c)
-> Word64Map a -> (Word64Map b, Word64Map c)
mapEitherWithKey Word64 -> a -> Either b c
f0 Word64Map a
t0 = StrictPair (Word64Map b) (Word64Map c)
-> (Word64Map b, Word64Map c)
forall a b. StrictPair a b -> (a, b)
toPair (StrictPair (Word64Map b) (Word64Map c)
 -> (Word64Map b, Word64Map c))
-> StrictPair (Word64Map b) (Word64Map c)
-> (Word64Map b, Word64Map c)
forall a b. (a -> b) -> a -> b
$ (Word64 -> a -> Either b c)
-> Word64Map a -> StrictPair (Word64Map b) (Word64Map c)
forall {t} {a} {a}.
(Word64 -> t -> Either a a)
-> Word64Map t -> StrictPair (Word64Map a) (Word64Map a)
go Word64 -> a -> Either b c
f0 Word64Map a
t0
  where
    go :: (Word64 -> t -> Either a a)
-> Word64Map t -> StrictPair (Word64Map a) (Word64Map a)
go Word64 -> t -> Either a a
f (Bin Word64
p Word64
m Word64Map t
l Word64Map t
r) =
      Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m Word64Map a
l1 Word64Map a
r1 Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m Word64Map a
l2 Word64Map a
r2
      where
        (Word64Map a
l1 :*: Word64Map a
l2) = (Word64 -> t -> Either a a)
-> Word64Map t -> StrictPair (Word64Map a) (Word64Map a)
go Word64 -> t -> Either a a
f Word64Map t
l
        (Word64Map a
r1 :*: Word64Map a
r2) = (Word64 -> t -> Either a a)
-> Word64Map t -> StrictPair (Word64Map a) (Word64Map a)
go Word64 -> t -> Either a a
f Word64Map t
r
    go Word64 -> t -> Either a a
f (Tip Word64
k t
x) = case Word64 -> t -> Either a a
f Word64
k t
x of
      Left a
y  -> (Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k a
y Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64Map a
forall a. Word64Map a
Nil)
      Right a
z -> (Word64Map a
forall a. Word64Map a
Nil Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k a
z)
    go Word64 -> t -> Either a a
_ Word64Map t
Nil = (Word64Map a
forall a. Word64Map a
Nil Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64Map a
forall a. Word64Map a
Nil)

-- | \(O(\min(n,W))\). The expression (@'split' k map@) is a pair @(map1,map2)@
-- where all keys in @map1@ are lower than @k@ and all keys in
-- @map2@ larger than @k@. Any key equal to @k@ is found in neither @map1@ nor @map2@.
--
-- > split 2 (fromList [(5,"a"), (3,"b")]) == (empty, fromList [(3,"b"), (5,"a")])
-- > split 3 (fromList [(5,"a"), (3,"b")]) == (empty, singleton 5 "a")
-- > split 4 (fromList [(5,"a"), (3,"b")]) == (singleton 3 "b", singleton 5 "a")
-- > split 5 (fromList [(5,"a"), (3,"b")]) == (singleton 3 "b", empty)
-- > split 6 (fromList [(5,"a"), (3,"b")]) == (fromList [(3,"b"), (5,"a")], empty)

split :: Key -> Word64Map a -> (Word64Map a, Word64Map a)
split :: forall a. Word64 -> Word64Map a -> (Word64Map a, Word64Map a)
split Word64
k Word64Map a
t =
  case Word64Map a
t of
    Bin Word64
p Word64
m Word64Map a
l Word64Map a
r
      | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 ->
        if Word64
k Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
>= Word64
0 -- handle negative numbers.
        then
          case Word64 -> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall {a}.
Word64 -> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
go Word64
k Word64Map a
l of
            (Word64Map a
lt :*: Word64Map a
gt) ->
              let !lt' :: Word64Map a
lt' = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m Word64Map a
lt Word64Map a
r
              in (Word64Map a
lt', Word64Map a
gt)
        else
          case Word64 -> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall {a}.
Word64 -> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
go Word64
k Word64Map a
r of
            (Word64Map a
lt :*: Word64Map a
gt) ->
              let !gt' :: Word64Map a
gt' = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m Word64Map a
l Word64Map a
gt
              in (Word64Map a
lt, Word64Map a
gt')
    Word64Map a
_ -> case Word64 -> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall {a}.
Word64 -> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
go Word64
k Word64Map a
t of
          (Word64Map a
lt :*: Word64Map a
gt) -> (Word64Map a
lt, Word64Map a
gt)
  where
    go :: Word64 -> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
go Word64
k' t' :: Word64Map a
t'@(Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
      | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
k' Word64
p Word64
m = if Word64
k' Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
> Word64
p then Word64Map a
t' Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64Map a
forall a. Word64Map a
Nil else Word64Map a
forall a. Word64Map a
Nil Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64Map a
t'
      | Word64 -> Word64 -> Bool
zero Word64
k' Word64
m = case Word64 -> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
go Word64
k' Word64Map a
l of (Word64Map a
lt :*: Word64Map a
gt) -> Word64Map a
lt Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m Word64Map a
gt Word64Map a
r
      | Bool
otherwise = case Word64 -> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
go Word64
k' Word64Map a
r of (Word64Map a
lt :*: Word64Map a
gt) -> Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m Word64Map a
l Word64Map a
lt Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64Map a
gt
    go Word64
k' t' :: Word64Map a
t'@(Tip Word64
ky a
_)
      | Word64
k' Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
> Word64
ky   = (Word64Map a
t' Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64Map a
forall a. Word64Map a
Nil)
      | Word64
k' Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
ky   = (Word64Map a
forall a. Word64Map a
Nil Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64Map a
t')
      | Bool
otherwise = (Word64Map a
forall a. Word64Map a
Nil Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64Map a
forall a. Word64Map a
Nil)
    go Word64
_ Word64Map a
Nil = (Word64Map a
forall a. Word64Map a
Nil Word64Map a
-> Word64Map a -> StrictPair (Word64Map a) (Word64Map a)
forall a b. a -> b -> StrictPair a b
:*: Word64Map a
forall a. Word64Map a
Nil)


data SplitLookup a = SplitLookup !(Word64Map a) !(Maybe a) !(Word64Map a)

mapLT :: (Word64Map a -> Word64Map a) -> SplitLookup a -> SplitLookup a
mapLT :: forall a.
(Word64Map a -> Word64Map a) -> SplitLookup a -> SplitLookup a
mapLT Word64Map a -> Word64Map a
f (SplitLookup Word64Map a
lt Maybe a
fnd Word64Map a
gt) = Word64Map a -> Maybe a -> Word64Map a -> SplitLookup a
forall a. Word64Map a -> Maybe a -> Word64Map a -> SplitLookup a
SplitLookup (Word64Map a -> Word64Map a
f Word64Map a
lt) Maybe a
fnd Word64Map a
gt
{-# INLINE mapLT #-}

mapGT :: (Word64Map a -> Word64Map a) -> SplitLookup a -> SplitLookup a
mapGT :: forall a.
(Word64Map a -> Word64Map a) -> SplitLookup a -> SplitLookup a
mapGT Word64Map a -> Word64Map a
f (SplitLookup Word64Map a
lt Maybe a
fnd Word64Map a
gt) = Word64Map a -> Maybe a -> Word64Map a -> SplitLookup a
forall a. Word64Map a -> Maybe a -> Word64Map a -> SplitLookup a
SplitLookup Word64Map a
lt Maybe a
fnd (Word64Map a -> Word64Map a
f Word64Map a
gt)
{-# INLINE mapGT #-}

-- | \(O(\min(n,W))\). Performs a 'split' but also returns whether the pivot
-- key was found in the original map.
--
-- > splitLookup 2 (fromList [(5,"a"), (3,"b")]) == (empty, Nothing, fromList [(3,"b"), (5,"a")])
-- > splitLookup 3 (fromList [(5,"a"), (3,"b")]) == (empty, Just "b", singleton 5 "a")
-- > splitLookup 4 (fromList [(5,"a"), (3,"b")]) == (singleton 3 "b", Nothing, singleton 5 "a")
-- > splitLookup 5 (fromList [(5,"a"), (3,"b")]) == (singleton 3 "b", Just "a", empty)
-- > splitLookup 6 (fromList [(5,"a"), (3,"b")]) == (fromList [(3,"b"), (5,"a")], Nothing, empty)

splitLookup :: Key -> Word64Map a -> (Word64Map a, Maybe a, Word64Map a)
splitLookup :: forall a.
Word64 -> Word64Map a -> (Word64Map a, Maybe a, Word64Map a)
splitLookup Word64
k Word64Map a
t =
  case
    case Word64Map a
t of
      Bin Word64
p Word64
m Word64Map a
l Word64Map a
r
        | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 ->
          if Word64
k Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
>= Word64
0 -- handle negative numbers.
          then (Word64Map a -> Word64Map a) -> SplitLookup a -> SplitLookup a
forall a.
(Word64Map a -> Word64Map a) -> SplitLookup a -> SplitLookup a
mapLT ((Word64Map a -> Word64Map a -> Word64Map a)
-> Word64Map a -> Word64Map a -> Word64Map a
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m) Word64Map a
r) (Word64 -> Word64Map a -> SplitLookup a
forall {a}. Word64 -> Word64Map a -> SplitLookup a
go Word64
k Word64Map a
l)
          else (Word64Map a -> Word64Map a) -> SplitLookup a -> SplitLookup a
forall a.
(Word64Map a -> Word64Map a) -> SplitLookup a -> SplitLookup a
mapGT (Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m Word64Map a
l) (Word64 -> Word64Map a -> SplitLookup a
forall {a}. Word64 -> Word64Map a -> SplitLookup a
go Word64
k Word64Map a
r)
      Word64Map a
_ -> Word64 -> Word64Map a -> SplitLookup a
forall {a}. Word64 -> Word64Map a -> SplitLookup a
go Word64
k Word64Map a
t
  of SplitLookup Word64Map a
lt Maybe a
fnd Word64Map a
gt -> (Word64Map a
lt, Maybe a
fnd, Word64Map a
gt)
  where
    go :: Word64 -> Word64Map a -> SplitLookup a
go Word64
k' t' :: Word64Map a
t'@(Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
      | Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
k' Word64
p Word64
m =
          if Word64
k' Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
> Word64
p
          then Word64Map a -> Maybe a -> Word64Map a -> SplitLookup a
forall a. Word64Map a -> Maybe a -> Word64Map a -> SplitLookup a
SplitLookup Word64Map a
t' Maybe a
forall a. Maybe a
Nothing Word64Map a
forall a. Word64Map a
Nil
          else Word64Map a -> Maybe a -> Word64Map a -> SplitLookup a
forall a. Word64Map a -> Maybe a -> Word64Map a -> SplitLookup a
SplitLookup Word64Map a
forall a. Word64Map a
Nil Maybe a
forall a. Maybe a
Nothing Word64Map a
t'
      | Word64 -> Word64 -> Bool
zero Word64
k' Word64
m = (Word64Map a -> Word64Map a) -> SplitLookup a -> SplitLookup a
forall a.
(Word64Map a -> Word64Map a) -> SplitLookup a -> SplitLookup a
mapGT ((Word64Map a -> Word64Map a -> Word64Map a)
-> Word64Map a -> Word64Map a -> Word64Map a
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m) Word64Map a
r) (Word64 -> Word64Map a -> SplitLookup a
go Word64
k' Word64Map a
l)
      | Bool
otherwise = (Word64Map a -> Word64Map a) -> SplitLookup a -> SplitLookup a
forall a.
(Word64Map a -> Word64Map a) -> SplitLookup a -> SplitLookup a
mapLT (Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
p Word64
m Word64Map a
l) (Word64 -> Word64Map a -> SplitLookup a
go Word64
k' Word64Map a
r)
    go Word64
k' t' :: Word64Map a
t'@(Tip Word64
ky a
y)
      | Word64
k' Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
> Word64
ky   = Word64Map a -> Maybe a -> Word64Map a -> SplitLookup a
forall a. Word64Map a -> Maybe a -> Word64Map a -> SplitLookup a
SplitLookup Word64Map a
t'  Maybe a
forall a. Maybe a
Nothing  Word64Map a
forall a. Word64Map a
Nil
      | Word64
k' Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
ky   = Word64Map a -> Maybe a -> Word64Map a -> SplitLookup a
forall a. Word64Map a -> Maybe a -> Word64Map a -> SplitLookup a
SplitLookup Word64Map a
forall a. Word64Map a
Nil Maybe a
forall a. Maybe a
Nothing  Word64Map a
t'
      | Bool
otherwise = Word64Map a -> Maybe a -> Word64Map a -> SplitLookup a
forall a. Word64Map a -> Maybe a -> Word64Map a -> SplitLookup a
SplitLookup Word64Map a
forall a. Word64Map a
Nil (a -> Maybe a
forall a. a -> Maybe a
Just a
y) Word64Map a
forall a. Word64Map a
Nil
    go Word64
_ Word64Map a
Nil      = Word64Map a -> Maybe a -> Word64Map a -> SplitLookup a
forall a. Word64Map a -> Maybe a -> Word64Map a -> SplitLookup a
SplitLookup Word64Map a
forall a. Word64Map a
Nil Maybe a
forall a. Maybe a
Nothing  Word64Map a
forall a. Word64Map a
Nil

{--------------------------------------------------------------------
  Fold
--------------------------------------------------------------------}
-- | \(O(n)\). Fold the values in the map using the given right-associative
-- binary operator, such that @'foldr' f z == 'Prelude.foldr' f z . 'elems'@.
--
-- For example,
--
-- > elems map = foldr (:) [] map
--
-- > let f a len = len + (length a)
-- > foldr f 0 (fromList [(5,"a"), (3,"bbb")]) == 4
foldr :: (a -> b -> b) -> b -> Word64Map a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Word64Map a -> b
foldr a -> b -> b
f b
z = \Word64Map a
t ->      -- Use lambda t to be inlinable with two arguments only.
  case Word64Map a
t of
    Bin Word64
_ Word64
m Word64Map a
l Word64Map a
r
      | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 -> b -> Word64Map a -> b
go (b -> Word64Map a -> b
go b
z Word64Map a
l) Word64Map a
r -- put negative numbers before
      | Bool
otherwise -> b -> Word64Map a -> b
go (b -> Word64Map a -> b
go b
z Word64Map a
r) Word64Map a
l
    Word64Map a
_ -> b -> Word64Map a -> b
go b
z Word64Map a
t
  where
    go :: b -> Word64Map a -> b
go b
z' Word64Map a
Nil           = b
z'
    go b
z' (Tip Word64
_ a
x)     = a -> b -> b
f a
x b
z'
    go b
z' (Bin Word64
_ Word64
_ Word64Map a
l Word64Map a
r) = b -> Word64Map a -> b
go (b -> Word64Map a -> b
go b
z' Word64Map a
r) Word64Map a
l
{-# INLINE foldr #-}

-- | \(O(n)\). A strict version of 'foldr'. Each application of the operator is
-- evaluated before using the result in the next application. This
-- function is strict in the starting value.
foldr' :: (a -> b -> b) -> b -> Word64Map a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Word64Map a -> b
foldr' a -> b -> b
f b
z = \Word64Map a
t ->      -- Use lambda t to be inlinable with two arguments only.
  case Word64Map a
t of
    Bin Word64
_ Word64
m Word64Map a
l Word64Map a
r
      | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 -> b -> Word64Map a -> b
go (b -> Word64Map a -> b
go b
z Word64Map a
l) Word64Map a
r -- put negative numbers before
      | Bool
otherwise -> b -> Word64Map a -> b
go (b -> Word64Map a -> b
go b
z Word64Map a
r) Word64Map a
l
    Word64Map a
_ -> b -> Word64Map a -> b
go b
z Word64Map a
t
  where
    go :: b -> Word64Map a -> b
go !b
z' Word64Map a
Nil          = b
z'
    go b
z' (Tip Word64
_ a
x)     = a -> b -> b
f a
x b
z'
    go b
z' (Bin Word64
_ Word64
_ Word64Map a
l Word64Map a
r) = b -> Word64Map a -> b
go (b -> Word64Map a -> b
go b
z' Word64Map a
r) Word64Map a
l
{-# INLINE foldr' #-}

-- | \(O(n)\). Fold the values in the map using the given left-associative
-- binary operator, such that @'foldl' f z == 'Prelude.foldl' f z . 'elems'@.
--
-- For example,
--
-- > elems = reverse . foldl (flip (:)) []
--
-- > let f len a = len + (length a)
-- > foldl f 0 (fromList [(5,"a"), (3,"bbb")]) == 4
foldl :: (a -> b -> a) -> a -> Word64Map b -> a
foldl :: forall b a. (b -> a -> b) -> b -> Word64Map a -> b
foldl a -> b -> a
f a
z = \Word64Map b
t ->      -- Use lambda t to be inlinable with two arguments only.
  case Word64Map b
t of
    Bin Word64
_ Word64
m Word64Map b
l Word64Map b
r
      | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 -> a -> Word64Map b -> a
go (a -> Word64Map b -> a
go a
z Word64Map b
r) Word64Map b
l -- put negative numbers before
      | Bool
otherwise -> a -> Word64Map b -> a
go (a -> Word64Map b -> a
go a
z Word64Map b
l) Word64Map b
r
    Word64Map b
_ -> a -> Word64Map b -> a
go a
z Word64Map b
t
  where
    go :: a -> Word64Map b -> a
go a
z' Word64Map b
Nil           = a
z'
    go a
z' (Tip Word64
_ b
x)     = a -> b -> a
f a
z' b
x
    go a
z' (Bin Word64
_ Word64
_ Word64Map b
l Word64Map b
r) = a -> Word64Map b -> a
go (a -> Word64Map b -> a
go a
z' Word64Map b
l) Word64Map b
r
{-# INLINE foldl #-}

-- | \(O(n)\). A strict version of 'foldl'. Each application of the operator is
-- evaluated before using the result in the next application. This
-- function is strict in the starting value.
foldl' :: (a -> b -> a) -> a -> Word64Map b -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Word64Map a -> b
foldl' a -> b -> a
f a
z = \Word64Map b
t ->      -- Use lambda t to be inlinable with two arguments only.
  case Word64Map b
t of
    Bin Word64
_ Word64
m Word64Map b
l Word64Map b
r
      | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 -> a -> Word64Map b -> a
go (a -> Word64Map b -> a
go a
z Word64Map b
r) Word64Map b
l -- put negative numbers before
      | Bool
otherwise -> a -> Word64Map b -> a
go (a -> Word64Map b -> a
go a
z Word64Map b
l) Word64Map b
r
    Word64Map b
_ -> a -> Word64Map b -> a
go a
z Word64Map b
t
  where
    go :: a -> Word64Map b -> a
go !a
z' Word64Map b
Nil          = a
z'
    go a
z' (Tip Word64
_ b
x)     = a -> b -> a
f a
z' b
x
    go a
z' (Bin Word64
_ Word64
_ Word64Map b
l Word64Map b
r) = a -> Word64Map b -> a
go (a -> Word64Map b -> a
go a
z' Word64Map b
l) Word64Map b
r
{-# INLINE foldl' #-}

-- | \(O(n)\). Fold the keys and values in the map using the given right-associative
-- binary operator, such that
-- @'foldrWithKey' f z == 'Prelude.foldr' ('uncurry' f) z . 'toAscList'@.
--
-- For example,
--
-- > keys map = foldrWithKey (\k x ks -> k:ks) [] map
--
-- > let f k a result = result ++ "(" ++ (show k) ++ ":" ++ a ++ ")"
-- > foldrWithKey f "Map: " (fromList [(5,"a"), (3,"b")]) == "Map: (5:a)(3:b)"
foldrWithKey :: (Key -> a -> b -> b) -> b -> Word64Map a -> b
foldrWithKey :: forall a b. (Word64 -> a -> b -> b) -> b -> Word64Map a -> b
foldrWithKey Word64 -> a -> b -> b
f b
z = \Word64Map a
t ->      -- Use lambda t to be inlinable with two arguments only.
  case Word64Map a
t of
    Bin Word64
_ Word64
m Word64Map a
l Word64Map a
r
      | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 -> b -> Word64Map a -> b
go (b -> Word64Map a -> b
go b
z Word64Map a
l) Word64Map a
r -- put negative numbers before
      | Bool
otherwise -> b -> Word64Map a -> b
go (b -> Word64Map a -> b
go b
z Word64Map a
r) Word64Map a
l
    Word64Map a
_ -> b -> Word64Map a -> b
go b
z Word64Map a
t
  where
    go :: b -> Word64Map a -> b
go b
z' Word64Map a
Nil           = b
z'
    go b
z' (Tip Word64
kx a
x)    = Word64 -> a -> b -> b
f Word64
kx a
x b
z'
    go b
z' (Bin Word64
_ Word64
_ Word64Map a
l Word64Map a
r) = b -> Word64Map a -> b
go (b -> Word64Map a -> b
go b
z' Word64Map a
r) Word64Map a
l
{-# INLINE foldrWithKey #-}

-- | \(O(n)\). A strict version of 'foldrWithKey'. Each application of the operator is
-- evaluated before using the result in the next application. This
-- function is strict in the starting value.
foldrWithKey' :: (Key -> a -> b -> b) -> b -> Word64Map a -> b
foldrWithKey' :: forall a b. (Word64 -> a -> b -> b) -> b -> Word64Map a -> b
foldrWithKey' Word64 -> a -> b -> b
f b
z = \Word64Map a
t ->      -- Use lambda t to be inlinable with two arguments only.
  case Word64Map a
t of
    Bin Word64
_ Word64
m Word64Map a
l Word64Map a
r
      | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 -> b -> Word64Map a -> b
go (b -> Word64Map a -> b
go b
z Word64Map a
l) Word64Map a
r -- put negative numbers before
      | Bool
otherwise -> b -> Word64Map a -> b
go (b -> Word64Map a -> b
go b
z Word64Map a
r) Word64Map a
l
    Word64Map a
_ -> b -> Word64Map a -> b
go b
z Word64Map a
t
  where
    go :: b -> Word64Map a -> b
go !b
z' Word64Map a
Nil          = b
z'
    go b
z' (Tip Word64
kx a
x)    = Word64 -> a -> b -> b
f Word64
kx a
x b
z'
    go b
z' (Bin Word64
_ Word64
_ Word64Map a
l Word64Map a
r) = b -> Word64Map a -> b
go (b -> Word64Map a -> b
go b
z' Word64Map a
r) Word64Map a
l
{-# INLINE foldrWithKey' #-}

-- | \(O(n)\). Fold the keys and values in the map using the given left-associative
-- binary operator, such that
-- @'foldlWithKey' f z == 'Prelude.foldl' (\\z' (kx, x) -> f z' kx x) z . 'toAscList'@.
--
-- For example,
--
-- > keys = reverse . foldlWithKey (\ks k x -> k:ks) []
--
-- > let f result k a = result ++ "(" ++ (show k) ++ ":" ++ a ++ ")"
-- > foldlWithKey f "Map: " (fromList [(5,"a"), (3,"b")]) == "Map: (3:b)(5:a)"
foldlWithKey :: (a -> Key -> b -> a) -> a -> Word64Map b -> a
foldlWithKey :: forall a b. (a -> Word64 -> b -> a) -> a -> Word64Map b -> a
foldlWithKey a -> Word64 -> b -> a
f a
z = \Word64Map b
t ->      -- Use lambda t to be inlinable with two arguments only.
  case Word64Map b
t of
    Bin Word64
_ Word64
m Word64Map b
l Word64Map b
r
      | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 -> a -> Word64Map b -> a
go (a -> Word64Map b -> a
go a
z Word64Map b
r) Word64Map b
l -- put negative numbers before
      | Bool
otherwise -> a -> Word64Map b -> a
go (a -> Word64Map b -> a
go a
z Word64Map b
l) Word64Map b
r
    Word64Map b
_ -> a -> Word64Map b -> a
go a
z Word64Map b
t
  where
    go :: a -> Word64Map b -> a
go a
z' Word64Map b
Nil           = a
z'
    go a
z' (Tip Word64
kx b
x)    = a -> Word64 -> b -> a
f a
z' Word64
kx b
x
    go a
z' (Bin Word64
_ Word64
_ Word64Map b
l Word64Map b
r) = a -> Word64Map b -> a
go (a -> Word64Map b -> a
go a
z' Word64Map b
l) Word64Map b
r
{-# INLINE foldlWithKey #-}

-- | \(O(n)\). A strict version of 'foldlWithKey'. Each application of the operator is
-- evaluated before using the result in the next application. This
-- function is strict in the starting value.
foldlWithKey' :: (a -> Key -> b -> a) -> a -> Word64Map b -> a
foldlWithKey' :: forall a b. (a -> Word64 -> b -> a) -> a -> Word64Map b -> a
foldlWithKey' a -> Word64 -> b -> a
f a
z = \Word64Map b
t ->      -- Use lambda t to be inlinable with two arguments only.
  case Word64Map b
t of
    Bin Word64
_ Word64
m Word64Map b
l Word64Map b
r
      | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 -> a -> Word64Map b -> a
go (a -> Word64Map b -> a
go a
z Word64Map b
r) Word64Map b
l -- put negative numbers before
      | Bool
otherwise -> a -> Word64Map b -> a
go (a -> Word64Map b -> a
go a
z Word64Map b
l) Word64Map b
r
    Word64Map b
_ -> a -> Word64Map b -> a
go a
z Word64Map b
t
  where
    go :: a -> Word64Map b -> a
go !a
z' Word64Map b
Nil          = a
z'
    go a
z' (Tip Word64
kx b
x)    = a -> Word64 -> b -> a
f a
z' Word64
kx b
x
    go a
z' (Bin Word64
_ Word64
_ Word64Map b
l Word64Map b
r) = a -> Word64Map b -> a
go (a -> Word64Map b -> a
go a
z' Word64Map b
l) Word64Map b
r
{-# INLINE foldlWithKey' #-}

-- | \(O(n)\). Fold the keys and values in the map using the given monoid, such that
--
-- @'foldMapWithKey' f = 'Prelude.fold' . 'mapWithKey' f@
--
-- This can be an asymptotically faster than 'foldrWithKey' or 'foldlWithKey' for some monoids.
--
-- @since 0.5.4
foldMapWithKey :: Monoid m => (Key -> a -> m) -> Word64Map a -> m
foldMapWithKey :: forall m a. Monoid m => (Word64 -> a -> m) -> Word64Map a -> m
foldMapWithKey Word64 -> a -> m
f = Word64Map a -> m
go
  where
    go :: Word64Map a -> m
go Word64Map a
Nil           = m
forall a. Monoid a => a
mempty
    go (Tip Word64
kx a
x)    = Word64 -> a -> m
f Word64
kx a
x
    go (Bin Word64
_ Word64
m Word64Map a
l Word64Map a
r)
      | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0     = Word64Map a -> m
go Word64Map a
r m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` Word64Map a -> m
go Word64Map a
l
      | Bool
otherwise = Word64Map a -> m
go Word64Map a
l m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` Word64Map a -> m
go Word64Map a
r
{-# INLINE foldMapWithKey #-}

{--------------------------------------------------------------------
  List variations
--------------------------------------------------------------------}
-- | \(O(n)\).
-- Return all elements of the map in the ascending order of their keys.
-- Subject to list fusion.
--
-- > elems (fromList [(5,"a"), (3,"b")]) == ["b","a"]
-- > elems empty == []

elems :: Word64Map a -> [a]
elems :: forall a. Word64Map a -> [a]
elems = (a -> [a] -> [a]) -> [a] -> Word64Map a -> [a]
forall a b. (a -> b -> b) -> b -> Word64Map a -> b
foldr (:) []

-- | \(O(n)\). Return all keys of the map in ascending order. Subject to list
-- fusion.
--
-- > keys (fromList [(5,"a"), (3,"b")]) == [3,5]
-- > keys empty == []

keys  :: Word64Map a -> [Key]
keys :: forall a. Word64Map a -> [Word64]
keys = (Word64 -> a -> [Word64] -> [Word64])
-> [Word64] -> Word64Map a -> [Word64]
forall a b. (Word64 -> a -> b -> b) -> b -> Word64Map a -> b
foldrWithKey (\Word64
k a
_ [Word64]
ks -> Word64
k Word64 -> [Word64] -> [Word64]
forall a. a -> [a] -> [a]
: [Word64]
ks) []

-- | \(O(n)\). An alias for 'toAscList'. Returns all key\/value pairs in the
-- map in ascending key order. Subject to list fusion.
--
-- > assocs (fromList [(5,"a"), (3,"b")]) == [(3,"b"), (5,"a")]
-- > assocs empty == []

assocs :: Word64Map a -> [(Key,a)]
assocs :: forall a. Word64Map a -> [(Word64, a)]
assocs = Word64Map a -> [(Word64, a)]
forall a. Word64Map a -> [(Word64, a)]
toAscList

-- | \(O(n \min(n,W))\). The set of all keys of the map.
--
-- > keysSet (fromList [(5,"a"), (3,"b")]) == Data.Word64Set.fromList [3,5]
-- > keysSet empty == Data.Word64Set.empty

keysSet :: Word64Map a -> Word64Set.Word64Set
keysSet :: forall a. Word64Map a -> Word64Set
keysSet Word64Map a
Nil = Word64Set
Word64Set.Nil
keysSet (Tip Word64
kx a
_) = Word64 -> Word64Set
Word64Set.singleton Word64
kx
keysSet (Bin Word64
p Word64
m Word64Map a
l Word64Map a
r)
  | Word64
m Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. Word64
Word64Set.suffixBitMask Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
0 = Word64 -> Word64 -> Word64Set -> Word64Set -> Word64Set
Word64Set.Bin Word64
p Word64
m (Word64Map a -> Word64Set
forall a. Word64Map a -> Word64Set
keysSet Word64Map a
l) (Word64Map a -> Word64Set
forall a. Word64Map a -> Word64Set
keysSet Word64Map a
r)
  | Bool
otherwise = Word64 -> Word64 -> Word64Set
Word64Set.Tip (Word64
p Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. Word64
Word64Set.prefixBitMask) (Word64 -> Word64Map a -> Word64
forall {a}. Word64 -> Word64Map a -> Word64
computeBm (Word64 -> Word64Map a -> Word64
forall {a}. Word64 -> Word64Map a -> Word64
computeBm Word64
0 Word64Map a
l) Word64Map a
r)
  where computeBm :: Word64 -> Word64Map a -> Word64
computeBm !Word64
acc (Bin Word64
_ Word64
_ Word64Map a
l' Word64Map a
r') = Word64 -> Word64Map a -> Word64
computeBm (Word64 -> Word64Map a -> Word64
computeBm Word64
acc Word64Map a
l') Word64Map a
r'
        computeBm Word64
acc (Tip Word64
kx a
_) = Word64
acc Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.|. Word64 -> Word64
Word64Set.bitmapOf Word64
kx
        computeBm Word64
_   Word64Map a
Nil = [Char] -> Word64
forall a. HasCallStack => [Char] -> a
error [Char]
"Data.Word64Set.keysSet: Nil"

-- | \(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.Word64Set.fromList [3, 5]) == fromList [(5,"aaaaa"), (3,"aaa")]
-- > fromSet undefined Data.Word64Set.empty == empty

fromSet :: (Key -> a) -> Word64Set.Word64Set -> Word64Map a
fromSet :: forall a. (Word64 -> a) -> Word64Set -> Word64Map a
fromSet Word64 -> a
_ Word64Set
Word64Set.Nil = Word64Map a
forall a. Word64Map a
Nil
fromSet Word64 -> a
f (Word64Set.Bin Word64
p Word64
m Word64Set
l Word64Set
r) = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m ((Word64 -> a) -> Word64Set -> Word64Map a
forall a. (Word64 -> a) -> Word64Set -> Word64Map a
fromSet Word64 -> a
f Word64Set
l) ((Word64 -> a) -> Word64Set -> Word64Map a
forall a. (Word64 -> a) -> Word64Set -> Word64Map a
fromSet Word64 -> a
f Word64Set
r)
fromSet Word64 -> a
f (Word64Set.Tip Word64
kx Word64
bm) = (Word64 -> a) -> Word64 -> Word64 -> Word64 -> Word64Map a
forall {a}.
(Word64 -> a) -> Word64 -> Word64 -> Word64 -> Word64Map a
buildTree Word64 -> a
f Word64
kx Word64
bm (Word64
Word64Set.suffixBitMask Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
+ Word64
1)
  where
    -- This is slightly complicated, as we to convert the dense
    -- representation of Word64Set into tree representation of Word64Map.
    --
    -- 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 Word64Map from that half.
    buildTree :: (Word64 -> a) -> Word64 -> Word64 -> Word64 -> Word64Map a
buildTree Word64 -> a
g !Word64
prefix !Word64
bmask Word64
bits = case Word64
bits of
      Word64
0 -> Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
prefix (Word64 -> a
g Word64
prefix)
      Word64
_ -> case Word64 -> Word64
intFromNat ((Word64 -> Word64
natFromInt Word64
bits) Word64 -> Int -> Word64
`shiftRL` Int
1) of
        Word64
bits2
          | Word64
bmask Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. ((Word64
1 Word64 -> Int -> Word64
`shiftLL` Word64 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
bits2) Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- Word64
1) Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
0 ->
              (Word64 -> a) -> Word64 -> Word64 -> Word64 -> Word64Map a
buildTree Word64 -> a
g (Word64
prefix Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
+ Word64
bits2) (Word64
bmask Word64 -> Int -> Word64
`shiftRL` Word64 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
bits2) Word64
bits2
          | (Word64
bmask Word64 -> Int -> Word64
`shiftRL` Word64 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
bits2) Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. ((Word64
1 Word64 -> Int -> Word64
`shiftLL` Word64 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
bits2) Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- Word64
1) Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
0 ->
              (Word64 -> a) -> Word64 -> Word64 -> Word64 -> Word64Map a
buildTree Word64 -> a
g Word64
prefix Word64
bmask Word64
bits2
          | Bool
otherwise ->
              Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
prefix Word64
bits2
                ((Word64 -> a) -> Word64 -> Word64 -> Word64 -> Word64Map a
buildTree Word64 -> a
g Word64
prefix Word64
bmask Word64
bits2)
                ((Word64 -> a) -> Word64 -> Word64 -> Word64 -> Word64Map a
buildTree Word64 -> a
g (Word64
prefix Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
+ Word64
bits2) (Word64
bmask Word64 -> Int -> Word64
`shiftRL` Word64 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
bits2) Word64
bits2)

{--------------------------------------------------------------------
  Lists
--------------------------------------------------------------------}

#ifdef __GLASGOW_HASKELL__
-- | @since 0.5.6.2
instance GHCExts.IsList (Word64Map a) where
  type Item (Word64Map a) = (Key,a)
  fromList :: [Item (Word64Map a)] -> Word64Map a
fromList = [(Word64, a)] -> Word64Map a
[Item (Word64Map a)] -> Word64Map a
forall a. [(Word64, a)] -> Word64Map a
fromList
  toList :: Word64Map a -> [Item (Word64Map a)]
toList   = Word64Map a -> [(Word64, a)]
Word64Map a -> [Item (Word64Map a)]
forall a. Word64Map a -> [(Word64, a)]
toList
#endif

-- | \(O(n)\). Convert the map to a list of key\/value pairs. Subject to list
-- fusion.
--
-- > toList (fromList [(5,"a"), (3,"b")]) == [(3,"b"), (5,"a")]
-- > toList empty == []

toList :: Word64Map a -> [(Key,a)]
toList :: forall a. Word64Map a -> [(Word64, a)]
toList = Word64Map a -> [(Word64, a)]
forall a. Word64Map a -> [(Word64, a)]
toAscList

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

toAscList :: Word64Map a -> [(Key,a)]
toAscList :: forall a. Word64Map a -> [(Word64, a)]
toAscList = (Word64 -> a -> [(Word64, a)] -> [(Word64, a)])
-> [(Word64, a)] -> Word64Map a -> [(Word64, a)]
forall a b. (Word64 -> a -> b -> b) -> b -> Word64Map a -> b
foldrWithKey (\Word64
k a
x [(Word64, a)]
xs -> (Word64
k,a
x)(Word64, a) -> [(Word64, a)] -> [(Word64, a)]
forall a. a -> [a] -> [a]
:[(Word64, a)]
xs) []

-- | \(O(n)\). Convert the map to a list of key\/value pairs where the keys
-- are in descending order. Subject to list fusion.
--
-- > toDescList (fromList [(5,"a"), (3,"b")]) == [(5,"a"), (3,"b")]

toDescList :: Word64Map a -> [(Key,a)]
toDescList :: forall a. Word64Map a -> [(Word64, a)]
toDescList = ([(Word64, a)] -> Word64 -> a -> [(Word64, a)])
-> [(Word64, a)] -> Word64Map a -> [(Word64, a)]
forall a b. (a -> Word64 -> b -> a) -> a -> Word64Map b -> a
foldlWithKey (\[(Word64, a)]
xs Word64
k a
x -> (Word64
k,a
x)(Word64, a) -> [(Word64, a)] -> [(Word64, a)]
forall a. a -> [a] -> [a]
:[(Word64, a)]
xs) []

-- List fusion for the list generating functions.
#if __GLASGOW_HASKELL__
-- The foldrFB and foldlFB are fold{r,l}WithKey equivalents, used for list fusion.
-- They are important to convert unfused methods back, see mapFB in prelude.
foldrFB :: (Key -> a -> b -> b) -> b -> Word64Map a -> b
foldrFB :: forall a b. (Word64 -> a -> b -> b) -> b -> Word64Map a -> b
foldrFB = (Word64 -> a -> b -> b) -> b -> Word64Map a -> b
forall a b. (Word64 -> a -> b -> b) -> b -> Word64Map a -> b
foldrWithKey
{-# INLINE[0] foldrFB #-}
foldlFB :: (a -> Key -> b -> a) -> a -> Word64Map b -> a
foldlFB :: forall a b. (a -> Word64 -> b -> a) -> a -> Word64Map b -> a
foldlFB = (a -> Word64 -> b -> a) -> a -> Word64Map b -> a
forall a b. (a -> Word64 -> b -> a) -> a -> Word64Map b -> a
foldlWithKey
{-# INLINE[0] foldlFB #-}

-- Inline assocs and toList, so that we need to fuse only toAscList.
{-# INLINE assocs #-}
{-# INLINE toList #-}

-- The fusion is enabled up to phase 2 included. If it does not succeed,
-- convert in phase 1 the expanded elems,keys,to{Asc,Desc}List calls back to
-- elems,keys,to{Asc,Desc}List.  In phase 0, we inline fold{lr}FB (which were
-- used in a list fusion, otherwise it would go away in phase 1), and let compiler
-- do whatever it wants with elems,keys,to{Asc,Desc}List -- it was forbidden to
-- inline it before phase 0, otherwise the fusion rules would not fire at all.
{-# NOINLINE[0] elems #-}
{-# NOINLINE[0] keys #-}
{-# NOINLINE[0] toAscList #-}
{-# NOINLINE[0] toDescList #-}
{-# RULES "Word64Map.elems" [~1] forall m . elems m = build (\c n -> foldrFB (\_ x xs -> c x xs) n m) #-}
{-# RULES "Word64Map.elemsBack" [1] foldrFB (\_ x xs -> x : xs) [] = elems #-}
{-# RULES "Word64Map.keys" [~1] forall m . keys m = build (\c n -> foldrFB (\k _ xs -> c k xs) n m) #-}
{-# RULES "Word64Map.keysBack" [1] foldrFB (\k _ xs -> k : xs) [] = keys #-}
{-# RULES "Word64Map.toAscList" [~1] forall m . toAscList m = build (\c n -> foldrFB (\k x xs -> c (k,x) xs) n m) #-}
{-# RULES "Word64Map.toAscListBack" [1] foldrFB (\k x xs -> (k, x) : xs) [] = toAscList #-}
{-# RULES "Word64Map.toDescList" [~1] forall m . toDescList m = build (\c n -> foldlFB (\xs k x -> c (k,x) xs) n m) #-}
{-# RULES "Word64Map.toDescListBack" [1] foldlFB (\xs k x -> (k, x) : xs) [] = toDescList #-}
#endif


-- | \(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)] -> Word64Map a
fromList :: forall a. [(Word64, a)] -> Word64Map a
fromList [(Word64, a)]
xs
  = (Word64Map a -> (Word64, a) -> Word64Map a)
-> Word64Map a -> [(Word64, a)] -> Word64Map 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' Word64Map a -> (Word64, a) -> Word64Map a
forall {a}. Word64Map a -> (Word64, a) -> Word64Map a
ins Word64Map a
forall a. Word64Map a
empty [(Word64, a)]
xs
  where
    ins :: Word64Map a -> (Word64, a) -> Word64Map a
ins Word64Map a
t (Word64
k,a
x)  = Word64 -> a -> Word64Map a -> Word64Map a
forall a. Word64 -> a -> Word64Map a -> Word64Map a
insert Word64
k a
x Word64Map 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,"c")] == fromList [(3, "ab"), (5, "cba")]
-- > fromListWith (++) [] == empty

fromListWith :: (a -> a -> a) -> [(Key,a)] -> Word64Map a
fromListWith :: forall a. (a -> a -> a) -> [(Word64, a)] -> Word64Map a
fromListWith a -> a -> a
f [(Word64, a)]
xs
  = (Word64 -> a -> a -> a) -> [(Word64, a)] -> Word64Map a
forall a. (Word64 -> a -> a -> a) -> [(Word64, a)] -> Word64Map a
fromListWithKey (\Word64
_ a
x a
y -> a -> a -> a
f a
x a
y) [(Word64, 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)] -> Word64Map a
fromListWithKey :: forall a. (Word64 -> a -> a -> a) -> [(Word64, a)] -> Word64Map a
fromListWithKey Word64 -> a -> a -> a
f [(Word64, a)]
xs
  = (Word64Map a -> (Word64, a) -> Word64Map a)
-> Word64Map a -> [(Word64, a)] -> Word64Map 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' Word64Map a -> (Word64, a) -> Word64Map a
ins Word64Map a
forall a. Word64Map a
empty [(Word64, a)]
xs
  where
    ins :: Word64Map a -> (Word64, a) -> Word64Map a
ins Word64Map a
t (Word64
k,a
x) = (Word64 -> a -> a -> a)
-> Word64 -> a -> Word64Map a -> Word64Map a
forall a.
(Word64 -> a -> a -> a)
-> Word64 -> a -> Word64Map a -> Word64Map a
insertWithKey Word64 -> a -> a -> a
f Word64
k a
x Word64Map 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)] -> Word64Map a
fromAscList :: forall a. [(Word64, a)] -> Word64Map a
fromAscList = Distinct -> (Word64 -> a -> a -> a) -> [(Word64, a)] -> Word64Map a
forall a.
Distinct -> (Word64 -> a -> a -> a) -> [(Word64, a)] -> Word64Map a
fromMonoListWithKey Distinct
Nondistinct (\Word64
_ 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)] -> Word64Map a
fromAscListWith :: forall a. (a -> a -> a) -> [(Word64, a)] -> Word64Map a
fromAscListWith a -> a -> a
f = Distinct -> (Word64 -> a -> a -> a) -> [(Word64, a)] -> Word64Map a
forall a.
Distinct -> (Word64 -> a -> a -> a) -> [(Word64, a)] -> Word64Map a
fromMonoListWithKey Distinct
Nondistinct (\Word64
_ 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./
--
-- > let f key new_value old_value = (show key) ++ ":" ++ new_value ++ "|" ++ old_value
-- > fromAscListWithKey f [(3,"b"), (5,"a"), (5,"b")] == fromList [(3, "b"), (5, "5:b|a")]

fromAscListWithKey :: (Key -> a -> a -> a) -> [(Key,a)] -> Word64Map a
fromAscListWithKey :: forall a. (Word64 -> a -> a -> a) -> [(Word64, a)] -> Word64Map a
fromAscListWithKey Word64 -> a -> a -> a
f = Distinct -> (Word64 -> a -> a -> a) -> [(Word64, a)] -> Word64Map a
forall a.
Distinct -> (Word64 -> a -> a -> a) -> [(Word64, a)] -> Word64Map a
fromMonoListWithKey Distinct
Nondistinct Word64 -> 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)] -> Word64Map a
fromDistinctAscList :: forall a. [(Word64, a)] -> Word64Map a
fromDistinctAscList = Distinct -> (Word64 -> a -> a -> a) -> [(Word64, a)] -> Word64Map a
forall a.
Distinct -> (Word64 -> a -> a -> a) -> [(Word64, a)] -> Word64Map a
fromMonoListWithKey Distinct
Distinct (\Word64
_ 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)] -> Word64Map a
fromMonoListWithKey :: forall a.
Distinct -> (Word64 -> a -> a -> a) -> [(Word64, a)] -> Word64Map a
fromMonoListWithKey Distinct
distinct Word64 -> a -> a -> a
f = [(Word64, a)] -> Word64Map a
go
  where
    go :: [(Word64, a)] -> Word64Map a
go []              = Word64Map a
forall a. Word64Map a
Nil
    go ((Word64
kx,a
vx) : [(Word64, a)]
zs1) = Word64 -> a -> [(Word64, a)] -> Word64Map a
addAll' Word64
kx a
vx [(Word64, a)]
zs1

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

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

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

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

data Distinct = Distinct | Nondistinct

{--------------------------------------------------------------------
  Eq
--------------------------------------------------------------------}
instance Eq a => Eq (Word64Map a) where
  Word64Map a
t1 == :: Word64Map a -> Word64Map a -> Bool
== Word64Map a
t2  = Word64Map a -> Word64Map a -> Bool
forall a. Eq a => Word64Map a -> Word64Map a -> Bool
equal Word64Map a
t1 Word64Map a
t2
  Word64Map a
t1 /= :: Word64Map a -> Word64Map a -> Bool
/= Word64Map a
t2  = Word64Map a -> Word64Map a -> Bool
forall a. Eq a => Word64Map a -> Word64Map a -> Bool
nequal Word64Map a
t1 Word64Map a
t2

equal :: Eq a => Word64Map a -> Word64Map a -> Bool
equal :: forall a. Eq a => Word64Map a -> Word64Map a -> Bool
equal (Bin Word64
p1 Word64
m1 Word64Map a
l1 Word64Map a
r1) (Bin Word64
p2 Word64
m2 Word64Map a
l2 Word64Map a
r2)
  = (Word64
m1 Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
m2) Bool -> Bool -> Bool
&& (Word64
p1 Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
p2) Bool -> Bool -> Bool
&& (Word64Map a -> Word64Map a -> Bool
forall a. Eq a => Word64Map a -> Word64Map a -> Bool
equal Word64Map a
l1 Word64Map a
l2) Bool -> Bool -> Bool
&& (Word64Map a -> Word64Map a -> Bool
forall a. Eq a => Word64Map a -> Word64Map a -> Bool
equal Word64Map a
r1 Word64Map a
r2)
equal (Tip Word64
kx a
x) (Tip Word64
ky a
y)
  = (Word64
kx Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
ky) Bool -> Bool -> Bool
&& (a
xa -> a -> Bool
forall a. Eq a => a -> a -> Bool
==a
y)
equal Word64Map a
Nil Word64Map a
Nil = Bool
True
equal Word64Map a
_   Word64Map a
_   = Bool
False

nequal :: Eq a => Word64Map a -> Word64Map a -> Bool
nequal :: forall a. Eq a => Word64Map a -> Word64Map a -> Bool
nequal (Bin Word64
p1 Word64
m1 Word64Map a
l1 Word64Map a
r1) (Bin Word64
p2 Word64
m2 Word64Map a
l2 Word64Map a
r2)
  = (Word64
m1 Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word64
m2) Bool -> Bool -> Bool
|| (Word64
p1 Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word64
p2) Bool -> Bool -> Bool
|| (Word64Map a -> Word64Map a -> Bool
forall a. Eq a => Word64Map a -> Word64Map a -> Bool
nequal Word64Map a
l1 Word64Map a
l2) Bool -> Bool -> Bool
|| (Word64Map a -> Word64Map a -> Bool
forall a. Eq a => Word64Map a -> Word64Map a -> Bool
nequal Word64Map a
r1 Word64Map a
r2)
nequal (Tip Word64
kx a
x) (Tip Word64
ky a
y)
  = (Word64
kx Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word64
ky) Bool -> Bool -> Bool
|| (a
xa -> a -> Bool
forall a. Eq a => a -> a -> Bool
/=a
y)
nequal Word64Map a
Nil Word64Map a
Nil = Bool
False
nequal Word64Map a
_   Word64Map a
_   = Bool
True

-- | @since 0.5.9
instance Eq1 Word64Map where
  liftEq :: forall a b. (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
liftEq a -> b -> Bool
eq (Bin Word64
p1 Word64
m1 Word64Map a
l1 Word64Map a
r1) (Bin Word64
p2 Word64
m2 Word64Map b
l2 Word64Map b
r2)
    = (Word64
m1 Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
m2) Bool -> Bool -> Bool
&& (Word64
p1 Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
p2) Bool -> Bool -> Bool
&& ((a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
forall a b. (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
forall (f :: * -> *) a b.
Eq1 f =>
(a -> b -> Bool) -> f a -> f b -> Bool
liftEq a -> b -> Bool
eq Word64Map a
l1 Word64Map b
l2) Bool -> Bool -> Bool
&& ((a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
forall a b. (a -> b -> Bool) -> Word64Map a -> Word64Map b -> Bool
forall (f :: * -> *) a b.
Eq1 f =>
(a -> b -> Bool) -> f a -> f b -> Bool
liftEq a -> b -> Bool
eq Word64Map a
r1 Word64Map b
r2)
  liftEq a -> b -> Bool
eq (Tip Word64
kx a
x) (Tip Word64
ky b
y)
    = (Word64
kx Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
ky) Bool -> Bool -> Bool
&& (a -> b -> Bool
eq a
x b
y)
  liftEq a -> b -> Bool
_eq Word64Map a
Nil Word64Map b
Nil = Bool
True
  liftEq a -> b -> Bool
_eq Word64Map a
_   Word64Map b
_   = Bool
False

{--------------------------------------------------------------------
  Ord
--------------------------------------------------------------------}

instance Ord a => Ord (Word64Map a) where
    compare :: Word64Map a -> Word64Map a -> Ordering
compare Word64Map a
m1 Word64Map a
m2 = [(Word64, a)] -> [(Word64, a)] -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (Word64Map a -> [(Word64, a)]
forall a. Word64Map a -> [(Word64, a)]
toList Word64Map a
m1) (Word64Map a -> [(Word64, a)]
forall a. Word64Map a -> [(Word64, a)]
toList Word64Map a
m2)

-- | @since 0.5.9
instance Ord1 Word64Map where
  liftCompare :: forall a b.
(a -> b -> Ordering) -> Word64Map a -> Word64Map b -> Ordering
liftCompare a -> b -> Ordering
cmp Word64Map a
m Word64Map b
n =
    ((Word64, a) -> (Word64, b) -> Ordering)
-> [(Word64, a)] -> [(Word64, b)] -> Ordering
forall a b. (a -> b -> Ordering) -> [a] -> [b] -> Ordering
forall (f :: * -> *) a b.
Ord1 f =>
(a -> b -> Ordering) -> f a -> f b -> Ordering
liftCompare ((a -> b -> Ordering) -> (Word64, a) -> (Word64, b) -> Ordering
forall a b.
(a -> b -> Ordering) -> (Word64, a) -> (Word64, b) -> Ordering
forall (f :: * -> *) a b.
Ord1 f =>
(a -> b -> Ordering) -> f a -> f b -> Ordering
liftCompare a -> b -> Ordering
cmp) (Word64Map a -> [(Word64, a)]
forall a. Word64Map a -> [(Word64, a)]
toList Word64Map a
m) (Word64Map b -> [(Word64, b)]
forall a. Word64Map a -> [(Word64, a)]
toList Word64Map b
n)

{--------------------------------------------------------------------
  Functor
--------------------------------------------------------------------}

instance Functor Word64Map where
    fmap :: forall a b. (a -> b) -> Word64Map a -> Word64Map b
fmap = (a -> b) -> Word64Map a -> Word64Map b
forall a b. (a -> b) -> Word64Map a -> Word64Map b
map

#ifdef __GLASGOW_HASKELL__
    a
a <$ :: forall a b. a -> Word64Map b -> Word64Map a
<$ Bin Word64
p Word64
m Word64Map b
l Word64Map b
r = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m (a
a a -> Word64Map b -> Word64Map a
forall a b. a -> Word64Map b -> Word64Map a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Word64Map b
l) (a
a a -> Word64Map b -> Word64Map a
forall a b. a -> Word64Map b -> Word64Map a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Word64Map b
r)
    a
a <$ Tip Word64
k b
_     = Word64 -> a -> Word64Map a
forall a. Word64 -> a -> Word64Map a
Tip Word64
k a
a
    a
_ <$ Word64Map b
Nil         = Word64Map a
forall a. Word64Map a
Nil
#endif

{--------------------------------------------------------------------
  Show
--------------------------------------------------------------------}

instance Show a => Show (Word64Map a) where
  showsPrec :: Int -> Word64Map a -> [Char] -> [Char]
showsPrec Int
d Word64Map a
m   = Bool -> ([Char] -> [Char]) -> [Char] -> [Char]
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (([Char] -> [Char]) -> [Char] -> [Char])
-> ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$
    [Char] -> [Char] -> [Char]
showString [Char]
"fromList " ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Word64, a)] -> [Char] -> [Char]
forall a. Show a => a -> [Char] -> [Char]
shows (Word64Map a -> [(Word64, a)]
forall a. Word64Map a -> [(Word64, a)]
toList Word64Map a
m)

-- | @since 0.5.9
instance Show1 Word64Map where
    liftShowsPrec :: forall a.
(Int -> a -> [Char] -> [Char])
-> ([a] -> [Char] -> [Char])
-> Int
-> Word64Map a
-> [Char]
-> [Char]
liftShowsPrec Int -> a -> [Char] -> [Char]
sp [a] -> [Char] -> [Char]
sl Int
d Word64Map a
m =
        (Int -> [(Word64, a)] -> [Char] -> [Char])
-> [Char] -> Int -> [(Word64, a)] -> [Char] -> [Char]
forall a.
(Int -> a -> [Char] -> [Char])
-> [Char] -> Int -> a -> [Char] -> [Char]
showsUnaryWith ((Int -> (Word64, a) -> [Char] -> [Char])
-> ([(Word64, a)] -> [Char] -> [Char])
-> Int
-> [(Word64, a)]
-> [Char]
-> [Char]
forall a.
(Int -> a -> [Char] -> [Char])
-> ([a] -> [Char] -> [Char]) -> Int -> [a] -> [Char] -> [Char]
forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> [Char] -> [Char])
-> ([a] -> [Char] -> [Char]) -> Int -> f a -> [Char] -> [Char]
liftShowsPrec Int -> (Word64, a) -> [Char] -> [Char]
sp' [(Word64, a)] -> [Char] -> [Char]
sl') [Char]
"fromList" Int
d (Word64Map a -> [(Word64, a)]
forall a. Word64Map a -> [(Word64, a)]
toList Word64Map a
m)
      where
        sp' :: Int -> (Word64, a) -> [Char] -> [Char]
sp' = (Int -> a -> [Char] -> [Char])
-> ([a] -> [Char] -> [Char])
-> Int
-> (Word64, a)
-> [Char]
-> [Char]
forall a.
(Int -> a -> [Char] -> [Char])
-> ([a] -> [Char] -> [Char])
-> Int
-> (Word64, a)
-> [Char]
-> [Char]
forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> [Char] -> [Char])
-> ([a] -> [Char] -> [Char]) -> Int -> f a -> [Char] -> [Char]
liftShowsPrec Int -> a -> [Char] -> [Char]
sp [a] -> [Char] -> [Char]
sl
        sl' :: [(Word64, a)] -> [Char] -> [Char]
sl' = (Int -> a -> [Char] -> [Char])
-> ([a] -> [Char] -> [Char]) -> [(Word64, a)] -> [Char] -> [Char]
forall a.
(Int -> a -> [Char] -> [Char])
-> ([a] -> [Char] -> [Char]) -> [(Word64, a)] -> [Char] -> [Char]
forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> [Char] -> [Char])
-> ([a] -> [Char] -> [Char]) -> [f a] -> [Char] -> [Char]
liftShowList Int -> a -> [Char] -> [Char]
sp [a] -> [Char] -> [Char]
sl

{--------------------------------------------------------------------
  Read
--------------------------------------------------------------------}
instance (Read e) => Read (Word64Map e) where
#ifdef __GLASGOW_HASKELL__
  readPrec :: ReadPrec (Word64Map e)
readPrec = ReadPrec (Word64Map e) -> ReadPrec (Word64Map e)
forall a. ReadPrec a -> ReadPrec a
parens (ReadPrec (Word64Map e) -> ReadPrec (Word64Map e))
-> ReadPrec (Word64Map e) -> ReadPrec (Word64Map e)
forall a b. (a -> b) -> a -> b
$ Int -> ReadPrec (Word64Map e) -> ReadPrec (Word64Map e)
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
10 (ReadPrec (Word64Map e) -> ReadPrec (Word64Map e))
-> ReadPrec (Word64Map e) -> ReadPrec (Word64Map e)
forall a b. (a -> b) -> a -> b
$ do
    Ident [Char]
"fromList" <- ReadPrec Lexeme
lexP
    [(Word64, e)]
xs <- ReadPrec [(Word64, e)]
forall a. Read a => ReadPrec a
readPrec
    Word64Map e -> ReadPrec (Word64Map e)
forall a. a -> ReadPrec a
forall (m :: * -> *) a. Monad m => a -> m a
return ([(Word64, e)] -> Word64Map e
forall a. [(Word64, a)] -> Word64Map a
fromList [(Word64, e)]
xs)

  readListPrec :: ReadPrec [Word64Map e]
readListPrec = ReadPrec [Word64Map e]
forall a. Read a => ReadPrec [a]
readListPrecDefault
#else
  readsPrec p = readParen (p > 10) $ \ r -> do
    ("fromList",s) <- lex r
    (xs,t) <- reads s
    return (fromList xs,t)
#endif

-- | @since 0.5.9
instance Read1 Word64Map where
    liftReadsPrec :: forall a.
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Word64Map a)
liftReadsPrec Int -> ReadS a
rp ReadS [a]
rl = ([Char] -> ReadS (Word64Map a)) -> Int -> ReadS (Word64Map a)
forall a. ([Char] -> ReadS a) -> Int -> ReadS a
readsData (([Char] -> ReadS (Word64Map a)) -> Int -> ReadS (Word64Map a))
-> ([Char] -> ReadS (Word64Map a)) -> Int -> ReadS (Word64Map a)
forall a b. (a -> b) -> a -> b
$
        (Int -> ReadS [(Word64, a)])
-> [Char]
-> ([(Word64, a)] -> Word64Map a)
-> [Char]
-> ReadS (Word64Map a)
forall a t.
(Int -> ReadS a) -> [Char] -> (a -> t) -> [Char] -> ReadS t
readsUnaryWith ((Int -> ReadS (Word64, a))
-> ReadS [(Word64, a)] -> Int -> ReadS [(Word64, a)]
forall a. (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS [a]
forall (f :: * -> *) a.
Read1 f =>
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (f a)
liftReadsPrec Int -> ReadS (Word64, a)
rp' ReadS [(Word64, a)]
rl') [Char]
"fromList" [(Word64, a)] -> Word64Map a
forall a. [(Word64, a)] -> Word64Map a
fromList
      where
        rp' :: Int -> ReadS (Word64, a)
rp' = (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Word64, a)
forall a. (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Word64, a)
forall (f :: * -> *) a.
Read1 f =>
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (f a)
liftReadsPrec Int -> ReadS a
rp ReadS [a]
rl
        rl' :: ReadS [(Word64, a)]
rl' = (Int -> ReadS a) -> ReadS [a] -> ReadS [(Word64, a)]
forall a. (Int -> ReadS a) -> ReadS [a] -> ReadS [(Word64, a)]
forall (f :: * -> *) a.
Read1 f =>
(Int -> ReadS a) -> ReadS [a] -> ReadS [f a]
liftReadList Int -> ReadS a
rp ReadS [a]
rl

{--------------------------------------------------------------------
  Helpers
--------------------------------------------------------------------}
{--------------------------------------------------------------------
  Link
--------------------------------------------------------------------}
link :: Prefix -> Word64Map a -> Prefix -> Word64Map a -> Word64Map a
link :: forall a.
Word64 -> Word64Map a -> Word64 -> Word64Map a -> Word64Map a
link Word64
p1 Word64Map a
t1 Word64
p2 Word64Map a
t2 = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
linkWithMask (Word64 -> Word64 -> Word64
branchMask Word64
p1 Word64
p2) Word64
p1 Word64Map a
t1 {-p2-} Word64Map a
t2
{-# INLINE link #-}

-- `linkWithMask` is useful when the `branchMask` has already been computed
linkWithMask :: Mask -> Prefix -> Word64Map a -> Word64Map a -> Word64Map a
linkWithMask :: forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
linkWithMask Word64
m Word64
p1 Word64Map a
t1 {-p2-} Word64Map a
t2
  | Word64 -> Word64 -> Bool
zero Word64
p1 Word64
m = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m Word64Map a
t1 Word64Map a
t2
  | Bool
otherwise = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m Word64Map a
t2 Word64Map a
t1
  where
    p :: Word64
p = Word64 -> Word64 -> Word64
mask Word64
p1 Word64
m
{-# INLINE linkWithMask #-}

{--------------------------------------------------------------------
  @bin@ assures that we never have empty trees within a tree.
--------------------------------------------------------------------}
bin :: Prefix -> Mask -> Word64Map a -> Word64Map a -> Word64Map a
bin :: forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
bin Word64
_ Word64
_ Word64Map a
l Word64Map a
Nil = Word64Map a
l
bin Word64
_ Word64
_ Word64Map a
Nil Word64Map a
r = Word64Map a
r
bin Word64
p Word64
m Word64Map a
l Word64Map a
r   = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m Word64Map a
l Word64Map a
r
{-# INLINE bin #-}

-- binCheckLeft only checks that the left subtree is non-empty
binCheckLeft :: Prefix -> Mask -> Word64Map a -> Word64Map a -> Word64Map a
binCheckLeft :: forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckLeft Word64
_ Word64
_ Word64Map a
Nil Word64Map a
r = Word64Map a
r
binCheckLeft Word64
p Word64
m Word64Map a
l Word64Map a
r   = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m Word64Map a
l Word64Map a
r
{-# INLINE binCheckLeft #-}

-- binCheckRight only checks that the right subtree is non-empty
binCheckRight :: Prefix -> Mask -> Word64Map a -> Word64Map a -> Word64Map a
binCheckRight :: forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
binCheckRight Word64
_ Word64
_ Word64Map a
l Word64Map a
Nil = Word64Map a
l
binCheckRight Word64
p Word64
m Word64Map a
l Word64Map a
r   = Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
forall a.
Word64 -> Word64 -> Word64Map a -> Word64Map a -> Word64Map a
Bin Word64
p Word64
m Word64Map a
l Word64Map a
r
{-# INLINE binCheckRight #-}

{--------------------------------------------------------------------
  Endian independent bit twiddling
--------------------------------------------------------------------}

-- | Should this key follow the left subtree of a 'Bin' with switching
-- bit @m@? N.B., the answer is only valid when @match i p m@ is true.
zero :: Key -> Mask -> Bool
zero :: Word64 -> Word64 -> Bool
zero Word64
i Word64
m
  = (Word64 -> Word64
natFromInt Word64
i) Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. (Word64 -> Word64
natFromInt Word64
m) Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
0
{-# INLINE zero #-}

nomatch,match :: Key -> Prefix -> Mask -> Bool

-- | Does the key @i@ differ from the prefix @p@ before getting to
-- the switching bit @m@?
nomatch :: Word64 -> Word64 -> Word64 -> Bool
nomatch Word64
i Word64
p Word64
m
  = (Word64 -> Word64 -> Word64
mask Word64
i Word64
m) Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word64
p
{-# INLINE nomatch #-}

-- | Does the key @i@ match the prefix @p@ (up to but not including
-- bit @m@)?
match :: Word64 -> Word64 -> Word64 -> Bool
match Word64
i Word64
p Word64
m
  = (Word64 -> Word64 -> Word64
mask Word64
i Word64
m) Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
p
{-# INLINE match #-}


-- | The prefix of key @i@ up to (but not including) the switching
-- bit @m@.
mask :: Key -> Mask -> Prefix
mask :: Word64 -> Word64 -> Word64
mask Word64
i Word64
m
  = Word64 -> Word64 -> Word64
maskW (Word64 -> Word64
natFromInt Word64
i) (Word64 -> Word64
natFromInt Word64
m)
{-# INLINE mask #-}


{--------------------------------------------------------------------
  Big endian operations
--------------------------------------------------------------------}

-- | The prefix of key @i@ up to (but not including) the switching
-- bit @m@.
maskW :: Nat -> Nat -> Prefix
maskW :: Word64 -> Word64 -> Word64
maskW Word64
i Word64
m
  = Word64 -> Word64
intFromNat (Word64
i Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. ((-Word64
m) Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
`xor` Word64
m))
{-# INLINE maskW #-}

-- | Does the left switching bit specify a shorter prefix?
shorter :: Mask -> Mask -> Bool
shorter :: Word64 -> Word64 -> Bool
shorter Word64
m1 Word64
m2
  = (Word64 -> Word64
natFromInt Word64
m1) Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
> (Word64 -> Word64
natFromInt Word64
m2)
{-# INLINE shorter #-}

-- | The first switching bit where the two prefixes disagree.
branchMask :: Prefix -> Prefix -> Mask
branchMask :: Word64 -> Word64 -> Word64
branchMask Word64
p1 Word64
p2
  = Word64 -> Word64
intFromNat (Word64 -> Word64
highestBitMask (Word64 -> Word64
natFromInt Word64
p1 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
`xor` Word64 -> Word64
natFromInt Word64
p2))
{-# INLINE branchMask #-}

{--------------------------------------------------------------------
  Utilities
--------------------------------------------------------------------}

-- | \(O(1)\).  Decompose a map into pieces based on the structure
-- of the underlying tree. This function is useful for consuming a
-- map in parallel.
--
-- No guarantee is made as to the sizes of the pieces; an internal, but
-- deterministic process determines this.  However, it is guaranteed that the
-- pieces returned will be in ascending order (all elements in the first submap
-- less than all elements in the second, and so on).
--
-- Examples:
--
-- > splitRoot (fromList (zip [1..6::Int] ['a'..])) ==
-- >   [fromList [(1,'a'),(2,'b'),(3,'c')],fromList [(4,'d'),(5,'e'),(6,'f')]]
--
-- > splitRoot empty == []
--
--  Note that the current implementation does not return more than two submaps,
--  but you should not depend on this behaviour because it can change in the
--  future without notice.
splitRoot :: Word64Map a -> [Word64Map a]
splitRoot :: forall a. Word64Map a -> [Word64Map a]
splitRoot Word64Map a
orig =
  case Word64Map a
orig of
    Word64Map a
Nil -> []
    x :: Word64Map a
x@(Tip Word64
_ a
_) -> [Word64Map a
x]
    Bin Word64
_ Word64
m Word64Map a
l Word64Map a
r | Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
0 -> [Word64Map a
r, Word64Map a
l]
                | Bool
otherwise -> [Word64Map a
l, Word64Map a
r]
{-# INLINE splitRoot #-}


{--------------------------------------------------------------------
  Debugging
--------------------------------------------------------------------}

-- | \(O(n \min(n,W))\). Show the tree that implements the map. The tree is shown
-- in a compressed, hanging format.
showTree :: Show a => Word64Map a -> String
showTree :: forall a. Show a => Word64Map a -> [Char]
showTree Word64Map a
s
  = Bool -> Bool -> Word64Map a -> [Char]
forall a. Show a => Bool -> Bool -> Word64Map a -> [Char]
showTreeWith Bool
True Bool
False Word64Map a
s


{- | \(O(n \min(n,W))\). The expression (@'showTreeWith' hang wide map@) shows
 the tree that implements the map. If @hang@ is
 'True', a /hanging/ tree is shown otherwise a rotated tree is shown. If
 @wide@ is 'True', an extra wide version is shown.
-}
showTreeWith :: Show a => Bool -> Bool -> Word64Map a -> String
showTreeWith :: forall a. Show a => Bool -> Bool -> Word64Map a -> [Char]
showTreeWith Bool
hang Bool
wide Word64Map a
t
  | Bool
hang      = (Bool -> [[Char]] -> Word64Map a -> [Char] -> [Char]
forall a.
Show a =>
Bool -> [[Char]] -> Word64Map a -> [Char] -> [Char]
showsTreeHang Bool
wide [] Word64Map a
t) [Char]
""
  | Bool
otherwise = (Bool -> [[Char]] -> [[Char]] -> Word64Map a -> [Char] -> [Char]
forall a.
Show a =>
Bool -> [[Char]] -> [[Char]] -> Word64Map a -> [Char] -> [Char]
showsTree Bool
wide [] [] Word64Map a
t) [Char]
""

showsTree :: Show a => Bool -> [String] -> [String] -> Word64Map a -> ShowS
showsTree :: forall a.
Show a =>
Bool -> [[Char]] -> [[Char]] -> Word64Map a -> [Char] -> [Char]
showsTree Bool
wide [[Char]]
lbars [[Char]]
rbars Word64Map a
t = case Word64Map a
t of
  Bin Word64
p Word64
m Word64Map a
l Word64Map a
r ->
    Bool -> [[Char]] -> [[Char]] -> Word64Map a -> [Char] -> [Char]
forall a.
Show a =>
Bool -> [[Char]] -> [[Char]] -> Word64Map a -> [Char] -> [Char]
showsTree Bool
wide ([[Char]] -> [[Char]]
withBar [[Char]]
rbars) ([[Char]] -> [[Char]]
withEmpty [[Char]]
rbars) Word64Map a
r ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    Bool -> [[Char]] -> [Char] -> [Char]
showWide Bool
wide [[Char]]
rbars ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    [[Char]] -> [Char] -> [Char]
showsBars [[Char]]
lbars ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> [Char]
showString (Word64 -> Word64 -> [Char]
showBin Word64
p Word64
m) ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> [Char]
showString [Char]
"\n" ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    Bool -> [[Char]] -> [Char] -> [Char]
showWide Bool
wide [[Char]]
lbars ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    Bool -> [[Char]] -> [[Char]] -> Word64Map a -> [Char] -> [Char]
forall a.
Show a =>
Bool -> [[Char]] -> [[Char]] -> Word64Map a -> [Char] -> [Char]
showsTree Bool
wide ([[Char]] -> [[Char]]
withEmpty [[Char]]
lbars) ([[Char]] -> [[Char]]
withBar [[Char]]
lbars) Word64Map a
l
  Tip Word64
k a
x ->
    [[Char]] -> [Char] -> [Char]
showsBars [[Char]]
lbars ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    [Char] -> [Char] -> [Char]
showString [Char]
" " ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> [Char] -> [Char]
forall a. Show a => a -> [Char] -> [Char]
shows Word64
k ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> [Char]
showString [Char]
":=" ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [Char] -> [Char]
forall a. Show a => a -> [Char] -> [Char]
shows a
x ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> [Char]
showString [Char]
"\n"
  Word64Map a
Nil -> [[Char]] -> [Char] -> [Char]
showsBars [[Char]]
lbars ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> [Char]
showString [Char]
"|\n"

showsTreeHang :: Show a => Bool -> [String] -> Word64Map a -> ShowS
showsTreeHang :: forall a.
Show a =>
Bool -> [[Char]] -> Word64Map a -> [Char] -> [Char]
showsTreeHang Bool
wide [[Char]]
bars Word64Map a
t = case Word64Map a
t of
  Bin Word64
p Word64
m Word64Map a
l Word64Map a
r ->
    [[Char]] -> [Char] -> [Char]
showsBars [[Char]]
bars ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> [Char]
showString (Word64 -> Word64 -> [Char]
showBin Word64
p Word64
m) ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> [Char]
showString [Char]
"\n" ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    Bool -> [[Char]] -> [Char] -> [Char]
showWide Bool
wide [[Char]]
bars ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    Bool -> [[Char]] -> Word64Map a -> [Char] -> [Char]
forall a.
Show a =>
Bool -> [[Char]] -> Word64Map a -> [Char] -> [Char]
showsTreeHang Bool
wide ([[Char]] -> [[Char]]
withBar [[Char]]
bars) Word64Map a
l ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    Bool -> [[Char]] -> [Char] -> [Char]
showWide Bool
wide [[Char]]
bars ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    Bool -> [[Char]] -> Word64Map a -> [Char] -> [Char]
forall a.
Show a =>
Bool -> [[Char]] -> Word64Map a -> [Char] -> [Char]
showsTreeHang Bool
wide ([[Char]] -> [[Char]]
withEmpty [[Char]]
bars) Word64Map a
r
  Tip Word64
k a
x ->
    [[Char]] -> [Char] -> [Char]
showsBars [[Char]]
bars ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    [Char] -> [Char] -> [Char]
showString [Char]
" " ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> [Char] -> [Char]
forall a. Show a => a -> [Char] -> [Char]
shows Word64
k ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> [Char]
showString [Char]
":=" ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [Char] -> [Char]
forall a. Show a => a -> [Char] -> [Char]
shows a
x ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> [Char]
showString [Char]
"\n"
  Word64Map a
Nil -> [[Char]] -> [Char] -> [Char]
showsBars [[Char]]
bars ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> [Char]
showString [Char]
"|\n"

showBin :: Prefix -> Mask -> String
showBin :: Word64 -> Word64 -> [Char]
showBin Word64
_ Word64
_
  = [Char]
"*" -- ++ show (p,m)

showWide :: Bool -> [String] -> String -> String
showWide :: Bool -> [[Char]] -> [Char] -> [Char]
showWide Bool
wide [[Char]]
bars
  | Bool
wide      = [Char] -> [Char] -> [Char]
showString ([[Char]] -> [Char]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[Char]] -> [[Char]]
forall a. [a] -> [a]
reverse [[Char]]
bars)) ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> [Char]
showString [Char]
"|\n"
  | Bool
otherwise = [Char] -> [Char]
forall a. a -> a
id

showsBars :: [String] -> ShowS
showsBars :: [[Char]] -> [Char] -> [Char]
showsBars [[Char]]
bars
  = case [[Char]]
bars of
      [] -> [Char] -> [Char]
forall a. a -> a
id
      [Char]
_ : [[Char]]
tl -> [Char] -> [Char] -> [Char]
showString ([[Char]] -> [Char]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[Char]] -> [[Char]]
forall a. [a] -> [a]
reverse [[Char]]
tl)) ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> [Char]
showString [Char]
node

node :: String
node :: [Char]
node = [Char]
"+--"

withBar, withEmpty :: [String] -> [String]
withBar :: [[Char]] -> [[Char]]
withBar [[Char]]
bars   = [Char]
"|  "[Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
:[[Char]]
bars
withEmpty :: [[Char]] -> [[Char]]
withEmpty [[Char]]
bars = [Char]
"   "[Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
:[[Char]]
bars