-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Deeply-nested, multiple key type maps.
--
-- Please see the README at https://github.com/mixphix/deep-map
@package deep-map
@version 0.3.2
-- | This module defines a deeply-nested, semigroup-lifting map datatype,
-- whose keys are indexed by a type-level list.
--
-- Its interface is intended to mimic that of Map from the
-- containers package, with additional convenience functions for
-- working with deep nestings.
module Data.Map.Deep
data DeepMap (ks :: [Type]) (v :: Type) :: Type
[Core] :: v -> DeepMap '[] v
[Wrap] :: Ord k => Map k (DeepMap ks v) -> DeepMap (k ': ks) v
-- | Apply a two-argument function through a shallow DeepMap, akin
-- to liftA2.
onCore2 :: (v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x
-- | Apply a two-argument Map function through a deep
-- DeepMap, akin to liftA2.
onWrap2 :: (Map k (DeepMap ks v) -> Map k (DeepMap ls w) -> Map k (DeepMap ms x)) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ms) x
-- | O(1). The empty, arbitrary positive-depth DeepMap.
empty :: Ord k => DeepMap (k ': ks) v
-- | O(1). A depth-1 DeepMap with a single key/value pair.
singleton :: Ord k => k -> v -> DeepMap '[k] v
deep :: Deep ks -> v -> DeepMap ks v
-- | A singleton DeepMap. Use with (@|) to create deep
-- nestings:
--
--
-- >>> "Outer" @> 0 @| [5]
-- Wrap {fromList [("Outer",Wrap {fromList [(0,Core [5])]})]}
--
(@>) :: Ord k => k -> DeepMap ks v -> DeepMap (k ': ks) v
infixr 6 @>
-- | Infix synonym for singleton. Use with (@>) to create
-- deep nestings:
--
--
-- >>> "Outer" @> 0 @| [5]
-- Wrap {fromList [("Outer",Wrap {fromList [(0,Core [5])]})]}
--
(@|) :: Ord k => k -> v -> DeepMap '[k] v
infixr 6 @|
-- | O(n log n). Build a deeper DeepMap from a list of
-- key/DeepMap pairs. If the list contains more than one value for
-- the same key, the values are combined using (<>).
fromList :: (Ord k, Semigroup (DeepMap ks v)) => [(k, DeepMap ks v)] -> DeepMap (k ': ks) v
fromListDeep :: Monoid (DeepMap ks v) => [(Deep ks, v)] -> DeepMap ks v
-- | O(n log n). Build a depth-1 DeepMap from a list of
-- key/value pairs. If the list contains more than one value for the same
-- key, the values are combined using (<>).
fromList1 :: (Ord k, Semigroup v) => [(k, v)] -> DeepMap '[k] v
-- | O(n log n). Build a depth-2 DeepMap from a list of keys
-- and values. If the list contains more than one value for the same
-- keys, the values are combined using (<>).
fromList2 :: (Ord k0, Ord k1, Semigroup v) => [(k0, k1, v)] -> DeepMap '[k0, k1] v
-- | O(n log n). Build a depth-3 DeepMap from a list of keys
-- and values. If the list contains more than one value for the same
-- keys, the values are combined using (<>).
fromList3 :: (Ord k0, Ord k1, Ord k2, Semigroup v) => [(k0, k1, k2, v)] -> DeepMap '[k0, k1, k2] v
-- | O(n log n). Build a depth-4 DeepMap from a list of keys
-- and values. If the list contains more than one value for the same
-- keys, the values are combined using (<>).
fromList4 :: (Ord k0, Ord k1, Ord k2, Ord k3, Semigroup v) => [(k0, k1, k2, k3, v)] -> DeepMap '[k0, k1, k2, k3] v
-- | O(n log n). Build a depth-5 DeepMap from a list of keys
-- and values. If the list contains more than one value for the same
-- keys, the values are combined using (<>).
fromList5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4, Semigroup v) => [(k0, k1, k2, k3, k4, v)] -> DeepMap '[k0, k1, k2, k3, k4] v
-- | O(n log n). Build a deeper DeepMap from a list of
-- key/DeepMap pairs using the provided combining function.
fromListWith :: Ord k => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> [(k, DeepMap ks v)] -> DeepMap (k ': ks) v
-- | O(n log n). Build a depth-1 DeepMap from a list of
-- key/value pairs using the provided combining function.
fromListWith1 :: Ord k => (v -> v -> v) -> [(k, v)] -> DeepMap '[k] v
-- | O(n log n). Build a deeper DeepMap from a list of
-- key/DeepMap pairs with a combining function.
fromListWithKey :: Ord k => (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> [(k, DeepMap ks v)] -> DeepMap (k ': ks) v
-- | O(n log n). Build a depth-1 DeepMap from a list of
-- key/value pairs with a combining function.
fromListWithKey1 :: Ord k => (k -> v -> v -> v) -> [(k, v)] -> DeepMap '[k] v
-- | O(n log n). Build a depth-2 DeepMap from a list of keys
-- and values with a combining function.
fromListWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v -> v) -> [(k0, k1, v)] -> DeepMap '[k0, k1] v
-- | O(n log n). Build a depth-3 DeepMap from a list of keys
-- and values with a combining function.
fromListWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> v -> v) -> [(k0, k1, k2, v)] -> DeepMap '[k0, k1, k2] v
-- | O(n log n). Build a depth-3 DeepMap from a list of keys
-- and values with a combining function.
fromListWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> v -> v) -> [(k0, k1, k2, k3, v)] -> DeepMap '[k0, k1, k2, k3] v
-- | O(n log n). Build a depth-3 DeepMap from a list of keys
-- and values with a combining function.
fromListWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v) -> [(k0, k1, k2, k3, k4, v)] -> DeepMap '[k0, k1, k2, k3, k4] v
-- | Half of the isomorphism of a depth-1 DeepMap to a Map.
-- See also fromMap.
toMap :: DeepMap '[k] v -> Map k v
-- | Half of the isomorphism of a depth-1 DeepMap to a Map.
-- See also toMap.
fromMap :: Ord k => Map k v -> DeepMap '[k] v
-- | O(log n). Insert a key/DeepMap pair into the
-- DeepMap. If the key is already present in the map, the
-- associated value is combined with the new value as old
-- <> new. The overwriting behaviour from
-- containers can be recovered by wrapping values in Last
-- or by using overwrite.
insert :: (Ord k, Semigroup (DeepMap ks v)) => k -> DeepMap ks v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
insertDeep :: (Ord k, Semigroup (DeepMap ks v)) => Deep (k ': ks) -> v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(log n). Insert a new key and value into a depth-1
-- DeepMap. If the key is already present in the map, the
-- associated value is combined with the new value as old
-- <> new. The overwriting behaviour from
-- containers can be recovered by wrapping values in Last
-- or by using overwrite1.
insert1 :: (Ord k, Semigroup v) => k -> v -> DeepMap '[k] v -> DeepMap '[k] v
-- | O(log n). Insert a new key-chain/value pair into a depth-2
-- DeepMap. If the key is already present in the map, the
-- associated value is combined with the new value as old
-- <> new. The overwriting behaviour from
-- containers can be recovered by wrapping values in Last
-- or by using overwrite2.
insert2 :: (Ord k0, Ord k1, Semigroup v) => k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
-- | O(log n). Insert a new key-chain/value pair into a depth-3
-- DeepMap. If the key is already present in the map, the
-- associated value is combined with the new value as old
-- <> new. so the overwriting behaviour from
-- containers can be recovered by wrapping values in Last
-- or by using overwrite3.
insert3 :: (Ord k0, Ord k1, Ord k2, Semigroup v) => k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
-- | O(log n). Insert a new key-chain/value pair into a depth-4
-- DeepMap. If the key is already present in the map, the
-- associated value is combined with the new value as old
-- <> new. so the overwriting behaviour from
-- containers can be recovered by wrapping values in Last
-- or by using overwrite4.
insert4 :: (Ord k0, Ord k1, Ord k2, Ord k3, Semigroup v) => k0 -> k1 -> k2 -> k3 -> v -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
-- | O(log n). Insert a new key-chain/value pair into a depth-5
-- DeepMap. If the key is already present in the map, the
-- associated value is combined with the new value as old
-- <> new. so the overwriting behaviour from
-- containers can be recovered by wrapping values in Last
-- or by using overwrite5.
insert5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4, Semigroup v) => k0 -> k1 -> k2 -> k3 -> k4 -> v -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
-- | O(log n). Insert with a function, combining new value and old
-- value using the supplied function.
--
-- insertWith (~~) k new m will insert new at
-- k if there is no value present, or overwrite with old ~~
-- new if there was already a value old at k.
insertWith :: Ord k => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> k -> DeepMap ks v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(log n). Insert with a function, combining new value and old
-- value using the supplied function.
--
-- insertWith1 (~~) k new m will insert new at
-- k if there is no value present, or overwrite with old ~~
-- new if there was already a value old at k.
insertWith1 :: Ord k => (v -> v -> v) -> k -> v -> DeepMap '[k] v -> DeepMap '[k] v
-- | O(log n). Insert with a function, combining new value and old
-- value using the supplied function.
insertWith2 :: (Ord k0, Ord k1) => (v -> v -> v) -> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
-- | O(log n). Insert with a function, combining new value and old
-- value using the supplied function.
insertWith3 :: (Ord k0, Ord k1, Ord k2) => (v -> v -> v) -> k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
-- | O(log n). Insert with a function, combining new value and old
-- value using the supplied function.
insertWith4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (v -> v -> v) -> k0 -> k1 -> k2 -> k3 -> v -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
-- | O(log n). Insert with a function, combining new value and old
-- value using the supplied function.
insertWith5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (v -> v -> v) -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
-- | O(log n). Insert with a function, combining new value and old
-- value using the supplied function.
--
-- insertWithKey f k new m will insert new at
-- k if there is no value present, or f k old new if
-- there was already a value old at k. The key passed
-- to f is the one passed to insertWithKey, not the one
-- present in the map.
insertWithKey :: Ord k => (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> k -> DeepMap ks v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(log n). Insert with a function, combining new value and old
-- value using the supplied function with access to the given keys.
insertWithKey1 :: Ord k => (k -> v -> v -> v) -> k -> v -> DeepMap '[k] v -> DeepMap '[k] v
-- | O(log n). Insert with a function, combining new value and old
-- value using the supplied function with access to the given keys.
insertWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v -> v) -> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
-- | O(log n). Insert with a function, combining new value and old
-- value using the supplied function with access to the given keys.
insertWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> v -> v) -> k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
-- | O(log n). Insert with a function, combining new value and old
-- value using the supplied function with access to the given keys.
insertWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> v -> v) -> k0 -> k1 -> k2 -> k3 -> v -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
-- | O(log n). Insert with a function, combining new value and old
-- value using the supplied function with access to the given keys.
insertWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v) -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
-- | O(log n). Combines insertion and retrieval.
--
--
-- 'insertLookupWithKey' f k new == 'lookup' k &&& 'insertWithKey' f k new
--
insertLookupWithKey :: Ord k => (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> k -> DeepMap ks v -> DeepMap (k ': ks) v -> (Maybe (DeepMap ks v), DeepMap (k ': ks) v)
-- | O(log n). Combines insertion and retrieval.
insertLookupWithKey1 :: Ord k => (k -> v -> v -> v) -> k -> v -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v)
-- | O(log n). Combines insertion and retrieval.
insertLookupWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v -> v) -> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> (Maybe v, DeepMap '[k0, k1] v)
-- | O(log n). Combines insertion and retrieval.
insertLookupWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> v -> v) -> k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> (Maybe v, DeepMap '[k0, k1, k2] v)
-- | O(log n). Combines insertion and retrieval.
insertLookupWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> v -> v) -> k0 -> k1 -> k2 -> k3 -> v -> DeepMap '[k0, k1, k2, k3] v -> (Maybe v, DeepMap '[k0, k1, k2, k3] v)
-- | O(log n). Combines insertion and retrieval.
insertLookupWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v) -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> DeepMap '[k0, k1, k2, k3, k4] v -> (Maybe v, DeepMap '[k0, k1, k2, k3, k4] v)
-- | O(log n). Insert a new key/DeepMap pair into the
-- DeepMap. If the key is already present in the map, the
-- associated value is replaced by the new value.
overwrite :: Ord k => k -> DeepMap ks v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
overwriteDeep :: (Ord k, Semigroup (DeepMap ks v)) => Deep (k ': ks) -> v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(log n). Insert a new key/value pair into a depth-1
-- DeepMap. If the key is already present in the map, the
-- associated value is replaced by the new value.
overwrite1 :: Ord k => k -> v -> DeepMap '[k] v -> DeepMap '[k] v
-- | O(log n). Insert a new key-chain/value pair into a depth-2
-- DeepMap. If the key is already present in the map, the
-- associated value is replaced by the new value.
overwrite2 :: (Ord k0, Ord k1) => k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
-- | O(log n). Insert a new key-chain/value pair into a depth-3
-- DeepMap. If the key is already present in the map, the
-- associated value is replaced by the new value.
overwrite3 :: (Ord k0, Ord k1, Ord k2) => k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
-- | O(log n). Insert a new key-chain/value pair into a depth-4
-- DeepMap. If the key is already present in the map, the
-- associated value is replaced by the new value.
overwrite4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => k0 -> k1 -> k2 -> k3 -> v -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
-- | O(log n). Insert a new key-chain/value pair into a depth-5
-- DeepMap. If the key is already present in the map, the
-- associated value is replaced by the new value.
overwrite5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => k0 -> k1 -> k2 -> k3 -> k4 -> v -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
-- | O(log n). Combines replacement and retrieval.
overwriteLookup :: Ord k => k -> DeepMap ks v -> DeepMap (k ': ks) v -> (Maybe (DeepMap ks v), DeepMap (k ': ks) v)
overwriteLookupDeep :: (Ord k, Semigroup (DeepMap ks v)) => Deep (k ': ks) -> v -> DeepMap (k ': ks) v -> (Maybe (DeepMap ks v), DeepMap (k ': ks) v)
-- | O(log n). Combines replacement and retrieval at depth 1.
overwriteLookup1 :: Ord k => k -> v -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v)
-- | O(log n). Combines replacement and retrieval at depth 2.
overwriteLookup2 :: (Ord k0, Ord k1) => k0 -> k1 -> v -> DeepMap '[k0, k1] v -> (Maybe v, DeepMap '[k0, k1] v)
-- | O(log n). Combines replacement and retrieval at depth 3.
overwriteLookup3 :: (Ord k0, Ord k1, Ord k2) => k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> (Maybe v, DeepMap '[k0, k1, k2] v)
-- | O(log n). Combines replacement and retrieval at depth 4.
overwriteLookup4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => k0 -> k1 -> k2 -> k3 -> v -> DeepMap '[k0, k1, k2, k3] v -> (Maybe v, DeepMap '[k0, k1, k2, k3] v)
-- | O(log n). Combines replacement and retrieval at depth 5.
overwriteLookup5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => k0 -> k1 -> k2 -> k3 -> k4 -> v -> DeepMap '[k0, k1, k2, k3, k4] v -> (Maybe v, DeepMap '[k0, k1, k2, k3, k4] v)
-- | O(log n). Delete a key and its value from the map, or do
-- nothing if the key is missing.
delete :: Ord k => k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
deleteDeep :: Monoid v => Deep ks -> DeepMap ks v -> DeepMap ks v
-- | O(log n). Delete a key and its value from the map, or do
-- nothing if the key is missing.
delete1 :: Ord k => k -> DeepMap '[k] v -> DeepMap '[k] v
-- | O(log n). Delete a key and its value from the map, or do
-- nothing if the key is missing.
delete2 :: (Ord k0, Ord k1) => k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
-- | O(log n). Delete a key and its value from the map, or do
-- nothing if the key is missing.
delete3 :: (Ord k0, Ord k1, Ord k2) => k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
-- | O(log n). Delete a key and its value from the map, or do
-- nothing if the key is missing.
delete4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
-- | O(log n). Delete a key and its value from the map, or do
-- nothing if the key is missing.
delete5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
-- | O(log n). Change a value at a specific key with the result of
-- the provided function, or do nothing if the key is missing.
adjust :: Ord k => (DeepMap ks v -> DeepMap ks v) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
adjustDeep :: (v -> v) -> Deep ks -> DeepMap ks v -> DeepMap ks v
-- | O(log n). Change a value at a specific key with the result of
-- the provided function, or do nothing if the key is missing.
adjust1 :: Ord k => (v -> v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
-- | O(log n). Change a value at specific keys with the result of
-- the provided function, or do nothing if the key is missing.
adjust2 :: (Ord k0, Ord k1) => (v -> v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
-- | O(log n). Change a value at specific keys with the result of
-- the provided function, or do nothing if the key is missing.
adjust3 :: (Ord k0, Ord k1, Ord k2) => (v -> v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
-- | O(log n). Change a value at specific keys with the result of
-- the provided function, or do nothing if the key is missing.
adjust4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (v -> v) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
-- | O(log n). Change a value at specific keys with the result of
-- the provided function, or do nothing if the key is missing.
adjust5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (v -> v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
-- | O(log n). Change a value at a specific key with access to the
-- key itself, or do nothing if the key is missing.
adjustWithKey :: Ord k => (k -> DeepMap ks v -> DeepMap ks v) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(log n). Change a value at a specific key with access to the
-- key itself, or do nothing if the key is missing.
adjustWithKey1 :: Ord k => (k -> v -> v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
-- | O(log n). Change a value at a specific key with access to the
-- key itself, or do nothing if the key is missing.
adjustWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
-- | O(log n). Change a value at a specific key with access to the
-- key itself, or do nothing if the key is missing.
adjustWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
-- | O(log n). Change a value at a specific key with access to the
-- key itself, or do nothing if the key is missing.
adjustWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> v) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
-- | O(log n). Change a value at a specific key with access to the
-- key itself, or do nothing if the key is missing.
adjustWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
-- | O(log n). Change a DeepMap at a specific key. If the
-- function evaluates to Nothing, the key and submap are removed.
-- If the key is missing, do nothing.
update :: Ord k => (DeepMap ks v -> Maybe (DeepMap ks v)) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
updateDeep :: Monoid v => (v -> Maybe v) -> Deep ks -> DeepMap ks v -> DeepMap ks v
-- | O(log n). Change a DeepMap at a specific key. If the
-- function evaluates to Nothing, the key and submap are removed.
-- If the key is missing, do nothing.
update1 :: Ord k => (v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
-- | O(log n). Change a DeepMap at a specific key. If the
-- function evaluates to Nothing, the key and submap are removed.
-- If the key is missing, do nothing.
update2 :: (Ord k0, Ord k1) => (v -> Maybe v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
-- | O(log n). Change a DeepMap at a specific key. If the
-- function evaluates to Nothing, the key and submap are removed.
-- If the key is missing, do nothing.
update3 :: (Ord k0, Ord k1, Ord k2) => (v -> Maybe v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
-- | O(log n). Change a DeepMap at a specific key. If the
-- function evaluates to Nothing, the key and submap are removed.
-- If the key is missing, do nothing.
update4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
-- | O(log n). Change a DeepMap at a specific key. If the
-- function evaluates to Nothing, the key and submap are removed.
-- If the key is missing, do nothing.
update5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
-- | O(log n). Change a DeepMap at a specific key, with
-- access to the key itself. If the function evaluates to Nothing,
-- the key and submap are removed. If the key is missing, do nothing.
updateWithKey :: Ord k => (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(log n). Change a value at a specific key with access to the
-- key itself. If the function evaluates to Nothing, the key and
-- value are removed. If the key is missing, do nothing.
updateWithKey1 :: Ord k => (k -> v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
-- | O(log n). Change a value at specific keys with access to the
-- keys themselves. If the function evaluates to Nothing, the keys
-- and value are removed. If the keys are missing, do nothing.
updateWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> Maybe v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
-- | O(log n). Change a value at specific keys with access to the
-- keys themselves. If the function evaluates to Nothing, the keys
-- and value are removed. If the keys are missing, do nothing.
updateWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> Maybe v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
-- | O(log n). Change a value at specific keys with access to the
-- keys themselves. If the function evaluates to Nothing, the keys
-- and value are removed. If the keys are missing, do nothing.
updateWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
-- | O(log n). Change a value at specific keys with access to the
-- keys themselves. If the function evaluates to Nothing, the keys
-- and value are removed. If the keys are missing, do nothing.
updateWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
-- | O(log n). Combines change and retrieval.
--
--
-- 'updateLookupWithKey' f k == 'lookup' k &&& 'updateWithKey' f k
--
updateLookupWithKey :: Ord k => (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> k -> DeepMap (k ': ks) v -> (Maybe (DeepMap ks v), DeepMap (k ': ks) v)
-- | O(log n). Combines change and retrieval.
updateLookupWithKey1 :: Ord k => (k -> v -> Maybe v) -> k -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v)
-- | O(log n). Combines change and retrieval.
updateLookupWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> Maybe v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> (Maybe v, DeepMap '[k0, k1] v)
-- | O(log n). Combines change and retrieval.
updateLookupWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> Maybe v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> (Maybe v, DeepMap '[k0, k1, k2] v)
-- | O(log n). Combines change and retrieval.
updateLookupWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> (Maybe v, DeepMap '[k0, k1, k2, k3] v)
-- | O(log n). Combines change and retrieval.
updateLookupWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> (Maybe v, DeepMap '[k0, k1, k2, k3, k4] v)
-- | O(log n). Can be used to insert, overwrite,
-- delete, or update a value.
alter :: Ord k => (Maybe (DeepMap ks v) -> Maybe (DeepMap ks v)) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
alterDeep :: Monoid v => (Maybe v -> Maybe v) -> Deep ks -> DeepMap ks v -> DeepMap ks v
-- | O(log n). Can be used to insert, overwrite,
-- delete, or update a value.
alter1 :: Ord k => (Maybe v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
-- | O(log n). Can be used to insert, overwrite,
-- delete, or update a value.
alter2 :: (Ord k0, Ord k1) => (Maybe v -> Maybe v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
-- | O(log n). Can be used to insert, overwrite,
-- delete, or update a value.
alter3 :: (Ord k0, Ord k1, Ord k2) => (Maybe v -> Maybe v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
-- | O(log n). Can be used to insert, overwrite,
-- delete, or update a value.
alter4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (Maybe v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
-- | O(log n). Can be used to insert, overwrite,
-- delete, or update a value.
alter5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (Maybe v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
alterF :: (Functor f, Ord k) => (Maybe (DeepMap ks v) -> f (Maybe (DeepMap ks v))) -> k -> DeepMap (k ': ks) v -> f (DeepMap (k ': ks) v)
alterFDeep :: (Monoid v, Applicative f) => (Maybe v -> f (Maybe v)) -> Deep ks -> DeepMap ks v -> f (DeepMap ks v)
alterF1 :: (Functor f, Ord k) => (Maybe v -> f (Maybe v)) -> k -> DeepMap '[k] v -> f (DeepMap '[k] v)
alterF2 :: (Functor f, Ord k0, Ord k1) => (Maybe v -> f (Maybe v)) -> k0 -> k1 -> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] v)
alterF3 :: (Functor f, Ord k0, Ord k1, Ord k2) => (Maybe v -> f (Maybe v)) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] v)
alterF4 :: (Functor f, Ord k0, Ord k1, Ord k2, Ord k3) => (Maybe v -> f (Maybe v)) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] v)
alterF5 :: (Functor f, Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (Maybe v -> f (Maybe v)) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> f (DeepMap '[k0, k1, k2, k3, k4] v)
-- | O(log n). Lookup the value at a key.
lookup :: Ord k => k -> DeepMap (k ': ks) v -> Maybe (DeepMap ks v)
lookupDeep :: Deep ks -> DeepMap ks v -> Maybe v
-- | O(log n). A flipped, infix variant of lookup.
(@?) :: Ord k => DeepMap (k ': ks) v -> k -> Maybe (DeepMap ks v)
-- | O(log n). A flipped, infix variant of lookup1.
(@?|) :: Ord k => DeepMap '[k] v -> k -> Maybe v
-- | O(log n). Facilitates chaining of lookups. For m :: DeepMap
-- '[k0, k1, k2] v,
--
--
-- >>> m @? k0 @?? k1 @??| k2 == (m @? k0) >>= (@? k1) >>= (@?| k2)
--
(@??) :: Ord k => Maybe (DeepMap (k ': ks) v) -> k -> Maybe (DeepMap ks v)
-- | O(log n). Facilitates chaining of lookups. For m :: DeepMap
-- '[k0, k1, k2] v,
--
--
-- >>> m @? k0 @?? k1 @??| k2 == (m @? k0) >>= (@? k1) >>= (@?| k2)
--
(@??|) :: Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
-- | O(log n). A version of (@?) that returns mempty
-- when the element cannot be found.
(@!) :: (Ord k, Monoid (DeepMap ks v)) => DeepMap (k ': ks) v -> k -> DeepMap ks v
-- | O(log n). A version of (@?|) that returns mempty
-- when the element cannot be found.
(@!|) :: (Ord k, Monoid v) => DeepMap '[k] v -> k -> v
-- | O(log n). Lookup the DeepMap at a key, with a default if
-- the key is missing.
findWithDefault :: Ord k => DeepMap ks v -> k -> DeepMap (k ': ks) v -> DeepMap ks v
-- | O(log n). Lookup the value at a key, with a default if the key
-- is missing.
findWithDefault1 :: Ord k => v -> k -> DeepMap '[k] v -> v
-- | O(log n). Lookup the value at a key, with a default if the key
-- is missing.
findWithDefault2 :: (Ord k0, Ord k1) => v -> k0 -> k1 -> DeepMap '[k0, k1] v -> v
-- | O(log n). Lookup the value at a key, with a default if the key
-- is missing.
findWithDefault3 :: (Ord k0, Ord k1, Ord k2) => v -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> v
-- | O(log n). Lookup the value at a key, with a default if the key
-- is missing.
findWithDefault4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => v -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> v
-- | O(log n). Lookup the value at a key, with a default if the key
-- is missing.
findWithDefault5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => v -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> v
-- | O(log n). Is the key a member of the map? See also
-- notMember.
member :: Ord k => k -> DeepMap (k ': ks) v -> Bool
-- | O(log n). Is the key missing from the map? See also
-- member.
notMember :: Ord k => k -> DeepMap (k ': ks) v -> Bool
-- | Find the next smallest key to the given one, and return its key/value
-- pair.
lookupLT :: Ord k => k -> DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)
-- | Find the next largest key to the given one, and return its key/value
-- pair.
lookupGT :: Ord k => k -> DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)
-- | Find the largest key up to the given one, and return its key/value
-- pair.
lookupLE :: Ord k => k -> DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)
-- | Find the smallest key down to the given one, and return its key/value
-- pair.
lookupGE :: Ord k => k -> DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)
-- | O(1). Is the DeepMap empty?
null :: DeepMap (k ': ks) v -> Bool
-- | O(1). The number of outermost keys in the DeepMap.
size :: DeepMap (k ': ks) v -> Int
-- | O(m log(n / m + 1)), m <= n. Join two DeepMaps
-- together using (<>) to combine the values of duplicate
-- keys.
--
-- To retain Map's left-biased functionality, use
-- unionWith const.
union :: (Ord k, Semigroup (DeepMap ks v)) => DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(m log(n / m + 1)), m <= n. Join two DeepMaps with a
-- combining function.
unionWith :: Ord k => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(m log(n / m + 1)), m <= n. Join two DeepMaps with a
-- combining function.
unionWith1 :: Ord k => (v -> v -> v) -> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
-- | O(m log(n / m + 1)), m <= n. Join two DeepMaps with a
-- combining function.
unionWith2 :: (Ord k0, Ord k1) => (v -> v -> v) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
-- | O(m log(n / m + 1)), m <= n. Join two DeepMaps with a
-- combining function.
unionWith3 :: (Ord k0, Ord k1, Ord k2) => (v -> v -> v) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
-- | O(m log(n / m + 1)), m <= n. Join two DeepMaps with a
-- combining function.
unionWith4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (v -> v -> v) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
-- | O(m log(n / m + 1)), m <= n. Join two DeepMaps with a
-- combining function.
unionWith5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (v -> v -> v) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
-- | O(m log(n / m + 1)), m <= n. Join two maps with a combining
-- function with access to the keys.
unionWithKey :: Ord k => (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(m log(n / m + 1)), m <= n. Join two DeepMaps with a
-- combining function with access to the keys.
unionWithKey1 :: Ord k => (k -> v -> v -> v) -> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
-- | O(m log(n / m + 1)), m <= n. Join two DeepMaps with a
-- combining function with access to the keys.
unionWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v -> v) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
-- | O(m log(n / m + 1)), m <= n. Join two DeepMaps with a
-- combining function with access to the keys.
unionWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> v -> v) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
-- | O(m log(n / m + 1)), m <= n. Join two DeepMaps with a
-- combining function with access to the keys.
unionWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> v -> v) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
-- | O(m log(n / m + 1)), m <= n. Join two DeepMaps with a
-- combining function with access to the keys.
unionWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
-- | A synonym for fold. To retain Map's functionality, use
-- unionsWith const.
unions :: (Foldable t, Ord k, Semigroup (DeepMap ks v)) => t (DeepMap (k ': ks) v) -> DeepMap (k ': ks) v
-- | The union of a list of DeepMaps, combining with a specified
-- operation.
unionsWith :: (Foldable t, Ord k) => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> t (DeepMap (k ': ks) v) -> DeepMap (k ': ks) v
-- | The union of a list of DeepMaps, combining with a specified
-- operation.
unionsWith1 :: (Foldable t, Ord k) => (v -> v -> v) -> t (DeepMap '[k] v) -> DeepMap '[k] v
-- | O(m log(n / m + 1)), m <= n. The set-difference of the keys
-- in a DeepMap, keeping the values of the left-hand map.
difference :: Ord k => DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v
-- | Infix synonym for difference.
(\\) :: Ord k => DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v
-- | O(n + m). Difference with a combining function. Deletes keys if
-- the value is Nothing.
differenceWith :: Ord k => (DeepMap ks v -> DeepMap ls w -> Maybe (DeepMap ks v)) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v
-- | O(n + m). Difference with a combining function. Deletes keys if
-- the value is Nothing.
differenceWith1 :: Ord k => (v -> w -> Maybe v) -> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] v
-- | O(n + m). Difference with a combining function. Deletes keys if
-- the value is Nothing.
differenceWithKey :: Ord k => (k -> DeepMap ks v -> DeepMap ls w -> Maybe (DeepMap ks v)) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v
-- | O(n + m). Difference with a combining function. Deletes keys if
-- the value is Nothing.
differenceWithKey1 :: Ord k => (k -> v -> w -> Maybe v) -> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] v
-- | O(m log(n / m + 1)), m <= n. The set-intersection of the
-- keys in a map, keeping the values of the left-hand map.
intersection :: Ord k => DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v
-- | O(m log(n / m + 1)), m <= n. Intersection with a combining
-- function.
intersectionWith :: Ord k => (DeepMap ks v -> DeepMap ls w -> DeepMap ms x) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ms) x
-- | O(m log(n / m + 1)), m <= n. Intersection with a combining
-- function.
intersectionWith1 :: Ord k => (v -> w -> x) -> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] x
-- | O(m log(n / m + 1)), m <= n. Intersection with a combining
-- function.
intersectionWithKey :: Ord k => (k -> DeepMap ks v -> DeepMap ls w -> DeepMap ms x) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ms) x
-- | O(m log(n / m + 1)), m <= n. Intersection with a combining
-- function.
intersectionWithKey1 :: Ord k => (k -> v -> w -> x) -> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] x
-- | O(m log(n / m + 1)), m <= n. Intersection with a combining
-- function.
intersectionWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> w -> x) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] w -> DeepMap '[k0, k1] x
-- | O(m log(n / m + 1)), m <= n. Intersection with a combining
-- function.
intersectionWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> w -> x) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] w -> DeepMap '[k0, k1, k2] x
-- | O(m log(n / m + 1)), m <= n. Intersection with a combining
-- function.
intersectionWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> w -> x) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] w -> DeepMap '[k0, k1, k2, k3] x
-- | O(m log(n / m + 1)), m <= n. Intersection with a combining
-- function.
intersectionWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> w -> x) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] w -> DeepMap '[k0, k1, k2, k3, k4] x
-- | O(n). Strictly more general than fmap in that it may
-- change the types of the inner keys.
mapShallow :: (DeepMap ks v -> DeepMap ls w) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w
-- | O(n). Like mapShallow but the function has access to the
-- outer keys.
mapShallowWithKey :: (k -> DeepMap ks v -> DeepMap ls w) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w
-- | O(n). Like fmap but the function has access to the outer
-- keys.
mapWithKey1 :: (k -> v -> w) -> DeepMap '[k] v -> DeepMap '[k] w
-- | O(n). Like fmap but the function has access to the outer
-- keys.
mapWithKey2 :: (k0 -> k1 -> v -> w) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] w
-- | O(n). Like fmap but the function has access to the outer
-- keys.
mapWithKey3 :: (k0 -> k1 -> k2 -> v -> w) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] w
-- | O(n). Like fmap but the function has access to the outer
-- keys.
mapWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> w) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] w
-- | O(n). Like fmap but the function has access to the outer
-- keys.
mapWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> w) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] w
-- | O(n). Strictly more general than traverse in that it may
-- change the types of the inner keys.
traverseShallow :: Applicative f => (DeepMap ks v -> f (DeepMap ls w)) -> DeepMap (k ': ks) v -> f (DeepMap (k ': ls) w)
-- | O(n). Like traverseShallow but the function has access
-- to the keys.
traverseShallowWithKey :: Applicative f => (k -> DeepMap ks v -> f (DeepMap ls w)) -> DeepMap (k ': ks) v -> f (DeepMap (k ': ls) w)
-- | O(n). Like traverse but the function has access to the
-- keys.
traverseWithKey1 :: Applicative f => (k -> v -> f w) -> DeepMap '[k] v -> f (DeepMap '[k] w)
-- | O(n). Like traverse but the function has access to the
-- keys.
traverseWithKey2 :: Applicative f => (k0 -> k1 -> v -> f w) -> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] w)
-- | O(n). Like traverse but the function has access to the
-- keys.
traverseWithKey3 :: Applicative f => (k0 -> k1 -> k2 -> v -> f w) -> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] w)
-- | O(n). Like traverse but the function has access to the
-- keys.
traverseWithKey4 :: Applicative f => (k0 -> k1 -> k2 -> k3 -> v -> f w) -> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] w)
-- | O(n). Like traverse but the function has access to the
-- keys.
traverseWithKey5 :: Applicative f => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> f w) -> DeepMap '[k0, k1, k2, k3, k4] v -> f (DeepMap '[k0, k1, k2, k3, k4] w)
-- | O(n). Traverse keys/submaps and collect the Just
-- results.
traverseMaybeWithKey :: Applicative f => (k -> DeepMap ks v -> f (Maybe (DeepMap ls w))) -> DeepMap (k ': ks) v -> f (DeepMap (k ': ls) w)
-- | O(n). Traverse keys/values and collect the Just results.
traverseMaybeWithKey1 :: Applicative f => (k -> v -> f (Maybe w)) -> DeepMap '[k] v -> f (DeepMap '[k] w)
-- | O(n). Traverse keys/values and collect the Just results.
traverseMaybeWithKey2 :: Applicative f => (k0 -> k1 -> v -> f (Maybe w)) -> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] w)
-- | O(n). Traverse keys/values and collect the Just results.
traverseMaybeWithKey3 :: Applicative f => (k0 -> k1 -> k2 -> v -> f (Maybe w)) -> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] w)
-- | O(n). Traverse keys/values and collect the Just results.
traverseMaybeWithKey4 :: Applicative f => (k0 -> k1 -> k2 -> k3 -> v -> f (Maybe w)) -> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] w)
-- | O(n). Traverse keys/values and collect the Just results.
traverseMaybeWithKey5 :: Applicative f => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> f (Maybe w)) -> DeepMap '[k0, k1, k2, k3, k4] v -> f (DeepMap '[k0, k1, k2, k3, k4] w)
-- | O(n). Thread an accumulating argument through the
-- DeepMap in ascending order of keys.
mapAccum :: (acc -> DeepMap ks v -> (acc, DeepMap ls w)) -> acc -> DeepMap (k ': ks) v -> (acc, DeepMap (k ': ls) w)
-- | O(n). Thread an accumulating argument through the
-- DeepMap in ascending order of keys.
mapAccum1 :: (acc -> v -> (acc, w)) -> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
-- | O(n). Thread an accumulating argument through the
-- DeepMap in descending order of keys.
mapAccumR :: (acc -> DeepMap ks v -> (acc, DeepMap ls w)) -> acc -> DeepMap (k ': ks) v -> (acc, DeepMap (k ': ls) w)
-- | O(n). Thread an accumulating argument through the
-- DeepMap in descending order of keys.
mapAccumR1 :: (acc -> v -> (acc, w)) -> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
-- | O(n). Like mapAccum but the function has access to the
-- keys.
mapAccumWithKey :: (acc -> k -> DeepMap ks v -> (acc, DeepMap ls w)) -> acc -> DeepMap (k ': ks) v -> (acc, DeepMap (k ': ls) w)
-- | O(n). Like mapAccum but the function has access to the
-- keys.
mapAccumWithKey1 :: (acc -> k -> v -> (acc, w)) -> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
-- | O(n). Like mapAccum but the function has access to the
-- keys.
mapAccumWithKey2 :: (acc -> k0 -> k1 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1] v -> (acc, DeepMap '[k0, k1] w)
-- | O(n). Like mapAccum but the function has access to the
-- keys.
mapAccumWithKey3 :: (acc -> k0 -> k1 -> k2 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2] v -> (acc, DeepMap '[k0, k1, k2] w)
-- | O(n). Like mapAccum but the function has access to the
-- keys.
mapAccumWithKey4 :: (acc -> k0 -> k1 -> k2 -> k3 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2, k3] v -> (acc, DeepMap '[k0, k1, k2, k3] w)
-- | O(n). Like mapAccum but the function has access to the
-- keys.
mapAccumWithKey5 :: (acc -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2, k3, k4] v -> (acc, DeepMap '[k0, k1, k2, k3, k4] w)
-- | O(n). Like mapAccumR but the function has access to the
-- keys.
mapAccumRWithKey :: (acc -> k -> DeepMap ks v -> (acc, DeepMap ls w)) -> acc -> DeepMap (k ': ks) v -> (acc, DeepMap (k ': ls) w)
-- | O(n). Like mapAccumR but the function has access to the
-- keys.
mapAccumRWithKey1 :: (acc -> k -> v -> (acc, w)) -> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
-- | O(n). Like mapAccumR but the function has access to the
-- keys.
mapAccumRWithKey2 :: (acc -> k0 -> k1 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1] v -> (acc, DeepMap '[k0, k1] w)
-- | O(n). Like mapAccumR but the function has access to the
-- keys.
mapAccumRWithKey3 :: (acc -> k0 -> k1 -> k2 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2] v -> (acc, DeepMap '[k0, k1, k2] w)
-- | O(n). Like mapAccumR but the function has access to the
-- keys.
mapAccumRWithKey4 :: (acc -> k0 -> k1 -> k2 -> k3 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2, k3] v -> (acc, DeepMap '[k0, k1, k2, k3] w)
-- | O(n). Like mapAccumR but the function has access to the
-- keys.
mapAccumRWithKey5 :: (acc -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2, k3, k4] v -> (acc, DeepMap '[k0, k1, k2, k3, k4] w)
-- | O(n log n). Map a function over the outer keys of a
-- DeepMap. If the function maps two or more j-keys to
-- the same k-key, the values of the j-keys are
-- combined with (<>).
--
-- To retain Map's greatest-biased functionality, use
-- mapKeysWith const.
mapKeys :: (Ord k, Semigroup (DeepMap ks v)) => (j -> k) -> DeepMap (j ': ks) v -> DeepMap (k ': ks) v
mapKeysDeep :: Monoid (DeepMap ks v) => (Deep js -> Deep ks) -> DeepMap js v -> DeepMap ks v
-- | O(n log n). Map a function over the keys of a DeepMap.
mapKeys1 :: (Ord k, Semigroup v) => (j -> k) -> DeepMap '[j] v -> DeepMap '[k] v
-- | O(n log n). Map a function over the keys of a DeepMap.
mapKeys2 :: (Ord k0, Ord k1, Semigroup (DeepMap ks v)) => (j0 -> k0) -> (j1 -> k1) -> DeepMap (j0 ': (j1 ': ks)) v -> DeepMap (k0 ': (k1 ': ks)) v
-- | O(n log n). Map a function over the keys of a DeepMap.
mapKeys3 :: (Ord k0, Ord k1, Ord k2, Semigroup (DeepMap ks v)) => (j0 -> k0) -> (j1 -> k1) -> (j2 -> k2) -> DeepMap (j0 ': (j1 ': (j2 ': ks))) v -> DeepMap (k0 ': (k1 ': (k2 ': ks))) v
-- | O(n log n). Map a function over the keys of a DeepMap.
mapKeys4 :: (Ord k0, Ord k1, Ord k2, Ord k3, Semigroup (DeepMap ks v)) => (j0 -> k0) -> (j1 -> k1) -> (j2 -> k2) -> (j3 -> k3) -> DeepMap (j0 ': (j1 ': (j2 ': (j3 ': ks)))) v -> DeepMap (k0 ': (k1 ': (k2 ': (k3 ': ks)))) v
-- | O(n log n). Map a function over the keys of a DeepMap.
mapKeys5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4, Semigroup (DeepMap ks v)) => (j0 -> k0) -> (j1 -> k1) -> (j2 -> k2) -> (j3 -> k3) -> (j4 -> k4) -> DeepMap (j0 ': (j1 ': (j2 ': (j3 ': (j4 ': ks))))) v -> DeepMap (k0 ': (k1 ': (k2 ': (k3 ': (k4 ': ks))))) v
-- | O(n log n). Map a function over the outer keys of a
-- DeepMap with a combining function.
mapKeysWith :: Ord k => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> (j -> k) -> DeepMap (j ': ks) v -> DeepMap (k ': ks) v
-- | O(n log n). Map a function over the keys of a DeepMap
-- with a value-combining function.
mapKeysWith1 :: Ord k => (v -> v -> v) -> (j -> k) -> DeepMap '[j] v -> DeepMap '[k] v
-- | O(n log n). Map a function over the keys of a DeepMap
-- with a value-combining function.
mapKeysWith2 :: (Ord k0, Ord k1) => (v -> v -> v) -> (j0 -> k0) -> (j1 -> k1) -> DeepMap '[j0, j1] v -> DeepMap '[k0, k1] v
-- | O(n log n). Map a function over the keys of a DeepMap
-- with a value-combining function.
mapKeysWith3 :: (Ord k0, Ord k1, Ord k2) => (v -> v -> v) -> (j0 -> k0) -> (j1 -> k1) -> (j2 -> k2) -> DeepMap '[j0, j1, j2] v -> DeepMap '[k0, k1, k2] v
-- | O(n log n). Map a function over the keys of a DeepMap
-- with a value-combining function.
mapKeysWith4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (v -> v -> v) -> (j0 -> k0) -> (j1 -> k1) -> (j2 -> k2) -> (j3 -> k3) -> DeepMap '[j0, j1, j2, j3] v -> DeepMap '[k0, k1, k2, k3] v
-- | O(n log n). Map a function over the keys of a DeepMap
-- with a value-combining function.
mapKeysWith5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (v -> v -> v) -> (j0 -> k0) -> (j1 -> k1) -> (j2 -> k2) -> (j3 -> k3) -> (j4 -> k4) -> DeepMap '[j0, j1, j2, j3, j4] v -> DeepMap '[k0, k1, k2, k3, k4] v
-- | O(n log n). Map an applicative function over the outer keys and
-- collect the results.
traverseKeys :: (Applicative f, Ord k, Semigroup (DeepMap ks v)) => (j -> f k) -> DeepMap (j ': ks) v -> f (DeepMap (k ': ks) v)
traverseKeysDeep :: forall f js ks v. (Applicative f, Monoid (DeepMap ks v)) => (Deep js -> f (Deep ks)) -> DeepMap js v -> f (DeepMap ks v)
-- | O(n log n). Map an applicative function over the outer keys of
-- the map and collect the results using the specified combining
-- function.
traverseKeysWith :: (Applicative f, Ord k) => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> (j -> f k) -> DeepMap (j ': ks) v -> f (DeepMap (k ': ks) v)
-- | O(n log n). Map a monadic function over the keys of a
-- DeepMap and collect the results.
mapKeysM :: (Monad m, Ord k, Semigroup (DeepMap ks v)) => (j -> m k) -> DeepMap (j ': ks) v -> m (DeepMap (k ': ks) v)
-- | O(n log n). Map a monadic function over the keys of a
-- DeepMap and collect the results.
mapKeysM1 :: (Monad m, Ord k, Semigroup (DeepMap ks v)) => (j -> m k) -> DeepMap (j ': ks) v -> m (DeepMap (k ': ks) v)
-- | O(n log n). Map a monadic function over the keys of a
-- DeepMap and collect the results.
--
-- Sadly traverseKeys2 can't have this type signature because
-- we'd end up with a twice-wrapped Applicative and no way out.
mapKeysM2 :: (Monad m, Ord k0, Ord k1, Semigroup (DeepMap ks v)) => (j0 -> m k0) -> (j1 -> m k1) -> DeepMap (j0 ': (j1 ': ks)) v -> m (DeepMap (k0 ': (k1 ': ks)) v)
-- | O(n log n). Map a monadic function over the keys of a
-- DeepMap and collect the results.
mapKeysM3 :: (Monad m, Ord k0, Ord k1, Ord k2, Semigroup (DeepMap ks v)) => (j0 -> m k0) -> (j1 -> m k1) -> (j2 -> m k2) -> DeepMap (j0 ': (j1 ': (j2 ': ks))) v -> m (DeepMap (k0 ': (k1 ': (k2 ': ks))) v)
-- | O(n log n). Map a monadic function over the keys of a
-- DeepMap and collect the results.
mapKeysM4 :: (Monad m, Ord k0, Ord k1, Ord k2, Ord k3, Semigroup (DeepMap ks v)) => (j0 -> m k0) -> (j1 -> m k1) -> (j2 -> m k2) -> (j3 -> m k3) -> DeepMap (j0 ': (j1 ': (j2 ': (j3 ': ks)))) v -> m (DeepMap (k0 ': (k1 ': (k2 ': (k3 ': ks)))) v)
-- | O(n log n). Map a monadic function over the keys of a
-- DeepMap and collect the results.
mapKeysM5 :: (Monad m, Ord k0, Ord k1, Ord k2, Ord k3, Ord k4, Semigroup (DeepMap ks v)) => (j0 -> m k0) -> (j1 -> m k1) -> (j2 -> m k2) -> (j3 -> m k3) -> (j4 -> m k4) -> DeepMap (j0 ': (j1 ': (j2 ': (j3 ': (j4 ': ks))))) v -> m (DeepMap (k0 ': (k1 ': (k2 ': (k3 ': (k4 ': ks))))) v)
-- | O(n log n). Map a monadic function over the outer keys of a
-- DeepMap with a submap-combining function.
mapKeysMWith :: (Monad m, Ord k) => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> (j -> m k) -> DeepMap (j ': ks) v -> m (DeepMap (k ': ks) v)
-- | O(n log n). Map a monadic function over the keys of a
-- DeepMap with a value-combining function.
mapKeysMWith1 :: (Monad m, Ord k) => (v -> v -> v) -> (j -> m k) -> DeepMap '[j] v -> m (DeepMap '[k] v)
-- | O(n log n). Map a monadic function over the keys of a
-- DeepMap with a value-combining function.
mapKeysMWith2 :: (Monad m, Ord k0, Ord k1) => (v -> v -> v) -> (j0 -> m k0) -> (j1 -> m k1) -> DeepMap '[j0, j1] v -> m (DeepMap '[k0, k1] v)
-- | O(n log n). Map a monadic function over the keys of a
-- DeepMap with a value-combining function.
mapKeysMWith3 :: (Monad m, Ord k0, Ord k1, Ord k2) => (v -> v -> v) -> (j0 -> m k0) -> (j1 -> m k1) -> (j2 -> m k2) -> DeepMap '[j0, j1, j2] v -> m (DeepMap '[k0, k1, k2] v)
-- | O(n log n). Map a monadic function over the keys of a
-- DeepMap with a value-combining function.
mapKeysMWith4 :: (Monad m, Ord k0, Ord k1, Ord k2, Ord k3) => (v -> v -> v) -> (j0 -> m k0) -> (j1 -> m k1) -> (j2 -> m k2) -> (j3 -> m k3) -> DeepMap '[j0, j1, j2, j3] v -> m (DeepMap '[k0, k1, k2, k3] v)
-- | O(n log n). Map a monadic function over the keys of a
-- DeepMap with a value-combining function.
mapKeysMWith5 :: (Monad m, Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (v -> v -> v) -> (j0 -> m k0) -> (j1 -> m k1) -> (j2 -> m k2) -> (j3 -> m k3) -> (j4 -> m k4) -> DeepMap '[j0, j1, j2, j3, j4] v -> m (DeepMap '[k0, k1, k2, k3, k4] v)
-- | Right-associative fold of a structure, lazy in the accumulator.
--
-- In the case of lists, foldr, when applied to a binary operator,
-- a starting value (typically the right-identity of the operator), and a
-- list, reduces the list using the binary operator, from right to left:
--
--
-- foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)
--
--
-- Note that since the head of the resulting expression is produced by an
-- application of the operator to the first element of the list, given an
-- operator lazy in its right argument, foldr can produce a
-- terminating expression from an unbounded list.
--
-- For a general Foldable structure this should be semantically
-- identical to,
--
--
-- foldr f z = foldr f z . toList
--
--
-- Examples
--
-- Basic usage:
--
--
-- >>> foldr (||) False [False, True, False]
-- True
--
--
--
-- >>> foldr (||) False []
-- False
--
--
--
-- >>> foldr (\c acc -> acc ++ [c]) "foo" ['a', 'b', 'c', 'd']
-- "foodcba"
--
--
-- Infinite structures
--
-- ⚠️ Applying foldr to infinite structures usually doesn't
-- terminate.
--
-- It may still terminate under one of the following conditions:
--
--
-- - the folding function is short-circuiting
-- - the folding function is lazy on its second argument
--
--
-- Short-circuiting
--
-- (||) short-circuits on True values, so the
-- following terminates because there is a True value finitely far
-- from the left side:
--
--
-- >>> foldr (||) False (True : repeat False)
-- True
--
--
-- But the following doesn't terminate:
--
--
-- >>> foldr (||) False (repeat False ++ [True])
-- * Hangs forever *
--
--
-- Laziness in the second argument
--
-- Applying foldr to infinite structures terminates when the
-- operator is lazy in its second argument (the initial accumulator is
-- never used in this case, and so could be left undefined, but
-- [] is more clear):
--
--
-- >>> take 5 $ foldr (\i acc -> i : fmap (+3) acc) [] (repeat 1)
-- [1,4,7,10,13]
--
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
-- | Left-associative fold of a structure, lazy in the accumulator. This is
-- rarely what you want, but can work well for structures with efficient
-- right-to-left sequencing and an operator that is lazy in its left
-- argument.
--
-- In the case of lists, foldl, when applied to a binary operator,
-- a starting value (typically the left-identity of the operator), and a
-- list, reduces the list using the binary operator, from left to right:
--
--
-- foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn
--
--
-- Note that to produce the outermost application of the operator the
-- entire input list must be traversed. Like all left-associative folds,
-- foldl will diverge if given an infinite list.
--
-- If you want an efficient strict left-fold, you probably want to use
-- foldl' instead of foldl. The reason for this is that the
-- latter does not force the inner results (e.g. z `f` x1
-- in the above example) before applying them to the operator (e.g. to
-- (`f` x2)). This results in a thunk chain O(n) elements
-- long, which then must be evaluated from the outside-in.
--
-- For a general Foldable structure this should be semantically
-- identical to:
--
--
-- foldl f z = foldl f z . toList
--
--
-- Examples
--
-- The first example is a strict fold, which in practice is best
-- performed with foldl'.
--
--
-- >>> foldl (+) 42 [1,2,3,4]
-- 52
--
--
-- Though the result below is lazy, the input is reversed before
-- prepending it to the initial accumulator, so corecursion begins only
-- after traversing the entire input string.
--
--
-- >>> foldl (\acc c -> c : acc) "abcd" "efgh"
-- "hgfeabcd"
--
--
-- A left fold of a structure that is infinite on the right cannot
-- terminate, even when for any finite input the fold just returns the
-- initial accumulator:
--
--
-- >>> foldl (\a _ -> a) 0 $ repeat 1
-- * Hangs forever *
--
--
-- WARNING: When it comes to lists, you always want to use either
-- foldl' or foldr instead.
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
foldShallow :: Monoid (DeepMap ks v) => DeepMap (k ': ks) v -> DeepMap ks v
-- | O(n). Fold the keys and submaps in the DeepMap using the
-- given right-associative binary operator.
foldrWithKey :: (k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k ': ks) v -> b
-- | O(n). Fold the keys and values using the given
-- right-associative binary operator.
foldrWithKey1 :: (k -> v -> b -> b) -> b -> DeepMap '[k] v -> b
-- | O(n). Fold the keys and values using the given
-- right-associative binary operator.
foldrWithKey2 :: (k0 -> k1 -> v -> b -> b) -> b -> DeepMap '[k0, k1] v -> b
-- | O(n). Fold the keys and values using the given
-- right-associative binary operator.
foldrWithKey3 :: (k0 -> k1 -> k2 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2] v -> b
-- | O(n). Fold the keys and values using the given
-- right-associative binary operator.
foldrWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2, k3] v -> b
-- | O(n). Fold the keys and values using the given
-- right-associative binary operator.
foldrWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k3 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2, k3, k3] v -> b
-- | O(n). Fold the keys and submaps in the DeepMap using the
-- given left-associative binary operator.
foldlWithKey :: (b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k ': ks) v -> b
-- | O(n). Fold the keys and values in the DeepMap using the
-- given left-associative binary operator.
foldlWithKey1 :: (b -> k -> v -> b) -> b -> DeepMap '[k] v -> b
-- | O(n). Fold the keys and values in the DeepMap using the
-- given left-associative binary operator.
foldlWithKey2 :: (b -> k0 -> k1 -> v -> b) -> b -> DeepMap '[k0, k1] v -> b
-- | O(n). Fold the keys and values in the DeepMap using the
-- given left-associative binary operator.
foldlWithKey3 :: (b -> k0 -> k1 -> k2 -> v -> b) -> b -> DeepMap '[k0, k1, k2] v -> b
-- | O(n). Fold the keys and values in the DeepMap using the
-- given left-associative binary operator.
foldlWithKey4 :: (b -> k0 -> k1 -> k2 -> k3 -> v -> b) -> b -> DeepMap '[k0, k1, k2, k3] v -> b
-- | O(n). Strictly fold the keys and values in the DeepMap
-- using the given left-associative binary operator.
foldlWithKey5 :: (b -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> b) -> b -> DeepMap '[k0, k1, k2, k3, k4] v -> b
-- | O(n). Fold the keys and submaps using the given monoid.
foldMapWithKey :: Monoid m => (k -> DeepMap ks v -> m) -> DeepMap (k ': ks) v -> m
-- | O(n). Fold the keys and values in the map using the given
-- monoid.
foldMapWithKey1 :: Monoid m => (k -> v -> m) -> DeepMap '[k] v -> m
-- | O(n). Fold the keys and values in the map using the given
-- monoid.
foldMapWithKey2 :: Monoid m => (k0 -> k1 -> v -> m) -> DeepMap '[k0, k1] v -> m
-- | O(n). Fold the keys and values in the map using the given
-- monoid.
foldMapWithKey3 :: Monoid m => (k0 -> k1 -> k2 -> v -> m) -> DeepMap '[k0, k1, k2] v -> m
-- | O(n). Fold the keys and values in the map using the given
-- monoid.
foldMapWithKey4 :: Monoid m => (k0 -> k1 -> k2 -> k3 -> v -> m) -> DeepMap '[k0, k1, k2, k3] v -> m
-- | O(n). Fold the keys and values in the map using the given
-- monoid.
foldMapWithKey5 :: Monoid m => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> m) -> DeepMap '[k0, k1, k2, k3, k4] v -> m
-- | foldr' is a variant of foldr that performs strict
-- reduction from right to left, i.e. starting with the right-most
-- element. The input structure must be finite, otherwise
-- foldr' runs out of space (diverges).
--
-- If you want a strict right fold in constant space, you need a
-- structure that supports faster than O(n) access to the
-- right-most element, such as Seq from the containers
-- package.
--
-- This method does not run in constant space for structures such as
-- lists that don't support efficient right-to-left iteration and so
-- require O(n) space to perform right-to-left reduction. Use of
-- this method with such a structure is a hint that the chosen structure
-- may be a poor fit for the task at hand. If the order in which the
-- elements are combined is not important, use foldl' instead.
foldr' :: Foldable t => (a -> b -> b) -> b -> t a -> b
-- | Left-associative fold of a structure but with strict application of
-- the operator.
--
-- This ensures that each step of the fold is forced to Weak Head Normal
-- Form before being applied, avoiding the collection of thunks that
-- would otherwise occur. This is often what you want to strictly reduce
-- a finite structure to a single strict result (e.g. sum).
--
-- For a general Foldable structure this should be semantically
-- identical to,
--
--
-- foldl' f z = foldl' f z . toList
--
foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
-- | O(n). Strictly fold the keys and submaps in the DeepMap
-- using the given right-associative binary operator.
foldrWithKey' :: (k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k ': ks) v -> b
-- | O(n). Strictly fold the keys and values using the given
-- right-associative binary operator.
foldrWithKey1' :: (k -> v -> b -> b) -> b -> DeepMap '[k] v -> b
-- | O(n). Strictly fold the keys and values using the given
-- right-associative binary operator.
foldrWithKey2' :: (k0 -> k1 -> v -> b -> b) -> b -> DeepMap '[k0, k1] v -> b
-- | O(n). Strictly fold the keys and values using the given
-- right-associative binary operator.
foldrWithKey3' :: (k0 -> k1 -> k2 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2] v -> b
-- | O(n). Strictly fold the keys and values using the given
-- right-associative binary operator.
foldrWithKey4' :: (k0 -> k1 -> k2 -> k3 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2, k3] v -> b
-- | O(n). Strictly fold the keys and values using the given
-- right-associative binary operator.
foldrWithKey5' :: (k0 -> k1 -> k2 -> k3 -> k3 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2, k3, k3] v -> b
-- | O(n). Strictly fold the keys and submaps in the DeepMap
-- using the given left-associative binary operator.
foldlWithKey' :: (b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k ': ks) v -> b
-- | O(n). Strictly fold the keys and values in the DeepMap
-- using the given left-associative binary operator.
foldlWithKey1' :: (b -> k -> v -> b) -> b -> DeepMap '[k] v -> b
-- | O(n). Strictly fold the keys and values in the DeepMap
-- using the given left-associative binary operator.
foldlWithKey2' :: (b -> k0 -> k1 -> v -> b) -> b -> DeepMap '[k0, k1] v -> b
-- | O(n). Strictly fold the keys and values in the DeepMap
-- using the given left-associative binary operator.
foldlWithKey3' :: (b -> k0 -> k1 -> k2 -> v -> b) -> b -> DeepMap '[k0, k1, k2] v -> b
-- | O(n). Strictly fold the keys and values in the DeepMap
-- using the given left-associative binary operator.
foldlWithKey4' :: (b -> k0 -> k1 -> k2 -> k3 -> v -> b) -> b -> DeepMap '[k0, k1, k2, k3] v -> b
-- | O(n). Fold the keys and values in the DeepMap using the
-- given left-associative binary operator.
foldlWithKey5' :: (b -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> b) -> b -> DeepMap '[k0, k1, k2, k3, k4] v -> b
-- | O(n). Fold the keys and submaps using the given monoid.
foldMapWithKey' :: Monoid m => (k -> DeepMap ks v -> m) -> DeepMap (k ': ks) v -> m
-- | O(n). Fold the keys and values in the map using the given
-- monoid.
foldMapWithKey1' :: Monoid m => (k -> v -> m) -> DeepMap '[k] v -> m
-- | O(n). Fold the keys and values in the map using the given
-- monoid.
foldMapWithKey2' :: Monoid m => (k0 -> k1 -> v -> m) -> DeepMap '[k0, k1] v -> m
-- | O(n). Fold the keys and values in the map using the given
-- monoid.
foldMapWithKey3' :: Monoid m => (k0 -> k1 -> k2 -> v -> m) -> DeepMap '[k0, k1, k2] v -> m
-- | O(n). Fold the keys and values in the map using the given
-- monoid.
foldMapWithKey4' :: Monoid m => (k0 -> k1 -> k2 -> k3 -> v -> m) -> DeepMap '[k0, k1, k2, k3] v -> m
-- | O(n). Fold the keys and values in the map using the given
-- monoid.
foldMapWithKey5' :: Monoid m => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> m) -> DeepMap '[k0, k1, k2, k3, k4] v -> m
-- | O(n). Return all submaps of the map in ascending order of its
-- keys. Subject to list fusion.
elems :: DeepMap (k ': ks) v -> [DeepMap ks v]
-- | O(n). Return all values of the singly-nested map in ascending
-- order of its keys. Subject to list fusion.
elems1 :: DeepMap '[k] v -> [v]
-- | O(n). Return all values of the DeepMap at distinct key
-- chains.
elemsDeep :: DeepMap ks v -> [v]
-- | O(n). Return all keys of the map in ascending order. Subject to
-- list fusion.
keys :: DeepMap (k ': ks) v -> [k]
-- | O(n). The set of all keys of the map.
keysSet :: DeepMap (k ': ks) v -> Set k
-- | O(n). Return all distinct key chains of the DeepMap.
keysDeep :: DeepMap ks v -> [Deep ks]
-- | O(n). Return all pairs of the map in ascending key order.
-- Subject to list fusion.
assocs :: DeepMap (k ': ks) v -> [(k, DeepMap ks v)]
-- | O(n). Return all pairs of the singly-nested map in ascending
-- key order. Subject to list fusion.
assocs1 :: DeepMap '[k] v -> [(k, v)]
-- | O(n). Return all keychain-value pairs of the DeepMap.
assocsDeep :: DeepMap ks v -> [(Deep ks, v)]
-- | Transpose a DeepMap, by swapping the outer two
-- "dimensions".
invertKeys :: (Ord j, Ord k, Semigroup (DeepMap ks v)) => DeepMap (j ': (k ': ks)) v -> DeepMap (k ': (j ': ks)) v
-- | List of elements of a structure, from left to right. If the entire
-- list is intended to be reduced via a fold, just fold the structure
-- directly bypassing the list.
--
-- Examples
--
-- Basic usage:
--
--
-- >>> toList Nothing
-- []
--
--
--
-- >>> toList (Just 42)
-- [42]
--
--
--
-- >>> toList (Left "foo")
-- []
--
--
--
-- >>> toList (Node (Leaf 5) 17 (Node Empty 12 (Leaf 8)))
-- [5,17,12,8]
--
--
-- For lists, toList is the identity:
--
--
-- >>> toList [1, 2, 3]
-- [1,2,3]
--
toList :: Foldable t => t a -> [a]
-- | O(n). Convert the map to a list of key/submap pairs where the
-- keys are in ascending order. Subject to list fusion.
toAscList :: DeepMap (k ': ks) v -> [(k, DeepMap ks v)]
-- | O(n). Convert the map to a list of key/submap pairs where the
-- keys are in descending order. Subject to list fusion.
toDescList :: DeepMap (k ': ks) v -> [(k, DeepMap ks v)]
-- | O(n). Filter all submaps that satisfy the predicate.
filter :: (DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(n). Filter all values that satisfy the predicate.
filter1 :: (v -> Bool) -> DeepMap '[k] v -> DeepMap '[k] v
-- | O(n). Filter all values that satisfy the predicate.
filter2 :: (v -> Bool) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
-- | O(n). Filter all values that satisfy the predicate.
filter3 :: (v -> Bool) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
-- | O(n). Filter all values that satisfy the predicate.
filter4 :: (v -> Bool) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
-- | O(n). Filter all values that satisfy the predicate.
filter5 :: (v -> Bool) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
-- | O(n). Filter all key/submap pairs that satisfy the predicate.
filterWithKey :: (k -> DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | The constraint is necessary for instance resolution, but should always
-- be satisfied during normal use.
filterWithKeys :: FilterableWithIndex (Deep (k ': ks)) (DeepMap (k ': ks)) => (Deep (k ': ks) -> v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(n). Filter all key/value pairs that satisfy the predicate.
filterWithKey1 :: (k -> v -> Bool) -> DeepMap '[k] v -> DeepMap '[k] v
-- | O(n). Filter all key-chain/value pairs that satisfy the
-- predicate.
filterWithKey2 :: (k0 -> k1 -> v -> Bool) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
-- | O(n). Filter all key-chain/value pairs that satisfy the
-- predicate.
filterWithKey3 :: (k0 -> k1 -> k2 -> v -> Bool) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
-- | O(n). Filter all key-chain/value pairs that satisfy the
-- predicate.
filterWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> Bool) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
-- | O(n). Filter all key-chain/value pairs that satisfy the
-- predicate.
filterWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Bool) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
-- | O(m log(n / m + 1)), m <= n. Restrict a Map to only
-- the keys in a given Set.
restrictKeys :: Ord k => DeepMap (k ': ks) v -> Set k -> DeepMap (k ': ks) v
-- | O(m log(n / m + 1)), m <= n. Restrict a Map to only
-- the keys in a given Set.
restrictKeys2 :: (Ord k0, Ord k1) => DeepMap (k0 ': (k1 ': ks)) v -> Set (k0, k1) -> DeepMap (k0 ': (k1 ': ks)) v
-- | O(m log(n / m + 1)), m <= n. Restrict a Map to only
-- the keys in a given Set.
restrictKeys3 :: (Ord k0, Ord k1, Ord k2) => DeepMap (k0 ': (k1 ': (k2 ': ks))) v -> Set (k0, k1, k2) -> DeepMap (k0 ': (k1 ': (k2 ': ks))) v
-- | O(m log(n / m + 1)), m <= n. Restrict a Map to only
-- the keys in a given Set.
restrictKeys4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => DeepMap (k0 ': (k1 ': (k2 ': (k3 ': ks)))) v -> Set (k0, k1, k2, k3) -> DeepMap (k0 ': (k1 ': (k2 ': (k3 ': ks)))) v
-- | O(m log(n / m + 1)), m <= n. Restrict a Map to only
-- the keys in a given Set.
restrictKeys5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => DeepMap (k0 ': (k1 ': (k2 ': (k3 ': (k4 ': ks))))) v -> Set (k0, k1, k2, k3, k4) -> DeepMap (k0 ': (k1 ': (k2 ': (k3 ': (k4 ': ks))))) v
-- | O(m log(n / m + 1)), m <= n. Remove all the keys in a
-- Set from a Map.
withoutKeys :: Ord k => DeepMap (k ': ks) v -> Set k -> DeepMap (k ': ks) v
-- | O(m log(n / m + 1)), m <= n. Remove all the keys in a
-- Set from a Map.
withoutKeys2 :: (Ord k0, Ord k1) => DeepMap (k0 ': (k1 ': ks)) v -> Set (k0, k1) -> DeepMap (k0 ': (k1 ': ks)) v
-- | O(m log(n / m + 1)), m <= n. Remove all the keys in a
-- Set from a Map.
withoutKeys3 :: (Ord k0, Ord k1, Ord k2) => DeepMap (k0 ': (k1 ': (k2 ': ks))) v -> Set (k0, k1, k2) -> DeepMap (k0 ': (k1 ': (k2 ': ks))) v
-- | O(m log(n / m + 1)), m <= n. Remove all the keys in a
-- Set from a Map.
withoutKeys4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => DeepMap (k0 ': (k1 ': (k2 ': (k3 ': ks)))) v -> Set (k0, k1, k2, k3) -> DeepMap (k0 ': (k1 ': (k2 ': (k3 ': ks)))) v
-- | O(m log(n / m + 1)), m <= n. Remove all the keys in a
-- Set from a Map.
withoutKeys5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => DeepMap (k0 ': (k1 ': (k2 ': (k3 ': (k4 ': ks))))) v -> Set (k0, k1, k2, k3, k4) -> DeepMap (k0 ': (k1 ': (k2 ': (k3 ': (k4 ': ks))))) v
-- | O(n). Partition the map according to a predicate (satisfied,
-- failed).
partition :: (DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)
-- | O(n). Partition the map according to a predicate (satisfied,
-- failed).
partition1 :: (v -> Bool) -> DeepMap '[k] v -> (DeepMap '[k] v, DeepMap '[k] v)
-- | O(n). Partition the map according to a predicate (satisfied,
-- failed).
partition2 :: (v -> Bool) -> DeepMap '[k0, k1] v -> (DeepMap '[k0, k1] v, DeepMap '[k0, k1] v)
-- | O(n). Partition the map according to a predicate (satisfied,
-- failed).
partition3 :: (v -> Bool) -> DeepMap '[k0, k1, k2] v -> (DeepMap '[k0, k1, k2] v, DeepMap '[k0, k1, k2] v)
-- | O(n). Partition the map according to a predicate (satisfied,
-- failed).
partition4 :: (v -> Bool) -> DeepMap '[k0, k1, k2, k3] v -> (DeepMap '[k0, k1, k2, k3] v, DeepMap '[k0, k1, k2, k3] v)
-- | O(n). Partition the map according to a predicate (satisfied,
-- failed).
partition5 :: (v -> Bool) -> DeepMap '[k0, k1, k2, k3, k4] v -> (DeepMap '[k0, k1, k2, k3, k4] v, DeepMap '[k0, k1, k2, k3, k4] v)
-- | O(n). Partition the map according to a predicate (satisfied,
-- failed).
partitionWithKey :: (k -> DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)
-- | The constraint is necessary for instance resolution, but should always
-- be satisfied during normal use.
partitionWithKeys :: FilterableWithIndex (Deep (k ': ks)) (DeepMap (k ': ks)) => (Deep (k ': ks) -> v -> Bool) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)
-- | O(n). Partition the map according to a predicate (satisfied,
-- failed).
partitionWithKey1 :: (k -> v -> Bool) -> DeepMap '[k] v -> (DeepMap '[k] v, DeepMap '[k] v)
-- | O(n). Partition the map according to a predicate (satisfied,
-- failed).
partitionWithKey2 :: (k0 -> k1 -> v -> Bool) -> DeepMap '[k0, k1] v -> (DeepMap '[k0, k1] v, DeepMap '[k0, k1] v)
-- | O(n). Partition the map according to a predicate (satisfied,
-- failed).
partitionWithKey3 :: (k0 -> k1 -> k2 -> v -> Bool) -> DeepMap '[k0, k1, k2] v -> (DeepMap '[k0, k1, k2] v, DeepMap '[k0, k1, k2] v)
-- | O(n). Partition the map according to a predicate (satisfied,
-- failed).
partitionWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> Bool) -> DeepMap '[k0, k1, k2, k3] v -> (DeepMap '[k0, k1, k2, k3] v, DeepMap '[k0, k1, k2, k3] v)
-- | O(n). Partition the map according to a predicate (satisfied,
-- failed).
partitionWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Bool) -> DeepMap '[k0, k1, k2, k3, k4] v -> (DeepMap '[k0, k1, k2, k3, k4] v, DeepMap '[k0, k1, k2, k3, k4] v)
-- | O(n). Take while a predicate on the keys holds. See the note at
-- spanAntitone.
takeWhileAntitone :: (k -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(n). Drop while a predicate on the keys holds. See the note at
-- spanAntitone.
dropWhileAntitone :: (k -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(n). Take while a predicate on the keys holds.
--
-- NOTE: if p is not actually antitone, then spanAntitone
-- will split the map at some unspecified point where the predicate
-- switches from holding to not holding (where the predicate is seen to
-- hold before the first key and to fail after the last key).
spanAntitone :: (k -> Bool) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)
-- | O(n). Map values and collect the Just results.
mapMaybe :: (v -> Maybe w) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) w
-- | The constraint is necessary for instance resolution, but should always
-- be satisfied during normal use.
mapMaybeWithKeys :: FilterableWithIndex (Deep (k ': ks)) (DeepMap (k ': ks)) => (Deep (k ': ks) -> v -> Maybe w) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) w
-- | O(n). Map values and collect the Just results. Strictly
-- more general than mapMaybe in that the types of the inner keys
-- can change.
mapShallowMaybe :: (DeepMap ks v -> Maybe (DeepMap ls w)) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w
-- | O(n). Map values and collect the Just results.
mapShallowMaybeWithKey :: (k -> DeepMap ks v -> Maybe (DeepMap ls w)) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w
-- | O(n). Map values and collect the Just results.
mapMaybeWithKey1 :: (k -> v -> Maybe w) -> DeepMap '[k] v -> DeepMap '[k] w
-- | O(n). Map values and collect the Just results.
mapMaybeWithKey2 :: (k0 -> k1 -> v -> Maybe w) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] w
-- | O(n). Map values and collect the Just results.
mapMaybeWithKey3 :: (k0 -> k1 -> k2 -> v -> Maybe w) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] w
-- | O(n). Map values and collect the Just results.
mapMaybeWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> Maybe w) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] w
-- | O(n). Map values and collect the Just results.
mapMaybeWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Maybe w) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] w
-- | O(n). Map values and collect the Left and Right
-- results separately.
mapEither :: (v -> Either w x) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) w, DeepMap (k ': ks) x)
-- | The constraint is necessary for instance resolution, but should always
-- be satisfied during normal use.
mapEitherWithKeys :: FilterableWithIndex (Deep (k ': ks)) (DeepMap (k ': ks)) => (Deep (k ': ks) -> v -> Either w x) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) w, DeepMap (k ': ks) x)
-- | O(n). Map values and collect the Left and Right
-- results separately.
mapShallowEither :: (DeepMap ks v -> Either (DeepMap ls w) (DeepMap ms x)) -> DeepMap (k ': ks) v -> (DeepMap (k ': ls) w, DeepMap (k ': ms) x)
-- | O(n). Map values and collect the Left and Right
-- results separately.
mapShallowEitherWithKey :: (k -> DeepMap ks v -> Either (DeepMap ls w) (DeepMap ms x)) -> DeepMap (k ': ks) v -> (DeepMap (k ': ls) w, DeepMap (k ': ms) x)
-- | O(n). Map values and collect the Left and Right
-- results separately.
mapEitherWithKey1 :: (k -> v -> Either w x) -> DeepMap '[k] v -> (DeepMap '[k] w, DeepMap '[k] x)
-- | O(n). Map values and collect the Left and Right
-- results separately.
mapEitherWithKey2 :: (k0 -> k1 -> v -> Either w x) -> DeepMap '[k0, k1] v -> (DeepMap '[k0, k1] w, DeepMap '[k0, k1] x)
-- | O(n). Map values and collect the Left and Right
-- results separately.
mapEitherWithKey3 :: (k0 -> k1 -> k2 -> v -> Either w x) -> DeepMap '[k0, k1, k2] v -> (DeepMap '[k0, k1, k2] w, DeepMap '[k0, k1, k2] x)
-- | O(n). Map values and collect the Left and Right
-- results separately.
mapEitherWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> Either w x) -> DeepMap '[k0, k1, k2, k3] v -> (DeepMap '[k0, k1, k2, k3] w, DeepMap '[k0, k1, k2, k3] x)
-- | O(n). Map values and collect the Left and Right
-- results separately.
mapEitherWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Either w x) -> DeepMap '[k0, k1, k2, k3, k4] v -> (DeepMap '[k0, k1, k2, k3, k4] w, DeepMap '[k0, k1, k2, k3, k4] x)
-- | O(log n). Partition the map by comparing keys ((smaller,
-- larger) than given).
split :: Ord k => k -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)
-- | O(log n). Like split but the middle coordinate
-- lookups the value at the key.
splitLookup :: Ord k => k -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, Maybe (DeepMap ks v), DeepMap (k ': ks) v)
-- | O(1). Decompose a map into pieces based on the structure of the
-- underlying tree.
splitRoot :: DeepMap (k ': ks) v -> [DeepMap (k ': ks) v]
-- | O(m log(n / m + 1)), m <= n. Returns True if all the
-- keys in the left map exist in the right, and their values all
-- agree.
isSubmapOf :: (Ord k, Eq (DeepMap ks v)) => DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool
-- | O(m log(n / m + 1)), m <= n. Returns True if all the
-- keys in the left map exist in the right, and the function
-- returns True when applied to respective values.
isSubmapOfBy :: Ord k => (DeepMap ks v -> DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool
-- | O(m log(n / m + 1)), m <= n. Returns True if all the
-- keys in the left map exist in the right, and their values all
-- agree, and the maps are not equal.
isProperSubmapOf :: (Ord k, Eq (DeepMap ks v)) => DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool
-- | O(m log(n / m + 1)), m <= n. Returns True if all the
-- keys in the left map exist in the right, and the function
-- returns True when applied to respective values, and the
-- maps are not equal.
isProperSubmapOfBy :: Ord k => (DeepMap ks v -> DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool
-- | O(log n). Lookup the index of a key, which is its
-- zero-based index in the ordered sequence of keys.
--
--
-- 'lookupIndex' k m == 'Data.List.findIndex' k ('keys' m)
--
lookupIndex :: Ord k => k -> DeepMap (k ': ks) v -> Maybe Int
-- | O(log n). Lookup the index of a key, which is its
-- zero-based index in the ordered sequence of keys. Calls error
-- when the key is not in the map.
findIndex :: Ord k => k -> DeepMap (k ': ks) v -> Int
-- | O(log n). Retrieve an element by its index. Calls
-- error if i is outside the range 0 <= i <
-- size m.
elemAt :: Ord k => Int -> DeepMap (k ': ks) v -> (k, DeepMap ks v)
-- | O(log n). Update the element by its index. Calls
-- error if i is outside the range 0 <= i <
-- size m.
updateAt :: Ord k => (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(log n). Delete the element by its index. Calls
-- error if i is outside the range 0 <= i <
-- size m.
deleteAt :: Ord k => (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | Take the smallest n keys.
take :: Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | Drop the smallest n keys.
drop :: Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(n). Split a map at a particular index.
splitAt :: Int -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)
-- | O(log n). The minimal key of the map, or Nothing if the
-- map is empty.
lookupMin :: DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)
-- | O(log n). The maximal key of the map, or Nothing if the
-- map is empty.
lookupMax :: DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)
-- | O(log n). The minimal key of the map, or error if the
-- map is empty.
findMin :: DeepMap (k ': ks) v -> (k, DeepMap ks v)
-- | O(log n). The maximal key of the map, or error if the
-- map is empty.
findMax :: DeepMap (k ': ks) v -> (k, DeepMap ks v)
-- | O(log n). Delete the minimal key.
deleteMin :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(log n). Delete the maximal key.
deleteMax :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(log n). Delete and return the minimal key of the map, or
-- error if the map is empty.
deleteFindMin :: DeepMap (k ': ks) v -> ((k, DeepMap ks v), DeepMap (k ': ks) v)
-- | O(log n). Delete and return the maximal key of the map, or
-- error if the map is empty.
deleteFindMax :: DeepMap (k ': ks) v -> ((k, DeepMap ks v), DeepMap (k ': ks) v)
-- | O(log n). Update the value at the minimal key.
updateMin :: (DeepMap ks v -> Maybe (DeepMap ks v)) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(log n). Update the value at the maximal key.
updateMax :: (DeepMap ks v -> Maybe (DeepMap ks v)) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(log n). Update the value at the minimal key.
updateMinWithKey :: (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(log n). Update the value at the maximal key.
updateMaxWithKey :: (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
-- | O(log n). Retrieve the value associated with the minimal key of
-- the map, and the map stripped of that element, or Nothing if
-- passed an empty map.
minView :: DeepMap (k ': ks) v -> Maybe (DeepMap ks v, DeepMap (k ': ks) v)
-- | O(log n). Retrieve the value associated with the maximal key of
-- the map, and the map stripped of that element, or Nothing if
-- passed an empty map.
maxView :: DeepMap (k ': ks) v -> Maybe (DeepMap ks v, DeepMap (k ': ks) v)
-- | O(log n). Retrieve the minimal key/value pair of the map, and
-- the map stripped of that element, or Nothing if passed an empty
-- map.
minViewWithKey :: DeepMap (k ': ks) v -> Maybe ((k, DeepMap ks v), DeepMap (k ': ks) v)
-- | O(log n). Retrieve the maximal key/value pair of the map, and
-- the map stripped of that element, or Nothing if passed an empty
-- map.
maxViewWithKey :: DeepMap (k ': ks) v -> Maybe ((k, DeepMap ks v), DeepMap (k ': ks) v)
-- | For use with indexed maps, folds, and traversals.
data Deep ks
pattern D1 :: () => k -> Deep ks -> Deep (k ': ks)
pattern D2 :: (Ord k0, Ord k1) => k0 -> k1 -> Deep ks -> Deep (k0 ': (k1 ': ks))
pattern D3 :: (Ord k0, Ord k1, Ord k2) => k0 -> k1 -> k2 -> Deep ks -> Deep (k0 ': (k1 ': (k2 ': ks)))
pattern D4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => k0 -> k1 -> k2 -> k3 -> Deep ks -> Deep (k0 ': (k1 ': (k2 ': (k3 ': ks))))
pattern D5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => k0 -> k1 -> k2 -> k3 -> k4 -> Deep ks -> Deep (k0 ': (k1 ': (k2 ': (k3 ': (k4 ': ks)))))
instance GHC.Base.Functor (Data.Map.Deep.DeepMap ks)
instance Data.Foldable.Foldable (Data.Map.Deep.DeepMap ks)
instance Data.Traversable.Traversable (Data.Map.Deep.DeepMap ks)
instance GHC.Classes.Eq (Data.Map.Deep.Deep '[])
instance GHC.Classes.Ord (Data.Map.Deep.Deep '[])
instance GHC.Show.Show (Data.Map.Deep.Deep '[])
instance (GHC.Classes.Eq k, GHC.Classes.Eq (Data.Map.Deep.Deep ks)) => GHC.Classes.Eq (Data.Map.Deep.Deep (k : ks))
instance (GHC.Classes.Ord k, GHC.Classes.Ord (Data.Map.Deep.Deep ks)) => GHC.Classes.Ord (Data.Map.Deep.Deep (k : ks))
instance (GHC.Show.Show k, GHC.Show.Show (Data.Map.Deep.Deep ks)) => GHC.Show.Show (Data.Map.Deep.Deep (k : ks))
instance WithIndex.FunctorWithIndex (Data.Map.Deep.Deep ks) (Data.Map.Deep.DeepMap ks)
instance WithIndex.FoldableWithIndex (Data.Map.Deep.Deep ks) (Data.Map.Deep.DeepMap ks)
instance WithIndex.TraversableWithIndex (Data.Map.Deep.Deep ks) (Data.Map.Deep.DeepMap ks)
instance Witherable.FilterableWithIndex (Data.Map.Deep.Deep '[k]) (Data.Map.Deep.DeepMap '[k])
instance Witherable.WitherableWithIndex (Data.Map.Deep.Deep '[k]) (Data.Map.Deep.DeepMap '[k])
instance (GHC.Classes.Ord j, Witherable.FilterableWithIndex (Data.Map.Deep.Deep (k : ks)) (Data.Map.Deep.DeepMap (k : ks))) => Witherable.FilterableWithIndex (Data.Map.Deep.Deep (j : k : ks)) (Data.Map.Deep.DeepMap (j : k : ks))
instance (GHC.Classes.Ord j, Witherable.WitherableWithIndex (Data.Map.Deep.Deep (k : ks)) (Data.Map.Deep.DeepMap (k : ks))) => Witherable.WitherableWithIndex (Data.Map.Deep.Deep (j : k : ks)) (Data.Map.Deep.DeepMap (j : k : ks))
instance GHC.Classes.Eq v => GHC.Classes.Eq (Data.Map.Deep.DeepMap '[] v)
instance (GHC.Classes.Eq k, GHC.Classes.Eq (Data.Map.Deep.DeepMap ks v)) => GHC.Classes.Eq (Data.Map.Deep.DeepMap (k : ks) v)
instance GHC.Classes.Ord v => GHC.Classes.Ord (Data.Map.Deep.DeepMap '[] v)
instance (GHC.Classes.Ord k, GHC.Classes.Ord (Data.Map.Deep.DeepMap ks v)) => GHC.Classes.Ord (Data.Map.Deep.DeepMap (k : ks) v)
instance GHC.Show.Show v => GHC.Show.Show (Data.Map.Deep.DeepMap '[] v)
instance (GHC.Show.Show k, GHC.Show.Show (Data.Map.Deep.DeepMap ks v)) => GHC.Show.Show (Data.Map.Deep.DeepMap (k : ks) v)
instance GHC.Base.Semigroup v => GHC.Base.Semigroup (Data.Map.Deep.DeepMap '[] v)
instance (GHC.Classes.Ord k, GHC.Base.Semigroup (Data.Map.Deep.DeepMap ks v)) => GHC.Base.Semigroup (Data.Map.Deep.DeepMap (k : ks) v)
instance GHC.Base.Monoid v => GHC.Base.Monoid (Data.Map.Deep.DeepMap '[] v)
instance (GHC.Classes.Ord k, GHC.Base.Semigroup (Data.Map.Deep.DeepMap ks v)) => GHC.Base.Monoid (Data.Map.Deep.DeepMap (k : ks) v)
instance Witherable.Filterable (Data.Map.Deep.DeepMap '[k])
instance Witherable.Witherable (Data.Map.Deep.DeepMap '[k])
instance (GHC.Classes.Ord j, Witherable.Filterable (Data.Map.Deep.DeepMap (k : ks))) => Witherable.Filterable (Data.Map.Deep.DeepMap (j : k : ks))
instance (GHC.Classes.Ord j, Witherable.Witherable (Data.Map.Deep.DeepMap (k : ks))) => Witherable.Witherable (Data.Map.Deep.DeepMap (j : k : ks))
instance Data.Data.Data v => Data.Data.Data (Data.Map.Deep.DeepMap '[] v)
instance (GHC.Classes.Ord k, Data.Data.Data k, Data.Typeable.Internal.Typeable ks, Data.Typeable.Internal.Typeable v, Data.Data.Data (Data.Map.Deep.DeepMap ks v)) => Data.Data.Data (Data.Map.Deep.DeepMap (k : ks) v)
instance GHC.Generics.Generic v => GHC.Generics.Generic (Data.Map.Deep.DeepMap '[] v)
instance (GHC.Classes.Ord k, GHC.Generics.Generic k, GHC.Generics.Generic (Data.Map.Deep.DeepMap ks v)) => GHC.Generics.Generic (Data.Map.Deep.DeepMap (k : ks) v)