{-# LANGUAGE UndecidableInstances #-}

-- |
-- Module       : Data.Map.Deep
-- Copyright    : (c) Melanie Brown 2021
-- License      : BSD3 (see the file LICENSE)
-- Maintainer   : brown.m@pm.me
--
-- 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 'Data.Map' from the
-- @containers@ package, with additional convenience functions for working with deep nestings.
module Data.Map.Deep (
    -- * Map type
    DeepMap (..),
    onBare2,
    onNest2,

    -- * Construction
    empty,
    singleton,
    (@>),
    (@|),

    -- ** From Unordered Lists
    fromList,
    fromList1,
    fromList2,
    fromList3,
    fromList4,
    fromList5,
    fromListWith,
    fromListWith1,
    fromListWithKey,
    fromListWithKey1,
    fromListWithKey2,
    fromListWithKey3,
    fromListWithKey4,
    fromListWithKey5,

    -- ** Single-depth map isomorphisms
    toMap,
    fromMap,

    -- * Insertion
    insert,
    insert1,
    insert2,
    insert3,
    insert4,
    insert5,
    insertWith,
    insertWith1,
    insertWith2,
    insertWith3,
    insertWith4,
    insertWith5,
    insertWithKey,
    insertWithKey1,
    insertWithKey2,
    insertWithKey3,
    insertWithKey4,
    insertWithKey5,
    insertLookupWithKey,
    insertLookupWithKey1,
    insertLookupWithKey2,
    insertLookupWithKey3,
    insertLookupWithKey4,
    insertLookupWithKey5,
    overwrite,
    overwrite1,
    overwrite2,
    overwrite3,
    overwrite4,
    overwrite5,
    overwriteLookup,
    overwriteLookup1,
    overwriteLookup2,
    overwriteLookup3,
    overwriteLookup4,
    overwriteLookup5,

    -- * Deletion\/Update
    delete,
    delete1,
    delete2,
    delete3,
    delete4,
    delete5,
    adjust,
    adjust1,
    adjust2,
    adjust3,
    adjust4,
    adjust5,
    adjustWithKey,
    adjustWithKey1,
    adjustWithKey2,
    adjustWithKey3,
    adjustWithKey4,
    adjustWithKey5,
    update,
    update1,
    update2,
    update3,
    update4,
    update5,
    updateWithKey,
    updateWithKey1,
    updateWithKey2,
    updateWithKey3,
    updateWithKey4,
    updateWithKey5,
    updateLookupWithKey,
    updateLookupWithKey1,
    updateLookupWithKey2,
    updateLookupWithKey3,
    updateLookupWithKey4,
    updateLookupWithKey5,
    alter,
    alter1,
    alter2,
    alter3,
    alter4,
    alter5,
    alterF,
    alterF1,
    alterF2,
    alterF3,
    alterF4,
    alterF5,

    -- * Query

    -- ** Lookup
    lookup,
    (@?),
    (@?|),
    (@??),
    (@??|),
    (@!),
    (@!|),
    findWithDefault,
    findWithDefault1,
    findWithDefault2,
    findWithDefault3,
    findWithDefault4,
    findWithDefault5,
    member,
    notMember,
    lookupLT,
    lookupGT,
    lookupLE,
    lookupGE,

    -- ** Size
    null,
    size,

    -- * Combine

    -- ** Union
    union,
    unionWith,
    unionWith1,
    unionWith2,
    unionWith3,
    unionWith4,
    unionWith5,
    unionWithKey,
    unionWithKey1,
    unionWithKey2,
    unionWithKey3,
    unionWithKey4,
    unionWithKey5,
    unions,
    unionsWith,
    unionsWith1,

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

    -- ** Intersection
    intersection,
    intersectionWith,
    intersectionWith1,
    intersectionWithKey,
    intersectionWithKey1,
    intersectionWithKey2,
    intersectionWithKey3,
    intersectionWithKey4,
    intersectionWithKey5,

    -- * Traversal

    -- ** Map
    mapShallow,
    mapShallowWithKey,
    mapWithKey1,
    mapWithKey2,
    mapWithKey3,
    mapWithKey4,
    mapWithKey5,
    traverseShallow,
    traverseShallowWithKey,
    traverseWithKey1,
    traverseWithKey2,
    traverseWithKey3,
    traverseWithKey4,
    traverseWithKey5,
    traverseMaybeWithKey,
    traverseMaybeWithKey1,
    traverseMaybeWithKey2,
    traverseMaybeWithKey3,
    traverseMaybeWithKey4,
    traverseMaybeWithKey5,
    mapAccum,
    mapAccum1,
    mapAccumR,
    mapAccumR1,
    mapAccumWithKey,
    mapAccumWithKey1,
    mapAccumWithKey2,
    mapAccumWithKey3,
    mapAccumWithKey4,
    mapAccumWithKey5,
    mapAccumRWithKey,
    mapAccumRWithKey1,
    mapAccumRWithKey2,
    mapAccumRWithKey3,
    mapAccumRWithKey4,
    mapAccumRWithKey5,
    mapKeys,
    mapKeys1,
    mapKeys2,
    mapKeys3,
    mapKeys4,
    mapKeys5,
    mapKeysWith,
    mapKeysWith1,
    mapKeysWith2,
    mapKeysWith3,
    mapKeysWith4,
    mapKeysWith5,
    traverseKeys,
    traverseKeysWith,
    mapKeysM,
    mapKeysM1,
    mapKeysM2,
    mapKeysM3,
    mapKeysM4,
    mapKeysM5,
    mapKeysMWith,
    mapKeysMWith1,
    mapKeysMWith2,
    mapKeysMWith3,
    mapKeysMWith4,
    mapKeysMWith5,

    -- * Folds
    foldr,
    foldl,
    foldShallow,
    foldrWithKey,
    foldrWithKey1,
    foldrWithKey2,
    foldrWithKey3,
    foldrWithKey4,
    foldrWithKey5,
    foldlWithKey,
    foldlWithKey1,
    foldlWithKey2,
    foldlWithKey3,
    foldlWithKey4,
    foldlWithKey5,
    foldMapWithKey,
    foldMapWithKey1,
    foldMapWithKey2,
    foldMapWithKey3,
    foldMapWithKey4,
    foldMapWithKey5,

    -- ** Strict folds
    foldr',
    foldl',
    foldrWithKey',
    foldrWithKey1',
    foldrWithKey2',
    foldrWithKey3',
    foldrWithKey4',
    foldrWithKey5',
    foldlWithKey',
    foldlWithKey1',
    foldlWithKey2',
    foldlWithKey3',
    foldlWithKey4',
    foldlWithKey5',
    foldMapWithKey',
    foldMapWithKey1',
    foldMapWithKey2',
    foldMapWithKey3',
    foldMapWithKey4',
    foldMapWithKey5',

    -- * Conversion
    elems,
    elems1,
    keys,
    assocs,
    assocs1,
    keysSet,
    invertKeys,

    -- ** Lists
    toList,

    -- *** Ordered lists
    toAscList,
    toDescList,

    -- * Filter
    filter,
    filter1,
    filter2,
    filter3,
    filter4,
    filter5,
    filterWithKey,
    filterWithKey1,
    filterWithKey2,
    filterWithKey3,
    filterWithKey4,
    filterWithKey5,
    restrictKeys,
    restrictKeys2,
    restrictKeys3,
    restrictKeys4,
    restrictKeys5,
    withoutKeys,
    withoutKeys2,
    withoutKeys3,
    withoutKeys4,
    withoutKeys5,
    partition,
    partition1,
    partition2,
    partition3,
    partition4,
    partition5,
    partitionWithKey,
    partitionWithKey1,
    partitionWithKey2,
    partitionWithKey3,
    partitionWithKey4,
    partitionWithKey5,
    takeWhileAntitone,
    dropWhileAntitone,
    spanAntitone,
    mapMaybe,
    mapShallowMaybe,
    mapShallowMaybeWithKey,
    mapMaybeWithKey1,
    mapMaybeWithKey2,
    mapMaybeWithKey3,
    mapMaybeWithKey4,
    mapMaybeWithKey5,
    mapEither,
    mapShallowEither,
    mapShallowEitherWithKey,
    mapEitherWithKey1,
    mapEitherWithKey2,
    mapEitherWithKey3,
    mapEitherWithKey4,
    mapEitherWithKey5,
    split,
    splitLookup,
    splitRoot,

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

    -- * Indexed
    lookupIndex,
    findIndex,
    elemAt,
    updateAt,
    deleteAt,
    take,
    drop,
    splitAt,

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

import Control.Arrow (Arrow ((&&&)), ArrowChoice ((+++), (|||)), (***))
import Data.Bool (bool)
import Data.Data
import Data.Either (isLeft)
import Data.Foldable (Foldable (fold, foldl', foldr', toList))
import Data.Foldable.WithIndex (FoldableWithIndex)
import Data.Functor ((<&>))
import Data.Functor.Compose (Compose (..))
import Data.Functor.Const (Const (..))
import Data.Functor.Identity (Identity (..))
import Data.Functor.WithIndex (FunctorWithIndex)
import Data.Kind (Type)
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import Data.Maybe (fromMaybe)
import Data.Set (Set)
import qualified Data.Set as Set
import Data.Traversable.WithIndex
import GHC.Generics
import Prelude hiding (
    drop,
    filter,
    lookup,
    map,
    null,
    splitAt,
    take,
 )

data DeepMap (ks :: [Type]) (v :: Type) :: Type where
    Bare :: {DeepMap '[] v -> v
getBare :: v} -> DeepMap '[] v
    Nest :: {DeepMap (k : ks) v -> Map k (DeepMap ks v)
getNest :: Map k (DeepMap ks v)} -> DeepMap (k ': ks) v

instance (Eq v) => Eq (DeepMap '[] v) where
    Bare v
v1 == :: DeepMap '[] v -> DeepMap '[] v -> Bool
== Bare v
v2 = v
v1 v -> v -> Bool
forall a. Eq a => a -> a -> Bool
== v
v2

instance (Eq k, Eq (DeepMap ks v)) => Eq (DeepMap (k ': ks) v) where
    Nest Map k (DeepMap ks v)
v1 == :: DeepMap (k : ks) v -> DeepMap (k : ks) v -> Bool
== Nest Map k (DeepMap ks v)
v2 = Map k (DeepMap ks v)
v1 Map k (DeepMap ks v) -> Map k (DeepMap ks v) -> Bool
forall a. Eq a => a -> a -> Bool
== Map k (DeepMap ks v)
Map k (DeepMap ks v)
v2

instance (Ord v) => Ord (DeepMap '[] v) where
    Bare v
v1 <= :: DeepMap '[] v -> DeepMap '[] v -> Bool
<= Bare v
v2 = v
v1 v -> v -> Bool
forall a. Ord a => a -> a -> Bool
<= v
v2

instance (Ord k, Ord (DeepMap ks v)) => Ord (DeepMap (k ': ks) v) where
    Nest Map k (DeepMap ks v)
v1 <= :: DeepMap (k : ks) v -> DeepMap (k : ks) v -> Bool
<= Nest Map k (DeepMap ks v)
v2 = Map k (DeepMap ks v)
v1 Map k (DeepMap ks v) -> Map k (DeepMap ks v) -> Bool
forall a. Ord a => a -> a -> Bool
<= Map k (DeepMap ks v)
Map k (DeepMap ks v)
v2

instance (Show v) => Show (DeepMap '[] v) where
    show :: DeepMap '[] v -> String
show (Bare v
v) = String
"Bare " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> v -> String
forall a. Show a => a -> String
show v
v

instance (Show k, Show (DeepMap ks v)) => Show (DeepMap (k ': ks) v) where
    show :: DeepMap (k : ks) v -> String
show (Nest Map k (DeepMap ks v)
v) = String
"Nest {" String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Map k (DeepMap ks v) -> String
forall a. Show a => a -> String
show Map k (DeepMap ks v)
v String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
"}"

instance (Semigroup v) => Semigroup (DeepMap '[] v) where
    <> :: DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v
(<>) = (v -> v -> v) -> DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v
forall v w x.
(v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x
onBare2 v -> v -> v
forall a. Semigroup a => a -> a -> a
(<>)

instance (Ord k, Semigroup (DeepMap ks v)) => Semigroup (DeepMap (k ': ks) v) where
    <> :: DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
(<>) = (Map k (DeepMap ks v)
 -> Map k (DeepMap ks v) -> Map k (DeepMap ks v))
-> DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
(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
onNest2 ((Map k (DeepMap ks v)
  -> Map k (DeepMap ks v) -> Map k (DeepMap ks v))
 -> DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v)
-> (Map k (DeepMap ks v)
    -> Map k (DeepMap ks v) -> Map k (DeepMap ks v))
-> DeepMap (k : ks) v
-> DeepMap (k : ks) v
-> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> Map k (DeepMap ks v)
-> Map k (DeepMap ks v)
-> Map k (DeepMap ks v)
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith DeepMap ks v -> DeepMap ks v -> DeepMap ks v
forall a. Semigroup a => a -> a -> a
(<>)

instance (Monoid v) => Monoid (DeepMap '[] v) where
    mempty :: DeepMap '[] v
mempty = v -> DeepMap '[] v
forall v. v -> DeepMap '[] v
Bare v
forall a. Monoid a => a
mempty

instance (Ord k, Semigroup (DeepMap ks v)) => Monoid (DeepMap (k ': ks) v) where
    mempty :: DeepMap (k : ks) v
mempty = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest Map k (DeepMap ks v)
forall a. Monoid a => a
mempty

deriving instance Functor (DeepMap ks)

deriving instance Foldable (DeepMap ks)

deriving instance Traversable (DeepMap ks)

instance FunctorWithIndex () (DeepMap '[])

instance FoldableWithIndex () (DeepMap '[])

instance TraversableWithIndex () (DeepMap '[]) where
    itraverse :: (() -> a -> f b) -> DeepMap '[] a -> f (DeepMap '[] b)
itraverse () -> a -> f b
f (Bare a
v) = b -> DeepMap '[] b
forall v. v -> DeepMap '[] v
Bare (b -> DeepMap '[] b) -> f b -> f (DeepMap '[] b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> () -> a -> f b
f () a
v

instance (TraversableWithIndex ki (DeepMap ks)) => FunctorWithIndex (k, ki) (DeepMap (k ': ks))

instance (TraversableWithIndex ki (DeepMap ks)) => FoldableWithIndex (k, ki) (DeepMap (k ': ks))

instance (TraversableWithIndex ki (DeepMap ks)) => TraversableWithIndex (k, ki) (DeepMap (k ': ks)) where
    itraverse :: ((k, ki) -> a -> f b)
-> DeepMap (k : ks) a -> f (DeepMap (k : ks) b)
itraverse (k, ki) -> a -> f b
f = (k -> DeepMap ks a -> f (DeepMap ks b))
-> DeepMap (k : ks) a -> f (DeepMap (k : ks) b)
forall (f :: * -> *) k (ks :: [*]) v (ls :: [*]) w.
Applicative f =>
(k -> DeepMap ks v -> f (DeepMap ls w))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseShallowWithKey ((ki -> a -> f b) -> DeepMap ks a -> f (DeepMap ks b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse ((ki -> a -> f b) -> DeepMap ks a -> f (DeepMap ks b))
-> (k -> ki -> a -> f b) -> k -> DeepMap ks a -> f (DeepMap ks b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((k, ki) -> a -> f b) -> k -> ki -> a -> f b
forall a b c. ((a, b) -> c) -> a -> b -> c
curry (k, ki) -> a -> f b
f)

deriving instance (Typeable v) => Typeable (DeepMap '[] v)

deriving instance (Typeable k, Typeable (DeepMap ks v)) => Typeable (DeepMap (k ': ks) v)

tyDeepMap :: DataType
tyDeepMap :: DataType
tyDeepMap = String -> [Constr] -> DataType
mkDataType String
"Data.Map.Monoidal.Deep.DeepMap" [Constr
conBare, Constr
conNest]

conBare, conNest :: Constr
conBare :: Constr
conBare = DataType -> String -> [String] -> Fixity -> Constr
mkConstr DataType
tyDeepMap String
"Bare" [] Fixity
Data.Data.Prefix
conNest :: Constr
conNest = DataType -> String -> [String] -> Fixity -> Constr
mkConstr DataType
tyDeepMap String
"Nest" [] Fixity
Data.Data.Prefix

instance (Data v) => Data (DeepMap '[] v) where
    dataTypeOf :: DeepMap '[] v -> DataType
dataTypeOf DeepMap '[] v
_ = DataType
tyDeepMap
    toConstr :: DeepMap '[] v -> Constr
toConstr (Bare v
_) = Constr
conBare
    gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DeepMap '[] v)
gunfold forall b r. Data b => c (b -> r) -> c r
k forall r. r -> c r
z Constr
_ = c (v -> DeepMap '[] v) -> c (DeepMap '[] v)
forall b r. Data b => c (b -> r) -> c r
k ((v -> DeepMap '[] v) -> c (v -> DeepMap '[] v)
forall r. r -> c r
z v -> DeepMap '[] v
forall v. v -> DeepMap '[] v
Bare)

instance (Ord k, Data k, Typeable ks, Typeable v, Data (DeepMap ks v)) => Data (DeepMap (k ': ks) v) where
    dataTypeOf :: DeepMap (k : ks) v -> DataType
dataTypeOf DeepMap (k : ks) v
_ = DataType
tyDeepMap
    toConstr :: DeepMap (k : ks) v -> Constr
toConstr (Nest Map k (DeepMap ks v)
_) = Constr
conNest
    gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DeepMap (k : ks) v)
gunfold forall b r. Data b => c (b -> r) -> c r
k forall r. r -> c r
z Constr
_ = c (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> c (DeepMap (k : ks) v)
forall b r. Data b => c (b -> r) -> c r
k ((Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> c (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
forall r. r -> c r
z Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest)

instance (Generic v) => Generic (DeepMap '[] v) where
    type Rep (DeepMap '[] v) = Const v
    from :: DeepMap '[] v -> Rep (DeepMap '[] v) x
from (Bare v
v) = v -> Const v x
forall k a (b :: k). a -> Const a b
Const v
v
    to :: Rep (DeepMap '[] v) x -> DeepMap '[] v
to (Const v) = v -> DeepMap '[] v
forall v. v -> DeepMap '[] v
Bare v
v

instance (Ord k, Generic k, Generic (DeepMap ks v)) => Generic (DeepMap (k ': ks) v) where
    type Rep (DeepMap (k ': ks) v) = Compose [] (Const k :*: Rep (DeepMap ks v))
    from :: DeepMap (k : ks) v -> Rep (DeepMap (k : ks) v) x
from DeepMap (k : ks) v
m = [(:*:) (Const k) (Rep (DeepMap ks v)) x]
-> Compose [] (Const k :*: Rep (DeepMap ks v)) x
forall k k1 (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose ([(:*:) (Const k) (Rep (DeepMap ks v)) x]
 -> Compose [] (Const k :*: Rep (DeepMap ks v)) x)
-> [(:*:) (Const k) (Rep (DeepMap ks v)) x]
-> Compose [] (Const k :*: Rep (DeepMap ks v)) x
forall a b. (a -> b) -> a -> b
$ (\(k
k, DeepMap ks v
dm) -> k -> Const k x
forall k a (b :: k). a -> Const a b
Const k
k Const k x
-> Rep (DeepMap ks v) x -> (:*:) (Const k) (Rep (DeepMap ks v)) x
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*: DeepMap ks v -> Rep (DeepMap ks v) x
forall a x. Generic a => a -> Rep a x
from DeepMap ks v
dm) ((k, DeepMap ks v) -> (:*:) (Const k) (Rep (DeepMap ks v)) x)
-> [(k, DeepMap ks v)] -> [(:*:) (Const k) (Rep (DeepMap ks v)) x]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DeepMap (k : ks) v -> [(k, DeepMap ks v)]
forall k (ks :: [*]) v. DeepMap (k : ks) v -> [(k, DeepMap ks v)]
assocs DeepMap (k : ks) v
m
    to :: Rep (DeepMap (k : ks) v) x -> DeepMap (k : ks) v
to (Compose kvs) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> ([(k, DeepMap ks v)] -> Map k (DeepMap ks v))
-> [(k, DeepMap ks v)]
-> DeepMap (k : ks) v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(k, DeepMap ks v)] -> Map k (DeepMap ks v)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(k, DeepMap ks v)] -> DeepMap (k : ks) v)
-> [(k, DeepMap ks v)] -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (\(Const k
k :*: Rep (DeepMap ks v) x
dm') -> (k
k, Rep (DeepMap ks v) x -> DeepMap ks v
forall a x. Generic a => Rep a x -> a
to Rep (DeepMap ks v) x
dm')) ((:*:) (Const k) (Rep (DeepMap ks v)) x -> (k, DeepMap ks v))
-> [(:*:) (Const k) (Rep (DeepMap ks v)) x] -> [(k, DeepMap ks v)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(:*:) (Const k) (Rep (DeepMap ks v)) x]
kvs

-- | Apply a two-argument function through a shallow 'DeepMap', akin to 'liftA2'.
onBare2 :: (v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x
onBare2 :: (v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x
onBare2 v -> w -> x
f (Bare v
v) (Bare w
w) = x -> DeepMap '[] x
forall v. v -> DeepMap '[] v
Bare (x -> DeepMap '[] x) -> x -> DeepMap '[] x
forall a b. (a -> b) -> a -> b
$ v -> w -> x
f v
v w
w

-- | Apply a two-argument function through a shallow 'DeepMap', akin to 'liftA2'.
onBare2F :: (Functor f) => (v -> w -> f x) -> DeepMap '[] v -> DeepMap '[] w -> f (DeepMap '[] x)
onBare2F :: (v -> w -> f x)
-> DeepMap '[] v -> DeepMap '[] w -> f (DeepMap '[] x)
onBare2F v -> w -> f x
f (Bare v
v) (Bare w
w) = x -> DeepMap '[] x
forall v. v -> DeepMap '[] v
Bare (x -> DeepMap '[] x) -> f x -> f (DeepMap '[] x)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> v -> w -> f x
f v
v w
w

-- | Apply a two-argument 'Map' function through a deep 'DeepMap', akin to 'liftA2'.
onNest2 :: (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
onNest2 :: (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
onNest2 Map k (DeepMap ks v)
-> Map k (DeepMap ls w) -> Map k (DeepMap ms x)
f (Nest Map k (DeepMap ks v)
v) (Nest Map k (DeepMap ks w)
w) = Map k (DeepMap ms x) -> DeepMap (k : ms) x
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ms x) -> DeepMap (k : ms) x)
-> Map k (DeepMap ms x) -> DeepMap (k : ms) x
forall a b. (a -> b) -> a -> b
$ Map k (DeepMap ks v)
-> Map k (DeepMap ls w) -> Map k (DeepMap ms x)
f Map k (DeepMap ks v)
Map k (DeepMap ks v)
v Map k (DeepMap ls w)
Map k (DeepMap ks w)
w

-- | Half of the isomorphism of a depth-1 'DeepMap' to a 'Data.Map.Strict.Map'. See also 'fromMap'.
toMap :: DeepMap (k ': '[]) v -> Map k v
toMap :: DeepMap '[k] v -> Map k v
toMap (Nest Map k (DeepMap ks v)
m) = DeepMap '[] v -> v
forall v. DeepMap '[] v -> v
getBare (DeepMap '[] v -> v) -> Map k (DeepMap '[] v) -> Map k v
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map k (DeepMap ks v)
Map k (DeepMap '[] v)
m

-- | Half of the isomorphism of a depth-1 'DeepMap' to a 'Data.Map.Strict.Map'. See also 'toMap'.
fromMap :: Map k v -> DeepMap '[k] v
fromMap :: Map k v -> DeepMap '[k] v
fromMap Map k v
m = Map k (DeepMap '[] v) -> DeepMap '[k] v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (v -> DeepMap '[] v
forall v. v -> DeepMap '[] v
Bare (v -> DeepMap '[] v) -> Map k v -> Map k (DeepMap '[] v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map k v
m)

-- | A singleton 'DeepMap'. Use with '(@|)' to create deep nestings:
--
-- >>> "Outer" @> 0 @| [5]
-- Nest {fromList [("Outer",Nest {fromList [(0,Bare [5])]})]}
infixr 6 @>

(@>) :: k -> DeepMap ks v -> DeepMap (k ': ks) v
k
k @> :: k -> DeepMap ks v -> DeepMap (k : ks) v
@> DeepMap ks v
a = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ k -> DeepMap ks v -> Map k (DeepMap ks v)
forall k a. k -> a -> Map k a
Map.singleton k
k DeepMap ks v
a
{-# INLINE (@>) #-}

-- | Infix synonym for 'singleton'. Use with '(@>)' to create deep nestings:
--
-- >>> "Outer" @> 0 @| [5]
-- Nest {fromList [("Outer",Nest {fromList [(0,Bare [5])]})]}
infixr 6 @|

(@|) :: k -> v -> DeepMap '[k] v
k
k @| :: k -> v -> DeepMap '[k] v
@| v
a = Map k (DeepMap '[] v) -> DeepMap '[k] v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap '[] v) -> DeepMap '[k] v)
-> (DeepMap '[] v -> Map k (DeepMap '[] v))
-> DeepMap '[] v
-> DeepMap '[k] v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> DeepMap '[] v -> Map k (DeepMap '[] v)
forall k a. k -> a -> Map k a
Map.singleton k
k (DeepMap '[] v -> DeepMap '[k] v)
-> DeepMap '[] v -> DeepMap '[k] v
forall a b. (a -> b) -> a -> b
$ v -> DeepMap '[] v
forall v. v -> DeepMap '[] v
Bare v
a
{-# INLINE (@|) #-}

-- | /O(1)/. The empty, arbitrary positive-depth 'DeepMap'.
empty :: DeepMap (k ': ks) v
empty :: DeepMap (k : ks) v
empty = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest Map k (DeepMap ks v)
forall k a. Map k a
Map.empty

-- | /O(1)/. A depth-1 'DeepMap' with a single key/value pair.
singleton :: k -> v -> DeepMap '[k] v
singleton :: k -> v -> DeepMap '[k] v
singleton k
k v
v = Map k (DeepMap '[] v) -> DeepMap '[k] v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap '[] v) -> DeepMap '[k] v)
-> (DeepMap '[] v -> Map k (DeepMap '[] v))
-> DeepMap '[] v
-> DeepMap '[k] v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> DeepMap '[] v -> Map k (DeepMap '[] v)
forall k a. k -> a -> Map k a
Map.singleton k
k (DeepMap '[] v -> DeepMap '[k] v)
-> DeepMap '[] v -> DeepMap '[k] v
forall a b. (a -> b) -> a -> b
$ v -> DeepMap '[] v
forall v. v -> DeepMap '[] v
Bare v
v

-- | /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]
elems :: DeepMap (k : ks) v -> [DeepMap ks v]
elems (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> [DeepMap ks v]
forall k a. Map k a -> [a]
Map.elems Map k (DeepMap ks v)
m

-- | /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]
elems1 :: DeepMap '[k] v -> [v]
elems1 DeepMap '[k] v
m = DeepMap '[] v -> v
forall v. DeepMap '[] v -> v
getBare (DeepMap '[] v -> v) -> [DeepMap '[] v] -> [v]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DeepMap '[k] v -> [DeepMap '[] v]
forall k (ks :: [*]) v. DeepMap (k : ks) v -> [DeepMap ks v]
elems DeepMap '[k] v
m

-- | /O(n)/. Return all keys of the map in ascending order. Subject to list fusion.
keys :: DeepMap (k ': ks) v -> [k]
keys :: DeepMap (k : ks) v -> [k]
keys (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> [k]
forall k a. Map k a -> [k]
Map.keys Map k (DeepMap ks v)
m

-- | /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)]
assocs :: DeepMap (k : ks) v -> [(k, DeepMap ks v)]
assocs (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> [(k, DeepMap ks v)]
forall k a. Map k a -> [(k, a)]
Map.assocs Map k (DeepMap ks v)
m

-- | /O(n)/. Return all pairs of the singly-nested map in ascending key order. Subject to list fusion.
assocs1 :: DeepMap '[k] v -> [(k, v)]
assocs1 :: DeepMap '[k] v -> [(k, v)]
assocs1 DeepMap '[k] v
dm = (DeepMap '[] v -> v) -> (k, DeepMap '[] v) -> (k, v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DeepMap '[] v -> v
forall v. DeepMap '[] v -> v
getBare ((k, DeepMap '[] v) -> (k, v)) -> [(k, DeepMap '[] v)] -> [(k, v)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DeepMap '[k] v -> [(k, DeepMap '[] v)]
forall k (ks :: [*]) v. DeepMap (k : ks) v -> [(k, DeepMap ks v)]
assocs DeepMap '[k] v
dm

-- | /O(n)/. The set of all keys of the map.
keysSet :: DeepMap (k ': ks) v -> Set k
keysSet :: DeepMap (k : ks) v -> Set k
keysSet (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> Set k
forall k a. Map k a -> Set k
Map.keysSet Map k (DeepMap ks v)
m

-- | /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
fromList :: [(k, DeepMap ks v)] -> DeepMap (k : ks) v
fromList [(k, DeepMap ks v)]
kvs = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> [(k, DeepMap ks v)] -> Map k (DeepMap ks v)
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith ((DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> DeepMap ks v -> DeepMap ks v -> DeepMap ks v
forall a b c. (a -> b -> c) -> b -> a -> c
flip DeepMap ks v -> DeepMap ks v -> DeepMap ks v
forall a. Semigroup a => a -> a -> a
(<>)) [(k, DeepMap ks v)]
kvs

-- | /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
fromList1 :: [(k, v)] -> DeepMap '[k] v
fromList1 = ((k, v) -> DeepMap '[k] v) -> [(k, v)] -> DeepMap '[k] v
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ((k -> v -> DeepMap '[k] v) -> (k, v) -> DeepMap '[k] v
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry k -> v -> DeepMap '[k] v
forall k 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
fromList2 :: [(k0, k1, v)] -> DeepMap '[k0, k1] v
fromList2 = ((k0, k1, v) -> DeepMap '[k0, k1] v)
-> [(k0, k1, v)] -> DeepMap '[k0, k1] v
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (\(k0
k0, k1
k1, v
v) -> k0
k0 k0 -> DeepMap '[k1] v -> DeepMap '[k0, k1] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k1
k1 k1 -> v -> DeepMap '[k1] v
forall k v. k -> v -> DeepMap '[k] v
@| v
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
fromList3 :: [(k0, k1, k2, v)] -> DeepMap '[k0, k1, k2] v
fromList3 = ((k0, k1, k2, v) -> DeepMap '[k0, k1, k2] v)
-> [(k0, k1, k2, v)] -> DeepMap '[k0, k1, k2] v
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (\(k0
k0, k1
k1, k2
k2, v
v) -> k0
k0 k0 -> DeepMap '[k1, k2] v -> DeepMap '[k0, k1, k2] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k1
k1 k1 -> DeepMap '[k2] v -> DeepMap '[k1, k2] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k2
k2 k2 -> v -> DeepMap '[k2] v
forall k v. k -> v -> DeepMap '[k] v
@| v
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
fromList4 :: [(k0, k1, k2, k3, v)] -> DeepMap '[k0, k1, k2, k3] v
fromList4 = ((k0, k1, k2, k3, v) -> DeepMap '[k0, k1, k2, k3] v)
-> [(k0, k1, k2, k3, v)] -> DeepMap '[k0, k1, k2, k3] v
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (\(k0
k0, k1
k1, k2
k2, k3
k3, v
v) -> k0
k0 k0 -> DeepMap '[k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k1
k1 k1 -> DeepMap '[k2, k3] v -> DeepMap '[k1, k2, k3] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k2
k2 k2 -> DeepMap '[k3] v -> DeepMap '[k2, k3] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k3
k3 k3 -> v -> DeepMap '[k3] v
forall k v. k -> v -> DeepMap '[k] v
@| v
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
fromList5 :: [(k0, k1, k2, k3, k4, v)] -> DeepMap '[k0, k1, k2, k3, k4] v
fromList5 = ((k0, k1, k2, k3, k4, v) -> DeepMap '[k0, k1, k2, k3, k4] v)
-> [(k0, k1, k2, k3, k4, v)] -> DeepMap '[k0, k1, k2, k3, k4] v
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (\(k0
k0, k1
k1, k2
k2, k3
k3, k4
k4, v
v) -> k0
k0 k0
-> DeepMap '[k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k1
k1 k1 -> DeepMap '[k2, k3, k4] v -> DeepMap '[k1, k2, k3, k4] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k2
k2 k2 -> DeepMap '[k3, k4] v -> DeepMap '[k2, k3, k4] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k3
k3 k3 -> DeepMap '[k4] v -> DeepMap '[k3, k4] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k4
k4 k4 -> v -> DeepMap '[k4] v
forall k v. k -> v -> DeepMap '[k] v
@| v
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
fromListWith :: (DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> [(k, DeepMap ks v)] -> DeepMap (k : ks) v
fromListWith DeepMap ks v -> DeepMap ks v -> DeepMap ks v
f [(k, DeepMap ks v)]
kvs = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> [(k, DeepMap ks v)] -> Map k (DeepMap ks v)
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith DeepMap ks v -> DeepMap ks v -> DeepMap ks v
f [(k, DeepMap ks v)]
kvs

-- | /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
fromListWith1 :: (v -> v -> v) -> [(k, v)] -> DeepMap '[k] v
fromListWith1 v -> v -> v
f [(k, v)]
kvs = Map k (DeepMap '[] v) -> DeepMap '[k] v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap '[] v) -> DeepMap '[k] v)
-> Map k (DeepMap '[] v) -> DeepMap '[k] v
forall a b. (a -> b) -> a -> b
$ v -> DeepMap '[] v
forall v. v -> DeepMap '[] v
Bare (v -> DeepMap '[] v) -> Map k v -> Map k (DeepMap '[] v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (v -> v -> v) -> [(k, v)] -> Map k v
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith v -> v -> v
f [(k, v)]
kvs

-- | /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
fromListWithKey :: (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> [(k, DeepMap ks v)] -> DeepMap (k : ks) v
fromListWithKey k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v
f [(k, DeepMap ks v)]
kvs = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> [(k, DeepMap ks v)] -> Map k (DeepMap ks v)
forall k a. Ord k => (k -> a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWithKey k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v
f [(k, DeepMap ks v)]
kvs

-- | /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
fromListWithKey1 :: (k -> v -> v -> v) -> [(k, v)] -> DeepMap '[k] v
fromListWithKey1 k -> v -> v -> v
f [(k, v)]
kvs = Map k (DeepMap '[] v) -> DeepMap '[k] v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap '[] v) -> DeepMap '[k] v)
-> Map k (DeepMap '[] v) -> DeepMap '[k] v
forall a b. (a -> b) -> a -> b
$ v -> DeepMap '[] v
forall v. v -> DeepMap '[] v
Bare (v -> DeepMap '[] v) -> Map k v -> Map k (DeepMap '[] v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (k -> v -> v -> v) -> [(k, v)] -> Map k v
forall k a. Ord k => (k -> a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWithKey k -> v -> v -> v
f [(k, v)]
kvs

-- | /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
fromListWithKey2 :: (k0 -> k1 -> v -> v -> v) -> [(k0, k1, v)] -> DeepMap '[k0, k1] v
fromListWithKey2 k0 -> k1 -> v -> v -> v
f [(k0, k1, v)]
kvs =
    (k0 -> DeepMap '[k1] v -> DeepMap '[k1] v -> DeepMap '[k1] v)
-> [(k0, DeepMap '[k1] v)] -> DeepMap '[k0, k1] v
forall k (ks :: [*]) v.
Ord k =>
(k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> [(k, DeepMap ks v)] -> DeepMap (k : ks) v
fromListWithKey ((k1 -> v -> v -> v)
-> DeepMap '[k1] v -> DeepMap '[k1] v -> DeepMap '[k1] v
forall k v.
Ord k =>
(k -> v -> v -> v)
-> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
unionWithKey1 ((k1 -> v -> v -> v)
 -> DeepMap '[k1] v -> DeepMap '[k1] v -> DeepMap '[k1] v)
-> (k0 -> k1 -> v -> v -> v)
-> k0
-> DeepMap '[k1] v
-> DeepMap '[k1] v
-> DeepMap '[k1] v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> v -> v -> v
f) ([(k0, DeepMap '[k1] v)] -> DeepMap '[k0, k1] v)
-> [(k0, DeepMap '[k1] v)] -> DeepMap '[k0, k1] v
forall a b. (a -> b) -> a -> b
$
        (\(k0
k0, k1
k1, v
v) -> (k0
k0, k1
k1 k1 -> v -> DeepMap '[k1] v
forall k v. k -> v -> DeepMap '[k] v
@| v
v)) ((k0, k1, v) -> (k0, DeepMap '[k1] v))
-> [(k0, k1, v)] -> [(k0, DeepMap '[k1] v)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(k0, k1, v)]
kvs

-- | /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
fromListWithKey3 :: (k0 -> k1 -> k2 -> v -> v -> v)
-> [(k0, k1, k2, v)] -> DeepMap '[k0, k1, k2] v
fromListWithKey3 k0 -> k1 -> k2 -> v -> v -> v
f [(k0, k1, k2, v)]
kvs =
    (k0
 -> DeepMap '[k1, k2] v
 -> DeepMap '[k1, k2] v
 -> DeepMap '[k1, k2] v)
-> [(k0, DeepMap '[k1, k2] v)] -> DeepMap '[k0, k1, k2] v
forall k (ks :: [*]) v.
Ord k =>
(k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> [(k, DeepMap ks v)] -> DeepMap (k : ks) v
fromListWithKey ((k1 -> k2 -> v -> v -> v)
-> DeepMap '[k1, k2] v
-> DeepMap '[k1, k2] v
-> DeepMap '[k1, k2] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
(k0 -> k1 -> v -> v -> v)
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] v
unionWithKey2 ((k1 -> k2 -> v -> v -> v)
 -> DeepMap '[k1, k2] v
 -> DeepMap '[k1, k2] v
 -> DeepMap '[k1, k2] v)
-> (k0 -> k1 -> k2 -> v -> v -> v)
-> k0
-> DeepMap '[k1, k2] v
-> DeepMap '[k1, k2] v
-> DeepMap '[k1, k2] v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> v -> v -> v
f) ([(k0, DeepMap '[k1, k2] v)] -> DeepMap '[k0, k1, k2] v)
-> [(k0, DeepMap '[k1, k2] v)] -> DeepMap '[k0, k1, k2] v
forall a b. (a -> b) -> a -> b
$
        (\(k0
k0, k1
k1, k2
k2, v
v) -> (k0
k0, k1
k1 k1 -> DeepMap '[k2] v -> DeepMap '[k1, k2] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k2
k2 k2 -> v -> DeepMap '[k2] v
forall k v. k -> v -> DeepMap '[k] v
@| v
v)) ((k0, k1, k2, v) -> (k0, DeepMap '[k1, k2] v))
-> [(k0, k1, k2, v)] -> [(k0, DeepMap '[k1, k2] v)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(k0, k1, k2, v)]
kvs

-- | /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
fromListWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> v -> v)
-> [(k0, k1, k2, k3, v)] -> DeepMap '[k0, k1, k2, k3] v
fromListWithKey4 k0 -> k1 -> k2 -> k3 -> v -> v -> v
f [(k0, k1, k2, k3, v)]
kvs =
    (k0
 -> DeepMap '[k1, k2, k3] v
 -> DeepMap '[k1, k2, k3] v
 -> DeepMap '[k1, k2, k3] v)
-> [(k0, DeepMap '[k1, k2, k3] v)] -> DeepMap '[k0, k1, k2, k3] v
forall k (ks :: [*]) v.
Ord k =>
(k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> [(k, DeepMap ks v)] -> DeepMap (k : ks) v
fromListWithKey ((k1 -> k2 -> k3 -> v -> v -> v)
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
forall k0 k1 k2 v.
(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
unionWithKey3 ((k1 -> k2 -> k3 -> v -> v -> v)
 -> DeepMap '[k1, k2, k3] v
 -> DeepMap '[k1, k2, k3] v
 -> DeepMap '[k1, k2, k3] v)
-> (k0 -> k1 -> k2 -> k3 -> v -> v -> v)
-> k0
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> v -> v -> v
f) ([(k0, DeepMap '[k1, k2, k3] v)] -> DeepMap '[k0, k1, k2, k3] v)
-> [(k0, DeepMap '[k1, k2, k3] v)] -> DeepMap '[k0, k1, k2, k3] v
forall a b. (a -> b) -> a -> b
$
        (\(k0
k0, k1
k1, k2
k2, k3
k3, v
v) -> (k0
k0, k1
k1 k1 -> DeepMap '[k2, k3] v -> DeepMap '[k1, k2, k3] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k2
k2 k2 -> DeepMap '[k3] v -> DeepMap '[k2, k3] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k3
k3 k3 -> v -> DeepMap '[k3] v
forall k v. k -> v -> DeepMap '[k] v
@| v
v)) ((k0, k1, k2, k3, v) -> (k0, DeepMap '[k1, k2, k3] v))
-> [(k0, k1, k2, k3, v)] -> [(k0, DeepMap '[k1, k2, k3] v)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(k0, k1, k2, k3, v)]
kvs

-- | /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
fromListWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v)
-> [(k0, k1, k2, k3, k4, v)] -> DeepMap '[k0, k1, k2, k3, k4] v
fromListWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v
f [(k0, k1, k2, k3, k4, v)]
kvs =
    (k0
 -> DeepMap '[k1, k2, k3, k4] v
 -> DeepMap '[k1, k2, k3, k4] v
 -> DeepMap '[k1, k2, k3, k4] v)
-> [(k0, DeepMap '[k1, k2, k3, k4] v)]
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k (ks :: [*]) v.
Ord k =>
(k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> [(k, DeepMap ks v)] -> DeepMap (k : ks) v
fromListWithKey ((k1 -> k2 -> k3 -> k4 -> v -> v -> v)
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
forall k0 k1 k2 k3 v.
(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
unionWithKey4 ((k1 -> k2 -> k3 -> k4 -> v -> v -> v)
 -> DeepMap '[k1, k2, k3, k4] v
 -> DeepMap '[k1, k2, k3, k4] v
 -> DeepMap '[k1, k2, k3, k4] v)
-> (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v)
-> k0
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v
f) ([(k0, DeepMap '[k1, k2, k3, k4] v)]
 -> DeepMap '[k0, k1, k2, k3, k4] v)
-> [(k0, DeepMap '[k1, k2, k3, k4] v)]
-> DeepMap '[k0, k1, k2, k3, k4] v
forall a b. (a -> b) -> a -> b
$
        (\(k0
k0, k1
k1, k2
k2, k3
k3, k4
k4, v
v) -> (k0
k0, k1
k1 k1 -> DeepMap '[k2, k3, k4] v -> DeepMap '[k1, k2, k3, k4] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k2
k2 k2 -> DeepMap '[k3, k4] v -> DeepMap '[k2, k3, k4] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k3
k3 k3 -> DeepMap '[k4] v -> DeepMap '[k3, k4] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k4
k4 k4 -> v -> DeepMap '[k4] v
forall k v. k -> v -> DeepMap '[k] v
@| v
v)) ((k0, k1, k2, k3, k4, v) -> (k0, DeepMap '[k1, k2, k3, k4] v))
-> [(k0, k1, k2, k3, k4, v)] -> [(k0, DeepMap '[k1, k2, k3, k4] v)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(k0, k1, k2, k3, k4, v)]
kvs

-- | /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 'Data.Semigroup.Last' or by using 'overwrite'.
insert :: (Ord k, Semigroup (DeepMap ks v)) => k -> DeepMap ks v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
insert :: k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
insert k
k DeepMap ks v
dm (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> k
-> DeepMap ks v
-> Map k (DeepMap ks v)
-> Map k (DeepMap ks v)
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith ((DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> DeepMap ks v -> DeepMap ks v -> DeepMap ks v
forall a b c. (a -> b -> c) -> b -> a -> c
flip DeepMap ks v -> DeepMap ks v -> DeepMap ks v
forall a. Semigroup a => a -> a -> a
(<>)) k
k DeepMap ks v
dm Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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 'Data.Semigroup.Last' or by using 'overwrite1'.
insert1 :: (Ord k, Semigroup v) => k -> v -> DeepMap '[k] v -> DeepMap '[k] v
insert1 :: k -> v -> DeepMap '[k] v -> DeepMap '[k] v
insert1 k
k v
v DeepMap '[k] v
m = DeepMap '[k] v
m DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
forall a. Semigroup a => a -> a -> a
<> k
k k -> v -> DeepMap '[k] v
forall k v. k -> v -> DeepMap '[k] v
@| v
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 'Data.Semigroup.Last' or by using 'overwrite2'.
insert2 :: (Ord k0, Ord k1, Semigroup v) => k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
insert2 :: k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
insert2 k0
k0 k1
k1 v
v DeepMap '[k0, k1] v
m = DeepMap '[k0, k1] v
m DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall a. Semigroup a => a -> a -> a
<> k0
k0 k0 -> DeepMap '[k1] v -> DeepMap '[k0, k1] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k1
k1 k1 -> v -> DeepMap '[k1] v
forall k v. k -> v -> DeepMap '[k] v
@| v
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 'Data.Semigroup.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
insert3 :: k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
insert3 k0
k0 k1
k1 k2
k2 v
v DeepMap '[k0, k1, k2] v
m = DeepMap '[k0, k1, k2] v
m DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
forall a. Semigroup a => a -> a -> a
<> k0
k0 k0 -> DeepMap '[k1, k2] v -> DeepMap '[k0, k1, k2] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k1
k1 k1 -> DeepMap '[k2] v -> DeepMap '[k1, k2] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k2
k2 k2 -> v -> DeepMap '[k2] v
forall k v. k -> v -> DeepMap '[k] v
@| v
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 'Data.Semigroup.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
insert4 :: k0
-> k1
-> k2
-> k3
-> v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
insert4 k0
k0 k1
k1 k2
k2 k3
k3 v
v DeepMap '[k0, k1, k2, k3] v
m = DeepMap '[k0, k1, k2, k3] v
m DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
forall a. Semigroup a => a -> a -> a
<> k0
k0 k0 -> DeepMap '[k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k1
k1 k1 -> DeepMap '[k2, k3] v -> DeepMap '[k1, k2, k3] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k2
k2 k2 -> DeepMap '[k3] v -> DeepMap '[k2, k3] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k3
k3 k3 -> v -> DeepMap '[k3] v
forall k v. k -> v -> DeepMap '[k] v
@| v
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 'Data.Semigroup.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
insert5 :: k0
-> k1
-> k2
-> k3
-> k4
-> v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
insert5 k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 v
v DeepMap '[k0, k1, k2, k3, k4] v
m = DeepMap '[k0, k1, k2, k3, k4] v
m DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall a. Semigroup a => a -> a -> a
<> k0
k0 k0
-> DeepMap '[k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k1
k1 k1 -> DeepMap '[k2, k3, k4] v -> DeepMap '[k1, k2, k3, k4] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k2
k2 k2 -> DeepMap '[k3, k4] v -> DeepMap '[k2, k3, k4] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k3
k3 k3 -> DeepMap '[k4] v -> DeepMap '[k3, k4] v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> k4
k4 k4 -> v -> DeepMap '[k4] v
forall k v. k -> v -> DeepMap '[k] v
@| v
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
overwrite :: k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k
k DeepMap ks v
v (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ k -> DeepMap ks v -> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert k
k DeepMap ks v
v Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
overwrite1 :: k -> v -> DeepMap '[k] v -> DeepMap '[k] v
overwrite1 k
k v
v = k -> DeepMap '[] v -> DeepMap '[k] v -> DeepMap '[k] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k
k (v -> DeepMap '[] v
forall v. v -> DeepMap '[] v
Bare v
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
overwrite2 :: k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
overwrite2 k0
k0 k1
k1 v
v DeepMap '[k0, k1] v
m = k0 -> DeepMap '[k1] v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 (k1 -> DeepMap '[] v -> DeepMap '[k1] v -> DeepMap '[k1] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k1
k1 (v -> DeepMap '[] v
forall v. v -> DeepMap '[] v
Bare v
v) (DeepMap '[k1] v -> DeepMap '[k1] v)
-> (Maybe (DeepMap '[k1] v) -> DeepMap '[k1] v)
-> Maybe (DeepMap '[k1] v)
-> DeepMap '[k1] v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DeepMap '[k1] v -> Maybe (DeepMap '[k1] v) -> DeepMap '[k1] v
forall a. a -> Maybe a -> a
fromMaybe DeepMap '[k1] v
forall k (ks :: [*]) v. DeepMap (k : ks) v
empty (Maybe (DeepMap '[k1] v) -> DeepMap '[k1] v)
-> Maybe (DeepMap '[k1] v) -> DeepMap '[k1] v
forall a b. (a -> b) -> a -> b
$ DeepMap '[k0, k1] v
m DeepMap '[k0, k1] v -> k0 -> Maybe (DeepMap '[k1] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0) DeepMap '[k0, k1] v
m

-- | /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
overwrite3 :: k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
overwrite3 k0
k0 k1
k1 k2
k2 v
v DeepMap '[k0, k1, k2] v
m = k0
-> DeepMap '[k1, k2] v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 (k1 -> k2 -> v -> DeepMap '[k1, k2] v -> DeepMap '[k1, k2] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
overwrite2 k1
k1 k2
k2 v
v (DeepMap '[k1, k2] v -> DeepMap '[k1, k2] v)
-> (Maybe (DeepMap '[k1, k2] v) -> DeepMap '[k1, k2] v)
-> Maybe (DeepMap '[k1, k2] v)
-> DeepMap '[k1, k2] v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DeepMap '[k1, k2] v
-> Maybe (DeepMap '[k1, k2] v) -> DeepMap '[k1, k2] v
forall a. a -> Maybe a -> a
fromMaybe DeepMap '[k1, k2] v
forall k (ks :: [*]) v. DeepMap (k : ks) v
empty (Maybe (DeepMap '[k1, k2] v) -> DeepMap '[k1, k2] v)
-> Maybe (DeepMap '[k1, k2] v) -> DeepMap '[k1, k2] v
forall a b. (a -> b) -> a -> b
$ DeepMap '[k0, k1, k2] v
m DeepMap '[k0, k1, k2] v -> k0 -> Maybe (DeepMap '[k1, k2] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0) DeepMap '[k0, k1, k2] v
m

-- | /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
overwrite4 :: k0
-> k1
-> k2
-> k3
-> v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
overwrite4 k0
k0 k1
k1 k2
k2 k3
k3 v
v DeepMap '[k0, k1, k2, k3] v
m = k0
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 (k1
-> k2
-> k3
-> v
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
forall k0 k1 k2 v.
(Ord k0, Ord k1, Ord k2) =>
k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
overwrite3 k1
k1 k2
k2 k3
k3 v
v (DeepMap '[k1, k2, k3] v -> DeepMap '[k1, k2, k3] v)
-> (Maybe (DeepMap '[k1, k2, k3] v) -> DeepMap '[k1, k2, k3] v)
-> Maybe (DeepMap '[k1, k2, k3] v)
-> DeepMap '[k1, k2, k3] v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DeepMap '[k1, k2, k3] v
-> Maybe (DeepMap '[k1, k2, k3] v) -> DeepMap '[k1, k2, k3] v
forall a. a -> Maybe a -> a
fromMaybe DeepMap '[k1, k2, k3] v
forall k (ks :: [*]) v. DeepMap (k : ks) v
empty (Maybe (DeepMap '[k1, k2, k3] v) -> DeepMap '[k1, k2, k3] v)
-> Maybe (DeepMap '[k1, k2, k3] v) -> DeepMap '[k1, k2, k3] v
forall a b. (a -> b) -> a -> b
$ DeepMap '[k0, k1, k2, k3] v
m DeepMap '[k0, k1, k2, k3] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0) DeepMap '[k0, k1, k2, k3] v
m

-- | /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
overwrite5 :: k0
-> k1
-> k2
-> k3
-> k4
-> v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
overwrite5 k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 v
v DeepMap '[k0, k1, k2, k3, k4] v
m = k0
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 (k1
-> k2
-> k3
-> k4
-> v
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
forall k0 k1 k2 k3 v.
(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
overwrite4 k1
k1 k2
k2 k3
k3 k4
k4 v
v (DeepMap '[k1, k2, k3, k4] v -> DeepMap '[k1, k2, k3, k4] v)
-> (Maybe (DeepMap '[k1, k2, k3, k4] v)
    -> DeepMap '[k1, k2, k3, k4] v)
-> Maybe (DeepMap '[k1, k2, k3, k4] v)
-> DeepMap '[k1, k2, k3, k4] v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DeepMap '[k1, k2, k3, k4] v
-> Maybe (DeepMap '[k1, k2, k3, k4] v)
-> DeepMap '[k1, k2, k3, k4] v
forall a. a -> Maybe a -> a
fromMaybe DeepMap '[k1, k2, k3, k4] v
forall k (ks :: [*]) v. DeepMap (k : ks) v
empty (Maybe (DeepMap '[k1, k2, k3, k4] v)
 -> DeepMap '[k1, k2, k3, k4] v)
-> Maybe (DeepMap '[k1, k2, k3, k4] v)
-> DeepMap '[k1, k2, k3, k4] v
forall a b. (a -> b) -> a -> b
$ DeepMap '[k0, k1, k2, k3, k4] v
m DeepMap '[k0, k1, k2, k3, k4] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0) DeepMap '[k0, k1, k2, k3, k4] v
m

-- | /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)
overwriteLookup :: k
-> DeepMap ks v
-> DeepMap (k : ks) v
-> (Maybe (DeepMap ks v), DeepMap (k : ks) v)
overwriteLookup k
k DeepMap ks v
v (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> (Maybe (DeepMap ks v), Map k (DeepMap ks v))
-> (Maybe (DeepMap ks v), DeepMap (k : ks) v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> k
-> DeepMap ks v
-> Map k (DeepMap ks v)
-> (Maybe (DeepMap ks v), Map k (DeepMap ks v))
forall k a.
Ord k =>
(k -> a -> a -> a) -> k -> a -> Map k a -> (Maybe a, Map k a)
Map.insertLookupWithKey ((DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v
forall a b. a -> b -> a
const DeepMap ks v -> DeepMap ks v -> DeepMap ks v
forall a b. a -> b -> a
const) k
k DeepMap ks v
v Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /O(log n)/. Combines replacement and retrieval at depth 1.
overwriteLookup1 :: (Ord k) => k -> v -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v)
overwriteLookup1 :: k -> v -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v)
overwriteLookup1 k
k v
v DeepMap '[k] v
m = (DeepMap '[k] v
m DeepMap '[k] v -> k -> Maybe v
forall k v. Ord k => DeepMap '[k] v -> k -> Maybe v
@?| k
k, k -> v -> DeepMap '[k] v -> DeepMap '[k] v
forall k v. Ord k => k -> v -> DeepMap '[k] v -> DeepMap '[k] v
overwrite1 k
k v
v DeepMap '[k] v
m)

-- | /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)
overwriteLookup2 :: k0
-> k1 -> v -> DeepMap '[k0, k1] v -> (Maybe v, DeepMap '[k0, k1] v)
overwriteLookup2 k0
k0 k1
k1 v
v DeepMap '[k0, k1] v
m = (DeepMap '[k0, k1] v
m DeepMap '[k0, k1] v -> k0 -> Maybe (DeepMap '[k1] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1] v) -> k1 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k1
k1, k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
overwrite2 k0
k0 k1
k1 v
v DeepMap '[k0, k1] v
m)

-- | /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)
overwriteLookup3 :: k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> (Maybe v, DeepMap '[k0, k1, k2] v)
overwriteLookup3 k0
k0 k1
k1 k2
k2 v
v DeepMap '[k0, k1, k2] v
m = (DeepMap '[k0, k1, k2] v
m DeepMap '[k0, k1, k2] v -> k0 -> Maybe (DeepMap '[k1, k2] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1, k2] v) -> k1 -> Maybe (DeepMap '[k2] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k1
k1 Maybe (DeepMap '[k2] v) -> k2 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k2
k2, k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
forall k0 k1 k2 v.
(Ord k0, Ord k1, Ord k2) =>
k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
overwrite3 k0
k0 k1
k1 k2
k2 v
v DeepMap '[k0, k1, k2] v
m)

-- | /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)
overwriteLookup4 :: k0
-> k1
-> k2
-> k3
-> v
-> DeepMap '[k0, k1, k2, k3] v
-> (Maybe v, DeepMap '[k0, k1, k2, k3] v)
overwriteLookup4 k0
k0 k1
k1 k2
k2 k3
k3 v
v DeepMap '[k0, k1, k2, k3] v
m = (DeepMap '[k0, k1, k2, k3] v
m DeepMap '[k0, k1, k2, k3] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1, k2, k3] v)
-> k1 -> Maybe (DeepMap '[k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k1
k1 Maybe (DeepMap '[k2, k3] v) -> k2 -> Maybe (DeepMap '[k3] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k2
k2 Maybe (DeepMap '[k3] v) -> k3 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k3
k3, k0
-> k1
-> k2
-> k3
-> v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k0 k1 k2 k3 v.
(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
overwrite4 k0
k0 k1
k1 k2
k2 k3
k3 v
v DeepMap '[k0, k1, k2, k3] v
m)

-- | /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)
overwriteLookup5 :: k0
-> k1
-> k2
-> k3
-> k4
-> v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> (Maybe v, DeepMap '[k0, k1, k2, k3, k4] v)
overwriteLookup5 k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 v
v DeepMap '[k0, k1, k2, k3, k4] v
m = (DeepMap '[k0, k1, k2, k3, k4] v
m DeepMap '[k0, k1, k2, k3, k4] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1, k2, k3, k4] v)
-> k1 -> Maybe (DeepMap '[k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k1
k1 Maybe (DeepMap '[k2, k3, k4] v)
-> k2 -> Maybe (DeepMap '[k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k2
k2 Maybe (DeepMap '[k3, k4] v) -> k3 -> Maybe (DeepMap '[k4] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k3
k3 Maybe (DeepMap '[k4] v) -> k4 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k4
k4, k0
-> k1
-> k2
-> k3
-> k4
-> v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k0 k1 k2 k3 k4 v.
(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
overwrite5 k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 v
v DeepMap '[k0, k1, k2, k3, k4] v
m)

-- | /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
insertWith :: (DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
insertWith DeepMap ks v -> DeepMap ks v -> DeepMap ks v
f k
k DeepMap ks v
v (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> k
-> DeepMap ks v
-> Map k (DeepMap ks v)
-> Map k (DeepMap ks v)
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith DeepMap ks v -> DeepMap ks v -> DeepMap ks v
f k
k DeepMap ks v
v Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
insertWith1 :: (v -> v -> v) -> k -> v -> DeepMap '[k] v -> DeepMap '[k] v
insertWith1 v -> v -> v
f k
k v
v = (DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v)
-> k -> DeepMap '[] v -> DeepMap '[k] v -> DeepMap '[k] v
forall k (ks :: [*]) v.
Ord k =>
(DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
insertWith ((v -> v -> v) -> DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v
forall v w x.
(v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x
onBare2 v -> v -> v
f) k
k (v -> DeepMap '[] v
forall v. v -> DeepMap '[] v
Bare v
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
insertWith2 :: (v -> v -> v)
-> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
insertWith2 v -> v -> v
f k0
k0 k1
k1 v
v DeepMap '[k0, k1] v
m = case DeepMap '[k0, k1] v
m DeepMap '[k0, k1] v -> k0 -> Maybe (DeepMap '[k1] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1] v)
Nothing -> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
overwrite2 k0
k0 k1
k1 v
v DeepMap '[k0, k1] v
m
    Just DeepMap '[k1] v
dm -> k0 -> DeepMap '[k1] v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((v -> v -> v) -> k1 -> v -> DeepMap '[k1] v -> DeepMap '[k1] v
forall k v.
Ord k =>
(v -> v -> v) -> k -> v -> DeepMap '[k] v -> DeepMap '[k] v
insertWith1 v -> v -> v
f k1
k1 v
v DeepMap '[k1] v
dm) DeepMap '[k0, k1] v
m

-- | /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
insertWith3 :: (v -> v -> v)
-> k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
insertWith3 v -> v -> v
f k0
k0 k1
k1 k2
k2 v
v DeepMap '[k0, k1, k2] v
m = case DeepMap '[k0, k1, k2] v
m DeepMap '[k0, k1, k2] v -> k0 -> Maybe (DeepMap '[k1, k2] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2] v)
Nothing -> k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
forall k0 k1 k2 v.
(Ord k0, Ord k1, Ord k2) =>
k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
overwrite3 k0
k0 k1
k1 k2
k2 v
v DeepMap '[k0, k1, k2] v
m
    Just DeepMap '[k1, k2] v
dm -> k0
-> DeepMap '[k1, k2] v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((v -> v -> v)
-> k1 -> k2 -> v -> DeepMap '[k1, k2] v -> DeepMap '[k1, k2] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
(v -> v -> v)
-> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
insertWith2 v -> v -> v
f k1
k1 k2
k2 v
v DeepMap '[k1, k2] v
dm) DeepMap '[k0, k1, k2] v
m

-- | /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
insertWith4 :: (v -> v -> v)
-> k0
-> k1
-> k2
-> k3
-> v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
insertWith4 v -> v -> v
f k0
k0 k1
k1 k2
k2 k3
k3 v
v DeepMap '[k0, k1, k2, k3] v
m = case DeepMap '[k0, k1, k2, k3] v
m DeepMap '[k0, k1, k2, k3] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2, k3] v)
Nothing -> k0
-> k1
-> k2
-> k3
-> v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k0 k1 k2 k3 v.
(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
overwrite4 k0
k0 k1
k1 k2
k2 k3
k3 v
v DeepMap '[k0, k1, k2, k3] v
m
    Just DeepMap '[k1, k2, k3] v
dm -> k0
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((v -> v -> v)
-> k1
-> k2
-> k3
-> v
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
forall k0 k1 k2 v.
(Ord k0, Ord k1, Ord k2) =>
(v -> v -> v)
-> k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
insertWith3 v -> v -> v
f k1
k1 k2
k2 k3
k3 v
v DeepMap '[k1, k2, k3] v
dm) DeepMap '[k0, k1, k2, k3] v
m

-- | /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
insertWith5 :: (v -> v -> v)
-> k0
-> k1
-> k2
-> k3
-> k4
-> v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
insertWith5 v -> v -> v
f k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 v
v DeepMap '[k0, k1, k2, k3, k4] v
m = case DeepMap '[k0, k1, k2, k3, k4] v
m DeepMap '[k0, k1, k2, k3, k4] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2, k3, k4] v)
Nothing -> k0
-> k1
-> k2
-> k3
-> k4
-> v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k0 k1 k2 k3 k4 v.
(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
overwrite5 k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 v
v DeepMap '[k0, k1, k2, k3, k4] v
m
    Just DeepMap '[k1, k2, k3, k4] v
dm -> k0
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((v -> v -> v)
-> k1
-> k2
-> k3
-> k4
-> v
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
forall k0 k1 k2 k3 v.
(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
insertWith4 v -> v -> v
f k1
k1 k2
k2 k3
k3 k4
k4 v
v DeepMap '[k1, k2, k3, k4] v
dm) DeepMap '[k0, k1, k2, k3, k4] v
m

-- | /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
insertWithKey :: (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
insertWithKey k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v
f k
k DeepMap ks v
v (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> k
-> DeepMap ks v
-> Map k (DeepMap ks v)
-> Map k (DeepMap ks v)
forall k a.
Ord k =>
(k -> a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWithKey k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v
f k
k DeepMap ks v
v Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
insertWithKey1 :: (k -> v -> v -> v) -> k -> v -> DeepMap '[k] v -> DeepMap '[k] v
insertWithKey1 k -> v -> v -> v
f k
k v
v = (k -> DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v)
-> k -> DeepMap '[] v -> DeepMap '[k] v -> DeepMap '[k] v
forall k (ks :: [*]) v.
Ord k =>
(k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
insertWithKey ((v -> v -> v) -> DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v
forall v w x.
(v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x
onBare2 ((v -> v -> v) -> DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v)
-> (k -> v -> v -> v)
-> k
-> DeepMap '[] v
-> DeepMap '[] v
-> DeepMap '[] v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> v -> v -> v
f) k
k (v -> DeepMap '[] v
forall v. v -> DeepMap '[] v
Bare v
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
insertWithKey2 :: (k0 -> k1 -> v -> v -> v)
-> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
insertWithKey2 k0 -> k1 -> v -> v -> v
f k0
k0 k1
k1 v
v DeepMap '[k0, k1] v
m = case DeepMap '[k0, k1] v
m DeepMap '[k0, k1] v -> k0 -> Maybe (DeepMap '[k1] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1] v)
Nothing -> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
overwrite2 k0
k0 k1
k1 v
v DeepMap '[k0, k1] v
m
    Just DeepMap '[k1] v
dm -> k0 -> DeepMap '[k1] v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((k1 -> v -> v -> v)
-> k1 -> v -> DeepMap '[k1] v -> DeepMap '[k1] v
forall k v.
Ord k =>
(k -> v -> v -> v) -> k -> v -> DeepMap '[k] v -> DeepMap '[k] v
insertWithKey1 (k0 -> k1 -> v -> v -> v
f k0
k0) k1
k1 v
v DeepMap '[k1] v
dm) DeepMap '[k0, k1] v
m

-- | /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
insertWithKey3 :: (k0 -> k1 -> k2 -> v -> v -> v)
-> k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
insertWithKey3 k0 -> k1 -> k2 -> v -> v -> v
f k0
k0 k1
k1 k2
k2 v
v DeepMap '[k0, k1, k2] v
m = case DeepMap '[k0, k1, k2] v
m DeepMap '[k0, k1, k2] v -> k0 -> Maybe (DeepMap '[k1, k2] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2] v)
Nothing -> k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
forall k0 k1 k2 v.
(Ord k0, Ord k1, Ord k2) =>
k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
overwrite3 k0
k0 k1
k1 k2
k2 v
v DeepMap '[k0, k1, k2] v
m
    Just DeepMap '[k1, k2] v
dm -> k0
-> DeepMap '[k1, k2] v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((k1 -> k2 -> v -> v -> v)
-> k1 -> k2 -> v -> DeepMap '[k1, k2] v -> DeepMap '[k1, k2] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
(k0 -> k1 -> v -> v -> v)
-> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
insertWithKey2 (k0 -> k1 -> k2 -> v -> v -> v
f k0
k0) k1
k1 k2
k2 v
v DeepMap '[k1, k2] v
dm) DeepMap '[k0, k1, k2] v
m

-- | /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
insertWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> v -> v)
-> k0
-> k1
-> k2
-> k3
-> v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
insertWithKey4 k0 -> k1 -> k2 -> k3 -> v -> v -> v
f k0
k0 k1
k1 k2
k2 k3
k3 v
v DeepMap '[k0, k1, k2, k3] v
m = case DeepMap '[k0, k1, k2, k3] v
m DeepMap '[k0, k1, k2, k3] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2, k3] v)
Nothing -> k0
-> k1
-> k2
-> k3
-> v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k0 k1 k2 k3 v.
(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
overwrite4 k0
k0 k1
k1 k2
k2 k3
k3 v
v DeepMap '[k0, k1, k2, k3] v
m
    Just DeepMap '[k1, k2, k3] v
dm -> k0
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((k1 -> k2 -> k3 -> v -> v -> v)
-> k1
-> k2
-> k3
-> v
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
forall k0 k1 k2 v.
(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
insertWithKey3 (k0 -> k1 -> k2 -> k3 -> v -> v -> v
f k0
k0) k1
k1 k2
k2 k3
k3 v
v DeepMap '[k1, k2, k3] v
dm) DeepMap '[k0, k1, k2, k3] v
m

-- | /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
insertWithKey5 :: (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
insertWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v
f k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 v
v DeepMap '[k0, k1, k2, k3, k4] v
m = case DeepMap '[k0, k1, k2, k3, k4] v
m DeepMap '[k0, k1, k2, k3, k4] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2, k3, k4] v)
Nothing -> k0
-> k1
-> k2
-> k3
-> k4
-> v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k0 k1 k2 k3 k4 v.
(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
overwrite5 k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 v
v DeepMap '[k0, k1, k2, k3, k4] v
m
    Just DeepMap '[k1, k2, k3, k4] v
dm -> k0
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((k1 -> k2 -> k3 -> k4 -> v -> v -> v)
-> k1
-> k2
-> k3
-> k4
-> v
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
forall k0 k1 k2 k3 v.
(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
insertWithKey4 (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v
f k0
k0) k1
k1 k2
k2 k3
k3 k4
k4 v
v DeepMap '[k1, k2, k3, k4] v
dm) DeepMap '[k0, k1, k2, k3, k4] v
m

-- | /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)
insertLookupWithKey :: (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)
insertLookupWithKey k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v
f k
k DeepMap ks v
v (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> (Maybe (DeepMap ks v), Map k (DeepMap ks v))
-> (Maybe (DeepMap ks v), DeepMap (k : ks) v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> k
-> DeepMap ks v
-> Map k (DeepMap ks v)
-> (Maybe (DeepMap ks v), Map k (DeepMap ks v))
forall k a.
Ord k =>
(k -> a -> a -> a) -> k -> a -> Map k a -> (Maybe a, Map k a)
Map.insertLookupWithKey k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v
f k
k DeepMap ks v
v Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /O(log n)/. Combines insertion and retrieval.
insertLookupWithKey1 :: (Ord k) => (k -> v -> v -> v) -> k -> v -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v)
insertLookupWithKey1 :: (k -> v -> v -> v)
-> k -> v -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v)
insertLookupWithKey1 k -> v -> v -> v
f k
k v
v DeepMap '[k] v
m = (DeepMap '[k] v
m DeepMap '[k] v -> k -> Maybe v
forall k v. Ord k => DeepMap '[k] v -> k -> Maybe v
@?| k
k, (k -> v -> v -> v) -> k -> v -> DeepMap '[k] v -> DeepMap '[k] v
forall k v.
Ord k =>
(k -> v -> v -> v) -> k -> v -> DeepMap '[k] v -> DeepMap '[k] v
insertWithKey1 k -> v -> v -> v
f k
k v
v DeepMap '[k] v
m)

-- | /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)
insertLookupWithKey2 :: (k0 -> k1 -> v -> v -> v)
-> k0
-> k1
-> v
-> DeepMap '[k0, k1] v
-> (Maybe v, DeepMap '[k0, k1] v)
insertLookupWithKey2 k0 -> k1 -> v -> v -> v
f k0
k0 k1
k1 v
v DeepMap '[k0, k1] v
m = (DeepMap '[k0, k1] v
m DeepMap '[k0, k1] v -> k0 -> Maybe (DeepMap '[k1] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1] v) -> k1 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k1
k1, (k0 -> k1 -> v -> v -> v)
-> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
(k0 -> k1 -> v -> v -> v)
-> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
insertWithKey2 k0 -> k1 -> v -> v -> v
f k0
k0 k1
k1 v
v DeepMap '[k0, k1] v
m)

-- | /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)
insertLookupWithKey3 :: (k0 -> k1 -> k2 -> v -> v -> v)
-> k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> (Maybe v, DeepMap '[k0, k1, k2] v)
insertLookupWithKey3 k0 -> k1 -> k2 -> v -> v -> v
f k0
k0 k1
k1 k2
k2 v
v DeepMap '[k0, k1, k2] v
m = (DeepMap '[k0, k1, k2] v
m DeepMap '[k0, k1, k2] v -> k0 -> Maybe (DeepMap '[k1, k2] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1, k2] v) -> k1 -> Maybe (DeepMap '[k2] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k1
k1 Maybe (DeepMap '[k2] v) -> k2 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k2
k2, (k0 -> k1 -> k2 -> v -> v -> v)
-> k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
forall k0 k1 k2 v.
(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
insertWithKey3 k0 -> k1 -> k2 -> v -> v -> v
f k0
k0 k1
k1 k2
k2 v
v DeepMap '[k0, k1, k2] v
m)

-- | /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)
insertLookupWithKey4 :: (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)
insertLookupWithKey4 k0 -> k1 -> k2 -> k3 -> v -> v -> v
f k0
k0 k1
k1 k2
k2 k3
k3 v
v DeepMap '[k0, k1, k2, k3] v
m = (DeepMap '[k0, k1, k2, k3] v
m DeepMap '[k0, k1, k2, k3] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1, k2, k3] v)
-> k1 -> Maybe (DeepMap '[k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k1
k1 Maybe (DeepMap '[k2, k3] v) -> k2 -> Maybe (DeepMap '[k3] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k2
k2 Maybe (DeepMap '[k3] v) -> k3 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k3
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
forall k0 k1 k2 k3 v.
(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
insertWithKey4 k0 -> k1 -> k2 -> k3 -> v -> v -> v
f k0
k0 k1
k1 k2
k2 k3
k3 v
v DeepMap '[k0, k1, k2, k3] v
m)

-- | /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)
insertLookupWithKey5 :: (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)
insertLookupWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v
f k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 v
v DeepMap '[k0, k1, k2, k3, k4] v
m = (DeepMap '[k0, k1, k2, k3, k4] v
m DeepMap '[k0, k1, k2, k3, k4] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1, k2, k3, k4] v)
-> k1 -> Maybe (DeepMap '[k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k1
k1 Maybe (DeepMap '[k2, k3, k4] v)
-> k2 -> Maybe (DeepMap '[k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k2
k2 Maybe (DeepMap '[k3, k4] v) -> k3 -> Maybe (DeepMap '[k4] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k3
k3 Maybe (DeepMap '[k4] v) -> k4 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k4
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
forall k0 k1 k2 k3 k4 v.
(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
insertWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v
f k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 v
v DeepMap '[k0, k1, k2, k3, k4] v
m)

-- | /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
delete :: k -> DeepMap (k : ks) v -> DeepMap (k : ks) v
delete k
k (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ k -> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall k a. Ord k => k -> Map k a -> Map k a
Map.delete k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
delete1 :: k -> DeepMap '[k] v -> DeepMap '[k] v
delete1 = k -> DeepMap '[k] v -> DeepMap '[k] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap (k : ks) v -> DeepMap (k : ks) v
delete

-- | /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
delete2 :: k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
delete2 k0
k0 k1
k1 DeepMap '[k0, k1] v
m = case DeepMap '[k0, k1] v
m DeepMap '[k0, k1] v -> k0 -> Maybe (DeepMap '[k1] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1] v)
Nothing -> DeepMap '[k0, k1] v
m
    Just DeepMap '[k1] v
dm -> k0 -> DeepMap '[k1] v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 (k1 -> DeepMap '[k1] v -> DeepMap '[k1] v
forall k v. Ord k => k -> DeepMap '[k] v -> DeepMap '[k] v
delete1 k1
k1 DeepMap '[k1] v
dm) DeepMap '[k0, k1] v
m

-- | /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
delete3 :: k0
-> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
delete3 k0
k0 k1
k1 k2
k2 DeepMap '[k0, k1, k2] v
m = case DeepMap '[k0, k1, k2] v
m DeepMap '[k0, k1, k2] v -> k0 -> Maybe (DeepMap '[k1, k2] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2] v)
Nothing -> DeepMap '[k0, k1, k2] v
m
    Just DeepMap '[k1, k2] v
dm -> k0
-> DeepMap '[k1, k2] v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 (k1 -> k2 -> DeepMap '[k1, k2] v -> DeepMap '[k1, k2] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
delete2 k1
k1 k2
k2 DeepMap '[k1, k2] v
dm) DeepMap '[k0, k1, k2] v
m

-- | /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
delete4 :: k0
-> k1
-> k2
-> k3
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
delete4 k0
k0 k1
k1 k2
k2 k3
k3 DeepMap '[k0, k1, k2, k3] v
m = case DeepMap '[k0, k1, k2, k3] v
m DeepMap '[k0, k1, k2, k3] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2, k3] v)
Nothing -> DeepMap '[k0, k1, k2, k3] v
m
    Just DeepMap '[k1, k2, k3] v
dm -> k0
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 (k1
-> k2 -> k3 -> DeepMap '[k1, k2, k3] v -> DeepMap '[k1, k2, k3] v
forall k0 k1 k2 v.
(Ord k0, Ord k1, Ord k2) =>
k0
-> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
delete3 k1
k1 k2
k2 k3
k3 DeepMap '[k1, k2, k3] v
dm) DeepMap '[k0, k1, k2, k3] v
m

-- | /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
delete5 :: k0
-> k1
-> k2
-> k3
-> k4
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
delete5 k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 DeepMap '[k0, k1, k2, k3, k4] v
m = case DeepMap '[k0, k1, k2, k3, k4] v
m DeepMap '[k0, k1, k2, k3, k4] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2, k3, k4] v)
Nothing -> DeepMap '[k0, k1, k2, k3, k4] v
m
    Just DeepMap '[k1, k2, k3, k4] v
dm -> k0
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 (k1
-> k2
-> k3
-> k4
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
forall k0 k1 k2 k3 v.
(Ord k0, Ord k1, Ord k2, Ord k3) =>
k0
-> k1
-> k2
-> k3
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
delete4 k1
k1 k2
k2 k3
k3 k4
k4 DeepMap '[k1, k2, k3, k4] v
dm) DeepMap '[k0, k1, k2, k3, k4] v
m

-- | /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
adjust :: (DeepMap ks v -> DeepMap ks v)
-> k -> DeepMap (k : ks) v -> DeepMap (k : ks) v
adjust DeepMap ks v -> DeepMap ks v
f k
k (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (DeepMap ks v -> DeepMap ks v)
-> k -> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall k a. Ord k => (a -> a) -> k -> Map k a -> Map k a
Map.adjust DeepMap ks v -> DeepMap ks v
f k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
adjust1 :: (v -> v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
adjust1 v -> v
f = (DeepMap '[] v -> DeepMap '[] v)
-> k -> DeepMap '[k] v -> DeepMap '[k] v
forall k (ks :: [*]) v.
Ord k =>
(DeepMap ks v -> DeepMap ks v)
-> k -> DeepMap (k : ks) v -> DeepMap (k : ks) v
adjust ((v -> v) -> DeepMap '[] v -> DeepMap '[] v
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap v -> v
f)

-- | /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
adjust2 :: (v -> v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
adjust2 v -> v
f k0
k0 k1
k1 DeepMap '[k0, k1] v
m = case DeepMap '[k0, k1] v
m DeepMap '[k0, k1] v -> k0 -> Maybe (DeepMap '[k1] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1] v)
Nothing -> DeepMap '[k0, k1] v
m
    Just DeepMap '[k1] v
dm -> k0 -> DeepMap '[k1] v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((v -> v) -> k1 -> DeepMap '[k1] v -> DeepMap '[k1] v
forall k v.
Ord k =>
(v -> v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
adjust1 v -> v
f k1
k1 DeepMap '[k1] v
dm) DeepMap '[k0, k1] v
m

-- | /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
adjust3 :: (v -> v)
-> k0
-> k1
-> k2
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
adjust3 v -> v
f k0
k0 k1
k1 k2
k2 DeepMap '[k0, k1, k2] v
m = case DeepMap '[k0, k1, k2] v
m DeepMap '[k0, k1, k2] v -> k0 -> Maybe (DeepMap '[k1, k2] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2] v)
Nothing -> DeepMap '[k0, k1, k2] v
m
    Just DeepMap '[k1, k2] v
dm -> k0
-> DeepMap '[k1, k2] v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((v -> v) -> k1 -> k2 -> DeepMap '[k1, k2] v -> DeepMap '[k1, k2] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
(v -> v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
adjust2 v -> v
f k1
k1 k2
k2 DeepMap '[k1, k2] v
dm) DeepMap '[k0, k1, k2] v
m

-- | /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
adjust4 :: (v -> v)
-> k0
-> k1
-> k2
-> k3
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
adjust4 v -> v
f k0
k0 k1
k1 k2
k2 k3
k3 DeepMap '[k0, k1, k2, k3] v
m = case DeepMap '[k0, k1, k2, k3] v
m DeepMap '[k0, k1, k2, k3] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2, k3] v)
Nothing -> DeepMap '[k0, k1, k2, k3] v
m
    Just DeepMap '[k1, k2, k3] v
dm -> k0
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((v -> v)
-> k1
-> k2
-> k3
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
forall k0 k1 k2 v.
(Ord k0, Ord k1, Ord k2) =>
(v -> v)
-> k0
-> k1
-> k2
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
adjust3 v -> v
f k1
k1 k2
k2 k3
k3 DeepMap '[k1, k2, k3] v
dm) DeepMap '[k0, k1, k2, k3] v
m

-- | /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
adjust5 :: (v -> v)
-> k0
-> k1
-> k2
-> k3
-> k4
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
adjust5 v -> v
f k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 DeepMap '[k0, k1, k2, k3, k4] v
m = case DeepMap '[k0, k1, k2, k3, k4] v
m DeepMap '[k0, k1, k2, k3, k4] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2, k3, k4] v)
Nothing -> DeepMap '[k0, k1, k2, k3, k4] v
m
    Just DeepMap '[k1, k2, k3, k4] v
dm -> k0
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((v -> v)
-> k1
-> k2
-> k3
-> k4
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
forall k0 k1 k2 k3 v.
(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
adjust4 v -> v
f k1
k1 k2
k2 k3
k3 k4
k4 DeepMap '[k1, k2, k3, k4] v
dm) DeepMap '[k0, k1, k2, k3, k4] v
m

-- | /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
adjustWithKey :: (k -> DeepMap ks v -> DeepMap ks v)
-> k -> DeepMap (k : ks) v -> DeepMap (k : ks) v
adjustWithKey k -> DeepMap ks v -> DeepMap ks v
f k
k (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (k -> DeepMap ks v -> DeepMap ks v)
-> k -> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall k a. Ord k => (k -> a -> a) -> k -> Map k a -> Map k a
Map.adjustWithKey k -> DeepMap ks v -> DeepMap ks v
f k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
adjustWithKey1 :: (k -> v -> v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
adjustWithKey1 k -> v -> v
f = (k -> DeepMap '[] v -> DeepMap '[] v)
-> k -> DeepMap '[k] v -> DeepMap '[k] v
forall k (ks :: [*]) v.
Ord k =>
(k -> DeepMap ks v -> DeepMap ks v)
-> k -> DeepMap (k : ks) v -> DeepMap (k : ks) v
adjustWithKey ((v -> v) -> DeepMap '[] v -> DeepMap '[] v
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((v -> v) -> DeepMap '[] v -> DeepMap '[] v)
-> (k -> v -> v) -> k -> DeepMap '[] v -> DeepMap '[] v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> v -> v
f)

-- | /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
adjustWithKey2 :: (k0 -> k1 -> v -> v)
-> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
adjustWithKey2 k0 -> k1 -> v -> v
f k0
k0 k1
k1 DeepMap '[k0, k1] v
m = case DeepMap '[k0, k1] v
m DeepMap '[k0, k1] v -> k0 -> Maybe (DeepMap '[k1] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1] v)
Nothing -> DeepMap '[k0, k1] v
m
    Just DeepMap '[k1] v
dm -> k0 -> DeepMap '[k1] v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((k1 -> v -> v) -> k1 -> DeepMap '[k1] v -> DeepMap '[k1] v
forall k v.
Ord k =>
(k -> v -> v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
adjustWithKey1 (k0 -> k1 -> v -> v
f k0
k0) k1
k1 DeepMap '[k1] v
dm) DeepMap '[k0, k1] v
m

-- | /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
adjustWithKey3 :: (k0 -> k1 -> k2 -> v -> v)
-> k0
-> k1
-> k2
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
adjustWithKey3 k0 -> k1 -> k2 -> v -> v
f k0
k0 k1
k1 k2
k2 DeepMap '[k0, k1, k2] v
m = case DeepMap '[k0, k1, k2] v
m DeepMap '[k0, k1, k2] v -> k0 -> Maybe (DeepMap '[k1, k2] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2] v)
Nothing -> DeepMap '[k0, k1, k2] v
m
    Just DeepMap '[k1, k2] v
dm -> k0
-> DeepMap '[k1, k2] v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((k1 -> k2 -> v -> v)
-> k1 -> k2 -> DeepMap '[k1, k2] v -> DeepMap '[k1, k2] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
(k0 -> k1 -> v -> v)
-> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
adjustWithKey2 (k0 -> k1 -> k2 -> v -> v
f k0
k0) k1
k1 k2
k2 DeepMap '[k1, k2] v
dm) DeepMap '[k0, k1, k2] v
m

-- | /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
adjustWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> v)
-> k0
-> k1
-> k2
-> k3
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
adjustWithKey4 k0 -> k1 -> k2 -> k3 -> v -> v
f k0
k0 k1
k1 k2
k2 k3
k3 DeepMap '[k0, k1, k2, k3] v
m = case DeepMap '[k0, k1, k2, k3] v
m DeepMap '[k0, k1, k2, k3] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2, k3] v)
Nothing -> DeepMap '[k0, k1, k2, k3] v
m
    Just DeepMap '[k1, k2, k3] v
dm -> k0
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((k1 -> k2 -> k3 -> v -> v)
-> k1
-> k2
-> k3
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
forall k0 k1 k2 v.
(Ord k0, Ord k1, Ord k2) =>
(k0 -> k1 -> k2 -> v -> v)
-> k0
-> k1
-> k2
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
adjustWithKey3 (k0 -> k1 -> k2 -> k3 -> v -> v
f k0
k0) k1
k1 k2
k2 k3
k3 DeepMap '[k1, k2, k3] v
dm) DeepMap '[k0, k1, k2, k3] v
m

-- | /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
adjustWithKey5 :: (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
adjustWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> v
f k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 DeepMap '[k0, k1, k2, k3, k4] v
m = case DeepMap '[k0, k1, k2, k3, k4] v
m DeepMap '[k0, k1, k2, k3, k4] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2, k3, k4] v)
Nothing -> DeepMap '[k0, k1, k2, k3, k4] v
m
    Just DeepMap '[k1, k2, k3, k4] v
dm -> k0
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((k1 -> k2 -> k3 -> k4 -> v -> v)
-> k1
-> k2
-> k3
-> k4
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
forall k0 k1 k2 k3 v.
(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
adjustWithKey4 (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v
f k0
k0) k1
k1 k2
k2 k3
k3 k4
k4 DeepMap '[k1, k2, k3, k4] v
dm) DeepMap '[k0, k1, k2, k3, k4] v
m

-- | /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
update :: (DeepMap ks v -> Maybe (DeepMap ks v))
-> k -> DeepMap (k : ks) v -> DeepMap (k : ks) v
update DeepMap ks v -> Maybe (DeepMap ks v)
f k
k (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (DeepMap ks v -> Maybe (DeepMap ks v))
-> k -> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall k a. Ord k => (a -> Maybe a) -> k -> Map k a -> Map k a
Map.update DeepMap ks v -> Maybe (DeepMap ks v)
f k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
update1 :: (v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
update1 v -> Maybe v
f = (DeepMap '[] v -> Maybe (DeepMap '[] v))
-> k -> DeepMap '[k] v -> DeepMap '[k] v
forall k (ks :: [*]) v.
Ord k =>
(DeepMap ks v -> Maybe (DeepMap ks v))
-> k -> DeepMap (k : ks) v -> DeepMap (k : ks) v
update ((v -> Maybe v) -> DeepMap '[] v -> Maybe (DeepMap '[] v)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse v -> Maybe v
f)

-- | /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
update2 :: (v -> Maybe v)
-> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
update2 v -> Maybe v
f k0
k0 k1
k1 DeepMap '[k0, k1] v
m = case DeepMap '[k0, k1] v
m DeepMap '[k0, k1] v -> k0 -> Maybe (DeepMap '[k1] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1] v)
Nothing -> DeepMap '[k0, k1] v
m
    Just DeepMap '[k1] v
dm -> k0 -> DeepMap '[k1] v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((v -> Maybe v) -> k1 -> DeepMap '[k1] v -> DeepMap '[k1] v
forall k v.
Ord k =>
(v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
update1 v -> Maybe v
f k1
k1 DeepMap '[k1] v
dm) DeepMap '[k0, k1] v
m

-- | /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
update3 :: (v -> Maybe v)
-> k0
-> k1
-> k2
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
update3 v -> Maybe v
f k0
k0 k1
k1 k2
k2 DeepMap '[k0, k1, k2] v
m = case DeepMap '[k0, k1, k2] v
m DeepMap '[k0, k1, k2] v -> k0 -> Maybe (DeepMap '[k1, k2] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2] v)
Nothing -> DeepMap '[k0, k1, k2] v
m
    Just DeepMap '[k1, k2] v
dm -> k0
-> DeepMap '[k1, k2] v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((v -> Maybe v)
-> k1 -> k2 -> DeepMap '[k1, k2] v -> DeepMap '[k1, k2] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
(v -> Maybe v)
-> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
update2 v -> Maybe v
f k1
k1 k2
k2 DeepMap '[k1, k2] v
dm) DeepMap '[k0, k1, k2] v
m

-- | /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
update4 :: (v -> Maybe v)
-> k0
-> k1
-> k2
-> k3
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
update4 v -> Maybe v
f k0
k0 k1
k1 k2
k2 k3
k3 DeepMap '[k0, k1, k2, k3] v
m = case DeepMap '[k0, k1, k2, k3] v
m DeepMap '[k0, k1, k2, k3] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2, k3] v)
Nothing -> DeepMap '[k0, k1, k2, k3] v
m
    Just DeepMap '[k1, k2, k3] v
dm -> k0
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((v -> Maybe v)
-> k1
-> k2
-> k3
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
forall k0 k1 k2 v.
(Ord k0, Ord k1, Ord k2) =>
(v -> Maybe v)
-> k0
-> k1
-> k2
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
update3 v -> Maybe v
f k1
k1 k2
k2 k3
k3 DeepMap '[k1, k2, k3] v
dm) DeepMap '[k0, k1, k2, k3] v
m

-- | /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
update5 :: (v -> Maybe v)
-> k0
-> k1
-> k2
-> k3
-> k4
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
update5 v -> Maybe v
f k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 DeepMap '[k0, k1, k2, k3, k4] v
m = case DeepMap '[k0, k1, k2, k3, k4] v
m DeepMap '[k0, k1, k2, k3, k4] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2, k3, k4] v)
Nothing -> DeepMap '[k0, k1, k2, k3, k4] v
m
    Just DeepMap '[k1, k2, k3, k4] v
dm -> k0
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((v -> Maybe v)
-> k1
-> k2
-> k3
-> k4
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
forall k0 k1 k2 k3 v.
(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
update4 v -> Maybe v
f k1
k1 k2
k2 k3
k3 k4
k4 DeepMap '[k1, k2, k3, k4] v
dm) DeepMap '[k0, k1, k2, k3, k4] v
m

-- | /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
updateWithKey :: (k -> DeepMap ks v -> Maybe (DeepMap ks v))
-> k -> DeepMap (k : ks) v -> DeepMap (k : ks) v
updateWithKey k -> DeepMap ks v -> Maybe (DeepMap ks v)
f k
k (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (k -> DeepMap ks v -> Maybe (DeepMap ks v))
-> k -> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall k a. Ord k => (k -> a -> Maybe a) -> k -> Map k a -> Map k a
Map.updateWithKey k -> DeepMap ks v -> Maybe (DeepMap ks v)
f k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
updateWithKey1 :: (k -> v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
updateWithKey1 k -> v -> Maybe v
f = (k -> DeepMap '[] v -> Maybe (DeepMap '[] v))
-> k -> DeepMap '[k] v -> DeepMap '[k] v
forall k (ks :: [*]) v.
Ord k =>
(k -> DeepMap ks v -> Maybe (DeepMap ks v))
-> k -> DeepMap (k : ks) v -> DeepMap (k : ks) v
updateWithKey ((v -> Maybe v) -> DeepMap '[] v -> Maybe (DeepMap '[] v)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse ((v -> Maybe v) -> DeepMap '[] v -> Maybe (DeepMap '[] v))
-> (k -> v -> Maybe v)
-> k
-> DeepMap '[] v
-> Maybe (DeepMap '[] v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> v -> Maybe v
f)

-- | /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
updateWithKey2 :: (k0 -> k1 -> v -> Maybe v)
-> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
updateWithKey2 k0 -> k1 -> v -> Maybe v
f k0
k0 k1
k1 DeepMap '[k0, k1] v
m = case DeepMap '[k0, k1] v
m DeepMap '[k0, k1] v -> k0 -> Maybe (DeepMap '[k1] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1] v)
Nothing -> DeepMap '[k0, k1] v
m
    Just DeepMap '[k1] v
dm -> k0 -> DeepMap '[k1] v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((k1 -> v -> Maybe v) -> k1 -> DeepMap '[k1] v -> DeepMap '[k1] v
forall k v.
Ord k =>
(k -> v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
updateWithKey1 (k0 -> k1 -> v -> Maybe v
f k0
k0) k1
k1 DeepMap '[k1] v
dm) DeepMap '[k0, k1] v
m

-- | /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
updateWithKey3 :: (k0 -> k1 -> k2 -> v -> Maybe v)
-> k0
-> k1
-> k2
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
updateWithKey3 k0 -> k1 -> k2 -> v -> Maybe v
f k0
k0 k1
k1 k2
k2 DeepMap '[k0, k1, k2] v
m = case DeepMap '[k0, k1, k2] v
m DeepMap '[k0, k1, k2] v -> k0 -> Maybe (DeepMap '[k1, k2] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2] v)
Nothing -> DeepMap '[k0, k1, k2] v
m
    Just DeepMap '[k1, k2] v
dm -> k0
-> DeepMap '[k1, k2] v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((k1 -> k2 -> v -> Maybe v)
-> k1 -> k2 -> DeepMap '[k1, k2] v -> DeepMap '[k1, k2] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
(k0 -> k1 -> v -> Maybe v)
-> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
updateWithKey2 (k0 -> k1 -> k2 -> v -> Maybe v
f k0
k0) k1
k1 k2
k2 DeepMap '[k1, k2] v
dm) DeepMap '[k0, k1, k2] v
m

-- | /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
updateWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> Maybe v)
-> k0
-> k1
-> k2
-> k3
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
updateWithKey4 k0 -> k1 -> k2 -> k3 -> v -> Maybe v
f k0
k0 k1
k1 k2
k2 k3
k3 DeepMap '[k0, k1, k2, k3] v
m = case DeepMap '[k0, k1, k2, k3] v
m DeepMap '[k0, k1, k2, k3] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2, k3] v)
Nothing -> DeepMap '[k0, k1, k2, k3] v
m
    Just DeepMap '[k1, k2, k3] v
dm -> k0
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((k1 -> k2 -> k3 -> v -> Maybe v)
-> k1
-> k2
-> k3
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
forall k0 k1 k2 v.
(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
updateWithKey3 (k0 -> k1 -> k2 -> k3 -> v -> Maybe v
f k0
k0) k1
k1 k2
k2 k3
k3 DeepMap '[k1, k2, k3] v
dm) DeepMap '[k0, k1, k2, k3] v
m

-- | /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
updateWithKey5 :: (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
updateWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> Maybe v
f k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 DeepMap '[k0, k1, k2, k3, k4] v
m = case DeepMap '[k0, k1, k2, k3, k4] v
m DeepMap '[k0, k1, k2, k3, k4] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 of
    Maybe (DeepMap '[k1, k2, k3, k4] v)
Nothing -> DeepMap '[k0, k1, k2, k3, k4] v
m
    Just DeepMap '[k1, k2, k3, k4] v
dm -> k0
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap ks v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
overwrite k0
k0 ((k1 -> k2 -> k3 -> k4 -> v -> Maybe v)
-> k1
-> k2
-> k3
-> k4
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
forall k0 k1 k2 k3 v.
(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
updateWithKey4 (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Maybe v
f k0
k0) k1
k1 k2
k2 k3
k3 k4
k4 DeepMap '[k1, k2, k3, k4] v
dm) DeepMap '[k0, k1, k2, k3, k4] v
m

-- | /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)
updateLookupWithKey :: (k -> DeepMap ks v -> Maybe (DeepMap ks v))
-> k
-> DeepMap (k : ks) v
-> (Maybe (DeepMap ks v), DeepMap (k : ks) v)
updateLookupWithKey k -> DeepMap ks v -> Maybe (DeepMap ks v)
f k
k (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> (Maybe (DeepMap ks v), Map k (DeepMap ks v))
-> (Maybe (DeepMap ks v), DeepMap (k : ks) v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (k -> DeepMap ks v -> Maybe (DeepMap ks v))
-> k
-> Map k (DeepMap ks v)
-> (Maybe (DeepMap ks v), Map k (DeepMap ks v))
forall k a.
Ord k =>
(k -> a -> Maybe a) -> k -> Map k a -> (Maybe a, Map k a)
Map.updateLookupWithKey k -> DeepMap ks v -> Maybe (DeepMap ks v)
f k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /O(log n)/. Combines change and retrieval.
updateLookupWithKey1 :: (Ord k) => (k -> v -> Maybe v) -> k -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v)
updateLookupWithKey1 :: (k -> v -> Maybe v)
-> k -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v)
updateLookupWithKey1 k -> v -> Maybe v
f k
k DeepMap '[k] v
m = (DeepMap '[k] v
m DeepMap '[k] v -> k -> Maybe v
forall k v. Ord k => DeepMap '[k] v -> k -> Maybe v
@?| k
k, (k -> v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
forall k v.
Ord k =>
(k -> v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
updateWithKey1 k -> v -> Maybe v
f k
k DeepMap '[k] v
m)

-- | /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)
updateLookupWithKey2 :: (k0 -> k1 -> v -> Maybe v)
-> k0
-> k1
-> DeepMap '[k0, k1] v
-> (Maybe v, DeepMap '[k0, k1] v)
updateLookupWithKey2 k0 -> k1 -> v -> Maybe v
f k0
k0 k1
k1 DeepMap '[k0, k1] v
m = (DeepMap '[k0, k1] v
m DeepMap '[k0, k1] v -> k0 -> Maybe (DeepMap '[k1] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1] v) -> k1 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k1
k1, (k0 -> k1 -> v -> Maybe v)
-> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
(k0 -> k1 -> v -> Maybe v)
-> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
updateWithKey2 k0 -> k1 -> v -> Maybe v
f k0
k0 k1
k1 DeepMap '[k0, k1] v
m)

-- | /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)
updateLookupWithKey3 :: (k0 -> k1 -> k2 -> v -> Maybe v)
-> k0
-> k1
-> k2
-> DeepMap '[k0, k1, k2] v
-> (Maybe v, DeepMap '[k0, k1, k2] v)
updateLookupWithKey3 k0 -> k1 -> k2 -> v -> Maybe v
f k0
k0 k1
k1 k2
k2 DeepMap '[k0, k1, k2] v
m = (DeepMap '[k0, k1, k2] v
m DeepMap '[k0, k1, k2] v -> k0 -> Maybe (DeepMap '[k1, k2] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1, k2] v) -> k1 -> Maybe (DeepMap '[k2] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k1
k1 Maybe (DeepMap '[k2] v) -> k2 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k2
k2, (k0 -> k1 -> k2 -> v -> Maybe v)
-> k0
-> k1
-> k2
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
forall k0 k1 k2 v.
(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
updateWithKey3 k0 -> k1 -> k2 -> v -> Maybe v
f k0
k0 k1
k1 k2
k2 DeepMap '[k0, k1, k2] v
m)

-- | /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)
updateLookupWithKey4 :: (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)
updateLookupWithKey4 k0 -> k1 -> k2 -> k3 -> v -> Maybe v
f k0
k0 k1
k1 k2
k2 k3
k3 DeepMap '[k0, k1, k2, k3] v
m = (DeepMap '[k0, k1, k2, k3] v
m DeepMap '[k0, k1, k2, k3] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1, k2, k3] v)
-> k1 -> Maybe (DeepMap '[k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k1
k1 Maybe (DeepMap '[k2, k3] v) -> k2 -> Maybe (DeepMap '[k3] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k2
k2 Maybe (DeepMap '[k3] v) -> k3 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k3
k3, (k0 -> k1 -> k2 -> k3 -> v -> Maybe v)
-> k0
-> k1
-> k2
-> k3
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k0 k1 k2 k3 v.
(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
updateWithKey4 k0 -> k1 -> k2 -> k3 -> v -> Maybe v
f k0
k0 k1
k1 k2
k2 k3
k3 DeepMap '[k0, k1, k2, k3] v
m)

-- | /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)
updateLookupWithKey5 :: (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)
updateLookupWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> Maybe v
f k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 DeepMap '[k0, k1, k2, k3, k4] v
m = (DeepMap '[k0, k1, k2, k3, k4] v
m DeepMap '[k0, k1, k2, k3, k4] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1, k2, k3, k4] v)
-> k1 -> Maybe (DeepMap '[k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k1
k1 Maybe (DeepMap '[k2, k3, k4] v)
-> k2 -> Maybe (DeepMap '[k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k2
k2 Maybe (DeepMap '[k3, k4] v) -> k3 -> Maybe (DeepMap '[k4] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k3
k3 Maybe (DeepMap '[k4] v) -> k4 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k4
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
forall k0 k1 k2 k3 k4 v.
(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
updateWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> Maybe v
f k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 DeepMap '[k0, k1, k2, k3, k4] v
m)

-- | /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
alter :: (Maybe (DeepMap ks v) -> Maybe (DeepMap ks v))
-> k -> DeepMap (k : ks) v -> DeepMap (k : ks) v
alter Maybe (DeepMap ks v) -> Maybe (DeepMap ks v)
f k
k (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (Maybe (DeepMap ks v) -> Maybe (DeepMap ks v))
-> k -> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall k a.
Ord k =>
(Maybe a -> Maybe a) -> k -> Map k a -> Map k a
Map.alter Maybe (DeepMap ks v) -> Maybe (DeepMap ks v)
f k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
alter1 :: (Maybe v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
alter1 Maybe v -> Maybe v
f = (Maybe (DeepMap '[] v) -> Maybe (DeepMap '[] v))
-> k -> DeepMap '[k] v -> DeepMap '[k] v
forall k (ks :: [*]) v.
Ord k =>
(Maybe (DeepMap ks v) -> Maybe (DeepMap ks v))
-> k -> DeepMap (k : ks) v -> DeepMap (k : ks) v
alter ((v -> DeepMap '[] v) -> Maybe v -> Maybe (DeepMap '[] v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap v -> DeepMap '[] v
forall v. v -> DeepMap '[] v
Bare (Maybe v -> Maybe (DeepMap '[] v))
-> (Maybe (DeepMap '[] v) -> Maybe v)
-> Maybe (DeepMap '[] v)
-> Maybe (DeepMap '[] v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe v -> Maybe v
f (Maybe v -> Maybe v)
-> (Maybe (DeepMap '[] v) -> Maybe v)
-> Maybe (DeepMap '[] v)
-> Maybe v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DeepMap '[] v -> v) -> Maybe (DeepMap '[] v) -> Maybe v
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DeepMap '[] v -> v
forall v. DeepMap '[] v -> v
getBare)

-- | /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
alter2 :: (Maybe v -> Maybe v)
-> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
alter2 Maybe v -> Maybe v
f k0
k0 k1
k1 DeepMap '[k0, k1] v
m = case Maybe v -> Maybe v
f (Maybe v -> Maybe v) -> Maybe v -> Maybe v
forall a b. (a -> b) -> a -> b
$ DeepMap '[k0, k1] v
m DeepMap '[k0, k1] v -> k0 -> Maybe (DeepMap '[k1] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1] v) -> k1 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k1
k1 of
    Maybe v
Nothing -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
delete2 k0
k0 k1
k1 DeepMap '[k0, k1] v
m
    Just v
v -> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
overwrite2 k0
k0 k1
k1 v
v DeepMap '[k0, k1] v
m

-- | /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
alter3 :: (Maybe v -> Maybe v)
-> k0
-> k1
-> k2
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
alter3 Maybe v -> Maybe v
f k0
k0 k1
k1 k2
k2 DeepMap '[k0, k1, k2] v
m = case Maybe v -> Maybe v
f (Maybe v -> Maybe v) -> Maybe v -> Maybe v
forall a b. (a -> b) -> a -> b
$ DeepMap '[k0, k1, k2] v
m DeepMap '[k0, k1, k2] v -> k0 -> Maybe (DeepMap '[k1, k2] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1, k2] v) -> k1 -> Maybe (DeepMap '[k2] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k1
k1 Maybe (DeepMap '[k2] v) -> k2 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k2
k2 of
    Maybe v
Nothing -> k0
-> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
forall k0 k1 k2 v.
(Ord k0, Ord k1, Ord k2) =>
k0
-> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
delete3 k0
k0 k1
k1 k2
k2 DeepMap '[k0, k1, k2] v
m
    Just v
v -> k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
forall k0 k1 k2 v.
(Ord k0, Ord k1, Ord k2) =>
k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
overwrite3 k0
k0 k1
k1 k2
k2 v
v DeepMap '[k0, k1, k2] v
m

-- | /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
alter4 :: (Maybe v -> Maybe v)
-> k0
-> k1
-> k2
-> k3
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
alter4 Maybe v -> Maybe v
f k0
k0 k1
k1 k2
k2 k3
k3 DeepMap '[k0, k1, k2, k3] v
m = case Maybe v -> Maybe v
f (Maybe v -> Maybe v) -> Maybe v -> Maybe v
forall a b. (a -> b) -> a -> b
$ DeepMap '[k0, k1, k2, k3] v
m DeepMap '[k0, k1, k2, k3] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1, k2, k3] v)
-> k1 -> Maybe (DeepMap '[k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k1
k1 Maybe (DeepMap '[k2, k3] v) -> k2 -> Maybe (DeepMap '[k3] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k2
k2 Maybe (DeepMap '[k3] v) -> k3 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k3
k3 of
    Maybe v
Nothing -> k0
-> k1
-> k2
-> k3
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k0 k1 k2 k3 v.
(Ord k0, Ord k1, Ord k2, Ord k3) =>
k0
-> k1
-> k2
-> k3
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
delete4 k0
k0 k1
k1 k2
k2 k3
k3 DeepMap '[k0, k1, k2, k3] v
m
    Just v
v -> k0
-> k1
-> k2
-> k3
-> v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k0 k1 k2 k3 v.
(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
overwrite4 k0
k0 k1
k1 k2
k2 k3
k3 v
v DeepMap '[k0, k1, k2, k3] v
m

-- | /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
alter5 :: (Maybe v -> Maybe v)
-> k0
-> k1
-> k2
-> k3
-> k4
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
alter5 Maybe v -> Maybe v
f k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 DeepMap '[k0, k1, k2, k3, k4] v
m = case Maybe v -> Maybe v
f (Maybe v -> Maybe v) -> Maybe v -> Maybe v
forall a b. (a -> b) -> a -> b
$ DeepMap '[k0, k1, k2, k3, k4] v
m DeepMap '[k0, k1, k2, k3, k4] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1, k2, k3, k4] v)
-> k1 -> Maybe (DeepMap '[k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k1
k1 Maybe (DeepMap '[k2, k3, k4] v)
-> k2 -> Maybe (DeepMap '[k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k2
k2 Maybe (DeepMap '[k3, k4] v) -> k3 -> Maybe (DeepMap '[k4] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k3
k3 Maybe (DeepMap '[k4] v) -> k4 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k4
k4 of
    Maybe v
Nothing -> k0
-> k1
-> k2
-> k3
-> k4
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k0 k1 k2 k3 k4 v.
(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
delete5 k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 DeepMap '[k0, k1, k2, k3, k4] v
m
    Just v
v -> k0
-> k1
-> k2
-> k3
-> k4
-> v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k0 k1 k2 k3 k4 v.
(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
overwrite5 k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 v
v DeepMap '[k0, k1, k2, k3, k4] v
m

alterF :: (Functor f, Ord k) => (Maybe (DeepMap ks v) -> f (Maybe (DeepMap ks v))) -> k -> DeepMap (k ': ks) v -> f (DeepMap (k ': ks) v)
alterF :: (Maybe (DeepMap ks v) -> f (Maybe (DeepMap ks v)))
-> k -> DeepMap (k : ks) v -> f (DeepMap (k : ks) v)
alterF Maybe (DeepMap ks v) -> f (Maybe (DeepMap ks v))
f k
k (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> f (Map k (DeepMap ks v)) -> f (DeepMap (k : ks) v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Maybe (DeepMap ks v) -> f (Maybe (DeepMap ks v)))
-> k -> Map k (DeepMap ks v) -> f (Map k (DeepMap ks v))
forall (f :: * -> *) k a.
(Functor f, Ord k) =>
(Maybe a -> f (Maybe a)) -> k -> Map k a -> f (Map k a)
Map.alterF Maybe (DeepMap ks v) -> f (Maybe (DeepMap ks v))
f k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

alterF1 :: (Functor f, Ord k) => (Maybe v -> f (Maybe v)) -> k -> DeepMap '[k] v -> f (DeepMap '[k] v)
alterF1 :: (Maybe v -> f (Maybe v))
-> k -> DeepMap '[k] v -> f (DeepMap '[k] v)
alterF1 Maybe v -> f (Maybe v)
f = (Maybe (DeepMap '[] v) -> f (Maybe (DeepMap '[] v)))
-> k -> DeepMap '[k] v -> f (DeepMap '[k] v)
forall (f :: * -> *) k (ks :: [*]) v.
(Functor f, Ord k) =>
(Maybe (DeepMap ks v) -> f (Maybe (DeepMap ks v)))
-> k -> DeepMap (k : ks) v -> f (DeepMap (k : ks) v)
alterF ((Maybe v -> Maybe (DeepMap '[] v))
-> f (Maybe v) -> f (Maybe (DeepMap '[] v))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((v -> DeepMap '[] v) -> Maybe v -> Maybe (DeepMap '[] v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap v -> DeepMap '[] v
forall v. v -> DeepMap '[] v
Bare) (f (Maybe v) -> f (Maybe (DeepMap '[] v)))
-> (Maybe (DeepMap '[] v) -> f (Maybe v))
-> Maybe (DeepMap '[] v)
-> f (Maybe (DeepMap '[] v))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe v -> f (Maybe v)
f (Maybe v -> f (Maybe v))
-> (Maybe (DeepMap '[] v) -> Maybe v)
-> Maybe (DeepMap '[] v)
-> f (Maybe v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DeepMap '[] v -> v) -> Maybe (DeepMap '[] v) -> Maybe v
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DeepMap '[] v -> v
forall v. DeepMap '[] v -> v
getBare)

alterF2 :: (Functor f, Ord k0, Ord k1) => (Maybe v -> f (Maybe v)) -> k0 -> k1 -> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] v)
alterF2 :: (Maybe v -> f (Maybe v))
-> k0 -> k1 -> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] v)
alterF2 Maybe v -> f (Maybe v)
f k0
k0 k1
k1 DeepMap '[k0, k1] v
m =
    Maybe v -> f (Maybe v)
f (DeepMap '[k0, k1] v
m DeepMap '[k0, k1] v -> k0 -> Maybe (DeepMap '[k1] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1] v) -> k1 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k1
k1) f (Maybe v)
-> (Maybe v -> DeepMap '[k0, k1] v) -> f (DeepMap '[k0, k1] v)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
        Maybe v
Nothing -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
delete2 k0
k0 k1
k1 DeepMap '[k0, k1] v
m
        Just v
v -> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
overwrite2 k0
k0 k1
k1 v
v DeepMap '[k0, k1] v
m

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)
alterF3 :: (Maybe v -> f (Maybe v))
-> k0
-> k1
-> k2
-> DeepMap '[k0, k1, k2] v
-> f (DeepMap '[k0, k1, k2] v)
alterF3 Maybe v -> f (Maybe v)
f k0
k0 k1
k1 k2
k2 DeepMap '[k0, k1, k2] v
m =
    Maybe v -> f (Maybe v)
f (DeepMap '[k0, k1, k2] v
m DeepMap '[k0, k1, k2] v -> k0 -> Maybe (DeepMap '[k1, k2] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1, k2] v) -> k1 -> Maybe (DeepMap '[k2] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k1
k1 Maybe (DeepMap '[k2] v) -> k2 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k2
k2) f (Maybe v)
-> (Maybe v -> DeepMap '[k0, k1, k2] v)
-> f (DeepMap '[k0, k1, k2] v)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
        Maybe v
Nothing -> k0
-> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
forall k0 k1 k2 v.
(Ord k0, Ord k1, Ord k2) =>
k0
-> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
delete3 k0
k0 k1
k1 k2
k2 DeepMap '[k0, k1, k2] v
m
        Just v
v -> k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
forall k0 k1 k2 v.
(Ord k0, Ord k1, Ord k2) =>
k0
-> k1
-> k2
-> v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
overwrite3 k0
k0 k1
k1 k2
k2 v
v DeepMap '[k0, k1, k2] v
m

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)
alterF4 :: (Maybe v -> f (Maybe v))
-> k0
-> k1
-> k2
-> k3
-> DeepMap '[k0, k1, k2, k3] v
-> f (DeepMap '[k0, k1, k2, k3] v)
alterF4 Maybe v -> f (Maybe v)
f k0
k0 k1
k1 k2
k2 k3
k3 DeepMap '[k0, k1, k2, k3] v
m =
    Maybe v -> f (Maybe v)
f (DeepMap '[k0, k1, k2, k3] v
m DeepMap '[k0, k1, k2, k3] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1, k2, k3] v)
-> k1 -> Maybe (DeepMap '[k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k1
k1 Maybe (DeepMap '[k2, k3] v) -> k2 -> Maybe (DeepMap '[k3] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k2
k2 Maybe (DeepMap '[k3] v) -> k3 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k3
k3) f (Maybe v)
-> (Maybe v -> DeepMap '[k0, k1, k2, k3] v)
-> f (DeepMap '[k0, k1, k2, k3] v)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
        Maybe v
Nothing -> k0
-> k1
-> k2
-> k3
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k0 k1 k2 k3 v.
(Ord k0, Ord k1, Ord k2, Ord k3) =>
k0
-> k1
-> k2
-> k3
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
delete4 k0
k0 k1
k1 k2
k2 k3
k3 DeepMap '[k0, k1, k2, k3] v
m
        Just v
v -> k0
-> k1
-> k2
-> k3
-> v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k0 k1 k2 k3 v.
(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
overwrite4 k0
k0 k1
k1 k2
k2 k3
k3 v
v DeepMap '[k0, k1, k2, k3] v
m

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)
alterF5 :: (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)
alterF5 Maybe v -> f (Maybe v)
f k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 DeepMap '[k0, k1, k2, k3, k4] v
m =
    Maybe v -> f (Maybe v)
f (DeepMap '[k0, k1, k2, k3, k4] v
m DeepMap '[k0, k1, k2, k3, k4] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1, k2, k3, k4] v)
-> k1 -> Maybe (DeepMap '[k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k1
k1 Maybe (DeepMap '[k2, k3, k4] v)
-> k2 -> Maybe (DeepMap '[k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k2
k2 Maybe (DeepMap '[k3, k4] v) -> k3 -> Maybe (DeepMap '[k4] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k3
k3 Maybe (DeepMap '[k4] v) -> k4 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k4
k4) f (Maybe v)
-> (Maybe v -> DeepMap '[k0, k1, k2, k3, k4] v)
-> f (DeepMap '[k0, k1, k2, k3, k4] v)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
        Maybe v
Nothing -> k0
-> k1
-> k2
-> k3
-> k4
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k0 k1 k2 k3 k4 v.
(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
delete5 k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 DeepMap '[k0, k1, k2, k3, k4] v
m
        Just v
v -> k0
-> k1
-> k2
-> k3
-> k4
-> v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k0 k1 k2 k3 k4 v.
(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
overwrite5 k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 v
v DeepMap '[k0, k1, k2, k3, k4] v
m

-- | /O(log n)/. Lookup the value at a key.
lookup :: (Ord k) => k -> DeepMap (k ': ks) v -> Maybe (DeepMap ks v)
lookup :: k -> DeepMap (k : ks) v -> Maybe (DeepMap ks v)
lookup k
k (Nest Map k (DeepMap ks v)
m) = k -> Map k (DeepMap ks v) -> Maybe (DeepMap ks v)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /O(log n)/. Lookup the value at a key.
lookup1 :: (Ord k) => k -> DeepMap '[k] v -> Maybe v
lookup1 :: k -> DeepMap '[k] v -> Maybe v
lookup1 k
k (Nest Map k (DeepMap ks v)
m) = DeepMap '[] v -> v
forall v. DeepMap '[] v -> v
getBare (DeepMap '[] v -> v) -> Maybe (DeepMap '[] v) -> Maybe v
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> k -> Map k (DeepMap ks v) -> Maybe (DeepMap ks v)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /O(log n)/. A flipped, infix variant of 'lookup'.
(@?) :: (Ord k) => DeepMap (k ': ks) v -> k -> Maybe (DeepMap ks v)
@? :: DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
(@?) = (k -> DeepMap (k : ks) v -> Maybe (DeepMap ks v))
-> DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
forall a b c. (a -> b -> c) -> b -> a -> c
flip k -> DeepMap (k : ks) v -> Maybe (DeepMap ks v)
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap (k : ks) v -> Maybe (DeepMap ks v)
lookup

-- | /O(log n)/. A flipped, infix variant of 'lookup1'.
(@?|) :: (Ord k) => DeepMap '[k] v -> k -> Maybe v
@?| :: DeepMap '[k] v -> k -> Maybe v
(@?|) = (k -> DeepMap '[k] v -> Maybe v) -> DeepMap '[k] v -> k -> Maybe v
forall a b c. (a -> b -> c) -> b -> a -> c
flip k -> DeepMap '[k] v -> Maybe v
forall k v. Ord k => k -> DeepMap '[k] v -> Maybe v
lookup1

-- | /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)
Maybe (DeepMap (k : ks) v)
mm @?? :: Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k
k = Maybe (DeepMap (k : ks) v)
mm Maybe (DeepMap (k : ks) v)
-> (DeepMap (k : ks) v -> Maybe (DeepMap ks v))
-> Maybe (DeepMap ks v)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k
k)

-- | /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
Maybe (DeepMap '[k] v)
mm @??| :: Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k
k = Maybe (DeepMap '[k] v)
mm Maybe (DeepMap '[k] v) -> (DeepMap '[k] v -> Maybe v) -> Maybe v
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (DeepMap '[k] v -> k -> Maybe v
forall k v. Ord k => DeepMap '[k] v -> k -> Maybe v
@?| k
k)

-- | /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
@! :: DeepMap (k : ks) v -> k -> DeepMap ks v
(@!) = (DeepMap ks v -> Maybe (DeepMap ks v) -> DeepMap ks v
forall a. a -> Maybe a -> a
fromMaybe DeepMap ks v
forall a. Monoid a => a
mempty (Maybe (DeepMap ks v) -> DeepMap ks v)
-> (k -> Maybe (DeepMap ks v)) -> k -> DeepMap ks v
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((k -> Maybe (DeepMap ks v)) -> k -> DeepMap ks v)
-> (DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v))
-> DeepMap (k : ks) v
-> k
-> DeepMap ks v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (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
@!| :: DeepMap '[k] v -> k -> v
(@!|) = (v -> Maybe v -> v
forall a. a -> Maybe a -> a
fromMaybe v
forall a. Monoid a => a
mempty (Maybe v -> v) -> (k -> Maybe v) -> k -> v
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((k -> Maybe v) -> k -> v)
-> (DeepMap '[k] v -> k -> Maybe v) -> DeepMap '[k] v -> k -> v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DeepMap '[k] v -> k -> Maybe v
forall k v. Ord k => DeepMap '[k] v -> k -> Maybe 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
findWithDefault :: DeepMap ks v -> k -> DeepMap (k : ks) v -> DeepMap ks v
findWithDefault DeepMap ks v
a = (DeepMap ks v -> Maybe (DeepMap ks v) -> DeepMap ks v
forall a. a -> Maybe a -> a
fromMaybe DeepMap ks v
a (Maybe (DeepMap ks v) -> DeepMap ks v)
-> (DeepMap (k : ks) v -> Maybe (DeepMap ks v))
-> DeepMap (k : ks) v
-> DeepMap ks v
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((DeepMap (k : ks) v -> Maybe (DeepMap ks v))
 -> DeepMap (k : ks) v -> DeepMap ks v)
-> (k -> DeepMap (k : ks) v -> Maybe (DeepMap ks v))
-> k
-> DeepMap (k : ks) v
-> DeepMap ks v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> DeepMap (k : ks) v -> Maybe (DeepMap ks v)
forall k (ks :: [*]) v.
Ord k =>
k -> DeepMap (k : ks) v -> Maybe (DeepMap ks v)
lookup

-- | /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
findWithDefault1 :: v -> k -> DeepMap '[k] v -> v
findWithDefault1 v
a k
k DeepMap '[k] v
m = v -> Maybe v -> v
forall a. a -> Maybe a -> a
fromMaybe v
a (Maybe v -> v) -> Maybe v -> v
forall a b. (a -> b) -> a -> b
$ DeepMap '[k] v
m DeepMap '[k] v -> k -> Maybe v
forall k v. Ord k => DeepMap '[k] v -> k -> Maybe v
@?| k
k

-- | /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
findWithDefault2 :: v -> k0 -> k1 -> DeepMap '[k0, k1] v -> v
findWithDefault2 v
a k0
k0 k1
k1 DeepMap '[k0, k1] v
m = v -> Maybe v -> v
forall a. a -> Maybe a -> a
fromMaybe v
a (Maybe v -> v) -> Maybe v -> v
forall a b. (a -> b) -> a -> b
$ DeepMap '[k0, k1] v
m DeepMap '[k0, k1] v -> k0 -> Maybe (DeepMap '[k1] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1] v) -> k1 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k1
k1

-- | /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
findWithDefault3 :: v -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> v
findWithDefault3 v
a k0
k0 k1
k1 k2
k2 DeepMap '[k0, k1, k2] v
m = v -> Maybe v -> v
forall a. a -> Maybe a -> a
fromMaybe v
a (Maybe v -> v) -> Maybe v -> v
forall a b. (a -> b) -> a -> b
$ DeepMap '[k0, k1, k2] v
m DeepMap '[k0, k1, k2] v -> k0 -> Maybe (DeepMap '[k1, k2] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1, k2] v) -> k1 -> Maybe (DeepMap '[k2] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k1
k1 Maybe (DeepMap '[k2] v) -> k2 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k2
k2

-- | /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
findWithDefault4 :: v -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> v
findWithDefault4 v
a k0
k0 k1
k1 k2
k2 k3
k3 DeepMap '[k0, k1, k2, k3] v
m = v -> Maybe v -> v
forall a. a -> Maybe a -> a
fromMaybe v
a (Maybe v -> v) -> Maybe v -> v
forall a b. (a -> b) -> a -> b
$ DeepMap '[k0, k1, k2, k3] v
m DeepMap '[k0, k1, k2, k3] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1, k2, k3] v)
-> k1 -> Maybe (DeepMap '[k2, k3] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k1
k1 Maybe (DeepMap '[k2, k3] v) -> k2 -> Maybe (DeepMap '[k3] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k2
k2 Maybe (DeepMap '[k3] v) -> k3 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k3
k3

-- | /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
findWithDefault5 :: v
-> k0
-> k1
-> k2
-> k3
-> k4
-> DeepMap '[k0, k1, k2, k3, k4] v
-> v
findWithDefault5 v
a k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 DeepMap '[k0, k1, k2, k3, k4] v
m = v -> Maybe v -> v
forall a. a -> Maybe a -> a
fromMaybe v
a (Maybe v -> v) -> Maybe v -> v
forall a b. (a -> b) -> a -> b
$ DeepMap '[k0, k1, k2, k3, k4] v
m DeepMap '[k0, k1, k2, k3, k4] v
-> k0 -> Maybe (DeepMap '[k1, k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> k -> Maybe (DeepMap ks v)
@? k0
k0 Maybe (DeepMap '[k1, k2, k3, k4] v)
-> k1 -> Maybe (DeepMap '[k2, k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k1
k1 Maybe (DeepMap '[k2, k3, k4] v)
-> k2 -> Maybe (DeepMap '[k3, k4] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k2
k2 Maybe (DeepMap '[k3, k4] v) -> k3 -> Maybe (DeepMap '[k4] v)
forall k (ks :: [*]) v.
Ord k =>
Maybe (DeepMap (k : ks) v) -> k -> Maybe (DeepMap ks v)
@?? k3
k3 Maybe (DeepMap '[k4] v) -> k4 -> Maybe v
forall k v. Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
@??| k4
k4

-- | /O(log n)/. Is the key a member of the map? See also 'notMember'.
member :: (Ord k) => k -> DeepMap (k ': ks) v -> Bool
member :: k -> DeepMap (k : ks) v -> Bool
member k
k (Nest Map k (DeepMap ks v)
m) = k -> Map k (DeepMap ks v) -> Bool
forall k a. Ord k => k -> Map k a -> Bool
Map.member k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /O(log n)/. Is the key missing from the map? See also 'member'.
notMember :: (Ord k) => k -> DeepMap (k ': ks) v -> Bool
notMember :: k -> DeepMap (k : ks) v -> Bool
notMember k
k (Nest Map k (DeepMap ks v)
m) = k -> Map k (DeepMap ks v) -> Bool
forall k a. Ord k => k -> Map k a -> Bool
Map.notMember k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | 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)
lookupLT :: k -> DeepMap (k : ks) v -> Maybe (k, DeepMap ks v)
lookupLT k
k (Nest Map k (DeepMap ks v)
m) = k -> Map k (DeepMap ks v) -> Maybe (k, DeepMap ks v)
forall k v. Ord k => k -> Map k v -> Maybe (k, v)
Map.lookupLT k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | 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)
lookupGT :: k -> DeepMap (k : ks) v -> Maybe (k, DeepMap ks v)
lookupGT k
k (Nest Map k (DeepMap ks v)
m) = k -> Map k (DeepMap ks v) -> Maybe (k, DeepMap ks v)
forall k v. Ord k => k -> Map k v -> Maybe (k, v)
Map.lookupGT k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | 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)
lookupLE :: k -> DeepMap (k : ks) v -> Maybe (k, DeepMap ks v)
lookupLE k
k (Nest Map k (DeepMap ks v)
m) = k -> Map k (DeepMap ks v) -> Maybe (k, DeepMap ks v)
forall k v. Ord k => k -> Map k v -> Maybe (k, v)
Map.lookupLE k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | 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)
lookupGE :: k -> DeepMap (k : ks) v -> Maybe (k, DeepMap ks v)
lookupGE k
k (Nest Map k (DeepMap ks v)
m) = k -> Map k (DeepMap ks v) -> Maybe (k, DeepMap ks v)
forall k v. Ord k => k -> Map k v -> Maybe (k, v)
Map.lookupGE k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /O(1)/. Is the 'DeepMap' empty?
null :: DeepMap (k ': ks) v -> Bool
null :: DeepMap (k : ks) v -> Bool
null (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> Bool
forall k a. Map k a -> Bool
Map.null Map k (DeepMap ks v)
m

-- | /O(1)/. The number of outermost keys in the 'DeepMap'.
size :: DeepMap (k ': ks) v -> Int
size :: DeepMap (k : ks) v -> Int
size (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> Int
forall k a. Map k a -> Int
Map.size Map k (DeepMap ks v)
m

-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's together using '(<>)' to combine
--   the values of duplicate keys.
--
--   To retain 'Data.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
union :: DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
union = DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
forall a. Semigroup a => a -> a -> a
(<>)

-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's 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
unionWith :: (DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
unionWith DeepMap ks v -> DeepMap ks v -> DeepMap ks v
f = (Map k (DeepMap ks v)
 -> Map k (DeepMap ks v) -> Map k (DeepMap ks v))
-> DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
(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
onNest2 ((DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> Map k (DeepMap ks v)
-> Map k (DeepMap ks v)
-> Map k (DeepMap ks v)
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith DeepMap ks v -> DeepMap ks v -> DeepMap ks v
f)

-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's with a combining function.
unionWith1 :: (Ord k) => (v -> v -> v) -> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
unionWith1 :: (v -> v -> v) -> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
unionWith1 v -> v -> v
f = (Map k (DeepMap '[] v)
 -> Map k (DeepMap '[] v) -> Map k (DeepMap '[] v))
-> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
(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
onNest2 ((DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v)
-> Map k (DeepMap '[] v)
-> Map k (DeepMap '[] v)
-> Map k (DeepMap '[] v)
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith ((v -> v -> v) -> DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v
forall v w x.
(v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x
onBare2 v -> v -> v
f))

-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's with a combining function.
unionWith2 :: (Ord k0, Ord k1) => (v -> v -> v) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
unionWith2 :: (v -> v -> v)
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] v
unionWith2 v -> v -> v
f = (DeepMap '[k1] v -> DeepMap '[k1] v -> DeepMap '[k1] v)
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] v
forall k (ks :: [*]) v.
Ord k =>
(DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
unionWith ((v -> v -> v)
-> DeepMap '[k1] v -> DeepMap '[k1] v -> DeepMap '[k1] v
forall k v.
Ord k =>
(v -> v -> v) -> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
unionWith1 v -> v -> v
f)

-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's 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
unionWith3 :: (v -> v -> v)
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
unionWith3 v -> v -> v
f = (DeepMap '[k1, k2] v -> DeepMap '[k1, k2] v -> DeepMap '[k1, k2] v)
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
forall k (ks :: [*]) v.
Ord k =>
(DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
unionWith ((v -> v -> v)
-> DeepMap '[k1, k2] v
-> DeepMap '[k1, k2] v
-> DeepMap '[k1, k2] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
(v -> v -> v)
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] v
unionWith2 v -> v -> v
f)

-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's 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
unionWith4 :: (v -> v -> v)
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
unionWith4 v -> v -> v
f = (DeepMap '[k1, k2, k3] v
 -> DeepMap '[k1, k2, k3] v -> DeepMap '[k1, k2, k3] v)
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k (ks :: [*]) v.
Ord k =>
(DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
unionWith ((v -> v -> v)
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
forall k0 k1 k2 v.
(Ord k0, Ord k1, Ord k2) =>
(v -> v -> v)
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
unionWith3 v -> v -> v
f)

-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's 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
unionWith5 :: (v -> v -> v)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
unionWith5 v -> v -> v
f = (DeepMap '[k1, k2, k3, k4] v
 -> DeepMap '[k1, k2, k3, k4] v -> DeepMap '[k1, k2, k3, k4] v)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k (ks :: [*]) v.
Ord k =>
(DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
unionWith ((v -> v -> v)
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
forall k0 k1 k2 k3 v.
(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
unionWith4 v -> v -> v
f)

-- | /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
unionWithKey :: (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
unionWithKey k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v
f = (Map k (DeepMap ks v)
 -> Map k (DeepMap ks v) -> Map k (DeepMap ks v))
-> DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
(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
onNest2 ((k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> Map k (DeepMap ks v)
-> Map k (DeepMap ks v)
-> Map k (DeepMap ks v)
forall k a.
Ord k =>
(k -> a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWithKey k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v
f)

-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's 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
unionWithKey1 :: (k -> v -> v -> v)
-> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
unionWithKey1 k -> v -> v -> v
f = (Map k (DeepMap '[] v)
 -> Map k (DeepMap '[] v) -> Map k (DeepMap '[] v))
-> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
(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
onNest2 ((k -> DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v)
-> Map k (DeepMap '[] v)
-> Map k (DeepMap '[] v)
-> Map k (DeepMap '[] v)
forall k a.
Ord k =>
(k -> a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWithKey ((k -> DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v)
 -> Map k (DeepMap '[] v)
 -> Map k (DeepMap '[] v)
 -> Map k (DeepMap '[] v))
-> (k -> DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v)
-> Map k (DeepMap '[] v)
-> Map k (DeepMap '[] v)
-> Map k (DeepMap '[] v)
forall a b. (a -> b) -> a -> b
$ (v -> v -> v) -> DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v
forall v w x.
(v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x
onBare2 ((v -> v -> v) -> DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v)
-> (k -> v -> v -> v)
-> k
-> DeepMap '[] v
-> DeepMap '[] v
-> DeepMap '[] v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> v -> v -> v
f)

-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's 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
unionWithKey2 :: (k0 -> k1 -> v -> v -> v)
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] v
unionWithKey2 k0 -> k1 -> v -> v -> v
f = (k0 -> DeepMap '[k1] v -> DeepMap '[k1] v -> DeepMap '[k1] v)
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] v
forall k (ks :: [*]) v.
Ord k =>
(k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
unionWithKey ((k1 -> v -> v -> v)
-> DeepMap '[k1] v -> DeepMap '[k1] v -> DeepMap '[k1] v
forall k v.
Ord k =>
(k -> v -> v -> v)
-> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
unionWithKey1 ((k1 -> v -> v -> v)
 -> DeepMap '[k1] v -> DeepMap '[k1] v -> DeepMap '[k1] v)
-> (k0 -> k1 -> v -> v -> v)
-> k0
-> DeepMap '[k1] v
-> DeepMap '[k1] v
-> DeepMap '[k1] v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> v -> v -> v
f)

-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's 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
unionWithKey3 :: (k0 -> k1 -> k2 -> v -> v -> v)
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
unionWithKey3 k0 -> k1 -> k2 -> v -> v -> v
f = (k0
 -> DeepMap '[k1, k2] v
 -> DeepMap '[k1, k2] v
 -> DeepMap '[k1, k2] v)
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
forall k (ks :: [*]) v.
Ord k =>
(k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
unionWithKey ((k1 -> k2 -> v -> v -> v)
-> DeepMap '[k1, k2] v
-> DeepMap '[k1, k2] v
-> DeepMap '[k1, k2] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
(k0 -> k1 -> v -> v -> v)
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] v
unionWithKey2 ((k1 -> k2 -> v -> v -> v)
 -> DeepMap '[k1, k2] v
 -> DeepMap '[k1, k2] v
 -> DeepMap '[k1, k2] v)
-> (k0 -> k1 -> k2 -> v -> v -> v)
-> k0
-> DeepMap '[k1, k2] v
-> DeepMap '[k1, k2] v
-> DeepMap '[k1, k2] v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> v -> v -> v
f)

-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's 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
unionWithKey4 :: (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
unionWithKey4 k0 -> k1 -> k2 -> k3 -> v -> v -> v
f = (k0
 -> DeepMap '[k1, k2, k3] v
 -> DeepMap '[k1, k2, k3] v
 -> DeepMap '[k1, k2, k3] v)
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k (ks :: [*]) v.
Ord k =>
(k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
unionWithKey ((k1 -> k2 -> k3 -> v -> v -> v)
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
forall k0 k1 k2 v.
(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
unionWithKey3 ((k1 -> k2 -> k3 -> v -> v -> v)
 -> DeepMap '[k1, k2, k3] v
 -> DeepMap '[k1, k2, k3] v
 -> DeepMap '[k1, k2, k3] v)
-> (k0 -> k1 -> k2 -> k3 -> v -> v -> v)
-> k0
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> v -> v -> v
f)

-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's 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
unionWithKey5 :: (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
unionWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v
f = (k0
 -> DeepMap '[k1, k2, k3, k4] v
 -> DeepMap '[k1, k2, k3, k4] v
 -> DeepMap '[k1, k2, k3, k4] v)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k (ks :: [*]) v.
Ord k =>
(k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
unionWithKey ((k1 -> k2 -> k3 -> k4 -> v -> v -> v)
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
forall k0 k1 k2 k3 v.
(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
unionWithKey4 ((k1 -> k2 -> k3 -> k4 -> v -> v -> v)
 -> DeepMap '[k1, k2, k3, k4] v
 -> DeepMap '[k1, k2, k3, k4] v
 -> DeepMap '[k1, k2, k3, k4] v)
-> (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v)
-> k0
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v
f)

-- | A synonym for 'fold'. To retain 'Data.Map'\'s functionality, use @'unionsWith' 'const'@.
unions :: (Foldable t, Ord k, Semigroup (DeepMap ks v)) => t (DeepMap (k ': ks) v) -> DeepMap (k ': ks) v
unions :: t (DeepMap (k : ks) v) -> DeepMap (k : ks) v
unions = t (DeepMap (k : ks) v) -> DeepMap (k : ks) v
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold

-- | The union of a list of 'DeepMap's, 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
unionsWith :: (DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> t (DeepMap (k : ks) v) -> DeepMap (k : ks) v
unionsWith DeepMap ks v -> DeepMap ks v -> DeepMap ks v
f = (DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v)
-> DeepMap (k : ks) v
-> t (DeepMap (k : ks) v)
-> DeepMap (k : ks) v
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl ((DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
forall k (ks :: [*]) v.
Ord k =>
(DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> DeepMap (k : ks) v -> DeepMap (k : ks) v -> DeepMap (k : ks) v
unionWith DeepMap ks v -> DeepMap ks v -> DeepMap ks v
f) DeepMap (k : ks) v
forall k (ks :: [*]) v. DeepMap (k : ks) v
empty

-- | The union of a list of 'DeepMap's, combining with a specified operation.
unionsWith1 :: (Foldable t, Ord k) => (v -> v -> v) -> t (DeepMap '[k] v) -> DeepMap '[k] v
unionsWith1 :: (v -> v -> v) -> t (DeepMap '[k] v) -> DeepMap '[k] v
unionsWith1 v -> v -> v
f = (DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v)
-> DeepMap '[k] v -> t (DeepMap '[k] v) -> DeepMap '[k] v
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl ((v -> v -> v) -> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
forall k v.
Ord k =>
(v -> v -> v) -> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
unionWith1 v -> v -> v
f) DeepMap '[k] v
forall k (ks :: [*]) v. DeepMap (k : ks) v
empty

-- | /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
difference :: DeepMap (k : ks) v -> DeepMap (k : ls) w -> DeepMap (k : ks) v
difference = (Map k (DeepMap ks v)
 -> Map k (DeepMap ls w) -> Map k (DeepMap ks v))
-> DeepMap (k : ks) v -> DeepMap (k : ls) w -> DeepMap (k : ks) v
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
(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
onNest2 Map k (DeepMap ks v)
-> Map k (DeepMap ls w) -> Map k (DeepMap ks v)
forall k a b. Ord k => Map k a -> Map k b -> Map k a
Map.difference

-- | Infix synonym for 'difference'.
(\\) :: (Ord k) => DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v
\\ :: DeepMap (k : ks) v -> DeepMap (k : ls) w -> DeepMap (k : ks) v
(\\) = DeepMap (k : ks) v -> DeepMap (k : ls) w -> DeepMap (k : ks) v
forall k (ks :: [*]) v (ls :: [*]) w.
Ord k =>
DeepMap (k : ks) v -> DeepMap (k : ls) w -> DeepMap (k : ks) v
difference

-- | /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
differenceWith :: (DeepMap ks v -> DeepMap ls w -> Maybe (DeepMap ks v))
-> DeepMap (k : ks) v -> DeepMap (k : ls) w -> DeepMap (k : ks) v
differenceWith DeepMap ks v -> DeepMap ls w -> Maybe (DeepMap ks v)
f = (Map k (DeepMap ks v)
 -> Map k (DeepMap ls w) -> Map k (DeepMap ks v))
-> DeepMap (k : ks) v -> DeepMap (k : ls) w -> DeepMap (k : ks) v
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
(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
onNest2 ((DeepMap ks v -> DeepMap ls w -> Maybe (DeepMap ks v))
-> Map k (DeepMap ks v)
-> Map k (DeepMap ls w)
-> Map k (DeepMap ks v)
forall k a b.
Ord k =>
(a -> b -> Maybe a) -> Map k a -> Map k b -> Map k a
Map.differenceWith DeepMap ks v -> DeepMap ls w -> Maybe (DeepMap ks v)
f)

-- | /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
differenceWith1 :: (v -> w -> Maybe v)
-> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] v
differenceWith1 v -> w -> Maybe v
f = (Map k (DeepMap '[] v)
 -> Map k (DeepMap '[] w) -> Map k (DeepMap '[] v))
-> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] v
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
(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
onNest2 ((DeepMap '[] v -> DeepMap '[] w -> Maybe (DeepMap '[] v))
-> Map k (DeepMap '[] v)
-> Map k (DeepMap '[] w)
-> Map k (DeepMap '[] v)
forall k a b.
Ord k =>
(a -> b -> Maybe a) -> Map k a -> Map k b -> Map k a
Map.differenceWith ((DeepMap '[] v -> DeepMap '[] w -> Maybe (DeepMap '[] v))
 -> Map k (DeepMap '[] v)
 -> Map k (DeepMap '[] w)
 -> Map k (DeepMap '[] v))
-> (DeepMap '[] v -> DeepMap '[] w -> Maybe (DeepMap '[] v))
-> Map k (DeepMap '[] v)
-> Map k (DeepMap '[] w)
-> Map k (DeepMap '[] v)
forall a b. (a -> b) -> a -> b
$ (v -> w -> Maybe v)
-> DeepMap '[] v -> DeepMap '[] w -> Maybe (DeepMap '[] v)
forall (f :: * -> *) v w x.
Functor f =>
(v -> w -> f x)
-> DeepMap '[] v -> DeepMap '[] w -> f (DeepMap '[] x)
onBare2F v -> w -> Maybe v
f)

-- | /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
differenceWithKey :: (k -> DeepMap ks v -> DeepMap ls w -> Maybe (DeepMap ks v))
-> DeepMap (k : ks) v -> DeepMap (k : ls) w -> DeepMap (k : ks) v
differenceWithKey k -> DeepMap ks v -> DeepMap ls w -> Maybe (DeepMap ks v)
f = (Map k (DeepMap ks v)
 -> Map k (DeepMap ls w) -> Map k (DeepMap ks v))
-> DeepMap (k : ks) v -> DeepMap (k : ls) w -> DeepMap (k : ks) v
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
(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
onNest2 ((k -> DeepMap ks v -> DeepMap ls w -> Maybe (DeepMap ks v))
-> Map k (DeepMap ks v)
-> Map k (DeepMap ls w)
-> Map k (DeepMap ks v)
forall k a b.
Ord k =>
(k -> a -> b -> Maybe a) -> Map k a -> Map k b -> Map k a
Map.differenceWithKey k -> DeepMap ks v -> DeepMap ls w -> Maybe (DeepMap ks v)
f)

-- | /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
differenceWithKey1 :: (k -> v -> w -> Maybe v)
-> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] v
differenceWithKey1 k -> v -> w -> Maybe v
f = (Map k (DeepMap '[] v)
 -> Map k (DeepMap '[] w) -> Map k (DeepMap '[] v))
-> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] v
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
(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
onNest2 ((k -> DeepMap '[] v -> DeepMap '[] w -> Maybe (DeepMap '[] v))
-> Map k (DeepMap '[] v)
-> Map k (DeepMap '[] w)
-> Map k (DeepMap '[] v)
forall k a b.
Ord k =>
(k -> a -> b -> Maybe a) -> Map k a -> Map k b -> Map k a
Map.differenceWithKey ((k -> DeepMap '[] v -> DeepMap '[] w -> Maybe (DeepMap '[] v))
 -> Map k (DeepMap '[] v)
 -> Map k (DeepMap '[] w)
 -> Map k (DeepMap '[] v))
-> (k -> DeepMap '[] v -> DeepMap '[] w -> Maybe (DeepMap '[] v))
-> Map k (DeepMap '[] v)
-> Map k (DeepMap '[] w)
-> Map k (DeepMap '[] v)
forall a b. (a -> b) -> a -> b
$ (v -> w -> Maybe v)
-> DeepMap '[] v -> DeepMap '[] w -> Maybe (DeepMap '[] v)
forall (f :: * -> *) v w x.
Functor f =>
(v -> w -> f x)
-> DeepMap '[] v -> DeepMap '[] w -> f (DeepMap '[] x)
onBare2F ((v -> w -> Maybe v)
 -> DeepMap '[] v -> DeepMap '[] w -> Maybe (DeepMap '[] v))
-> (k -> v -> w -> Maybe v)
-> k
-> DeepMap '[] v
-> DeepMap '[] w
-> Maybe (DeepMap '[] v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> v -> w -> Maybe v
f)

-- | /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
intersection :: DeepMap (k : ks) v -> DeepMap (k : ls) w -> DeepMap (k : ks) v
intersection = (Map k (DeepMap ks v)
 -> Map k (DeepMap ls w) -> Map k (DeepMap ks v))
-> DeepMap (k : ks) v -> DeepMap (k : ls) w -> DeepMap (k : ks) v
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
(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
onNest2 Map k (DeepMap ks v)
-> Map k (DeepMap ls w) -> Map k (DeepMap ks v)
forall k a b. Ord k => Map k a -> Map k b -> Map k a
Map.intersection

-- | /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
intersectionWith :: (DeepMap ks v -> DeepMap ls w -> DeepMap ms x)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w -> DeepMap (k : ms) x
intersectionWith DeepMap ks v -> DeepMap ls w -> DeepMap ms x
f = (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
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
(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
onNest2 ((DeepMap ks v -> DeepMap ls w -> DeepMap ms x)
-> Map k (DeepMap ks v)
-> Map k (DeepMap ls w)
-> Map k (DeepMap ms x)
forall k a b c.
Ord k =>
(a -> b -> c) -> Map k a -> Map k b -> Map k c
Map.intersectionWith DeepMap ks v -> DeepMap ls w -> DeepMap ms x
f)

-- | /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
intersectionWith1 :: (v -> w -> x) -> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] x
intersectionWith1 v -> w -> x
f = (Map k (DeepMap '[] v)
 -> Map k (DeepMap '[] w) -> Map k (DeepMap '[] x))
-> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] x
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
(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
onNest2 ((DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x)
-> Map k (DeepMap '[] v)
-> Map k (DeepMap '[] w)
-> Map k (DeepMap '[] x)
forall k a b c.
Ord k =>
(a -> b -> c) -> Map k a -> Map k b -> Map k c
Map.intersectionWith ((DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x)
 -> Map k (DeepMap '[] v)
 -> Map k (DeepMap '[] w)
 -> Map k (DeepMap '[] x))
-> (DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x)
-> Map k (DeepMap '[] v)
-> Map k (DeepMap '[] w)
-> Map k (DeepMap '[] x)
forall a b. (a -> b) -> a -> b
$ (v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x
forall v w x.
(v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x
onBare2 v -> w -> x
f)

-- | /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
intersectionWithKey :: (k -> DeepMap ks v -> DeepMap ls w -> DeepMap ms x)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w -> DeepMap (k : ms) x
intersectionWithKey k -> DeepMap ks v -> DeepMap ls w -> DeepMap ms x
f = (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
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
(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
onNest2 ((k -> DeepMap ks v -> DeepMap ls w -> DeepMap ms x)
-> Map k (DeepMap ks v)
-> Map k (DeepMap ls w)
-> Map k (DeepMap ms x)
forall k a b c.
Ord k =>
(k -> a -> b -> c) -> Map k a -> Map k b -> Map k c
Map.intersectionWithKey k -> DeepMap ks v -> DeepMap ls w -> DeepMap ms x
f)

-- | /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
intersectionWithKey1 :: (k -> v -> w -> x)
-> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] x
intersectionWithKey1 k -> v -> w -> x
f = (Map k (DeepMap '[] v)
 -> Map k (DeepMap '[] w) -> Map k (DeepMap '[] x))
-> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] x
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
(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
onNest2 ((k -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x)
-> Map k (DeepMap '[] v)
-> Map k (DeepMap '[] w)
-> Map k (DeepMap '[] x)
forall k a b c.
Ord k =>
(k -> a -> b -> c) -> Map k a -> Map k b -> Map k c
Map.intersectionWithKey ((k -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x)
 -> Map k (DeepMap '[] v)
 -> Map k (DeepMap '[] w)
 -> Map k (DeepMap '[] x))
-> (k -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x)
-> Map k (DeepMap '[] v)
-> Map k (DeepMap '[] w)
-> Map k (DeepMap '[] x)
forall a b. (a -> b) -> a -> b
$ (v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x
forall v w x.
(v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x
onBare2 ((v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x)
-> (k -> v -> w -> x)
-> k
-> DeepMap '[] v
-> DeepMap '[] w
-> DeepMap '[] x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> v -> w -> x
f)

-- | /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
intersectionWithKey2 :: (k0 -> k1 -> v -> w -> x)
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] w
-> DeepMap '[k0, k1] x
intersectionWithKey2 k0 -> k1 -> v -> w -> x
f = (k0 -> DeepMap '[k1] v -> DeepMap '[k1] w -> DeepMap '[k1] x)
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] w
-> DeepMap '[k0, k1] x
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
Ord k =>
(k -> DeepMap ks v -> DeepMap ls w -> DeepMap ms x)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w -> DeepMap (k : ms) x
intersectionWithKey ((k1 -> v -> w -> x)
-> DeepMap '[k1] v -> DeepMap '[k1] w -> DeepMap '[k1] x
forall k v w x.
Ord k =>
(k -> v -> w -> x)
-> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] x
intersectionWithKey1 ((k1 -> v -> w -> x)
 -> DeepMap '[k1] v -> DeepMap '[k1] w -> DeepMap '[k1] x)
-> (k0 -> k1 -> v -> w -> x)
-> k0
-> DeepMap '[k1] v
-> DeepMap '[k1] w
-> DeepMap '[k1] x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> v -> w -> x
f)

-- | /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
intersectionWithKey3 :: (k0 -> k1 -> k2 -> v -> w -> x)
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] w
-> DeepMap '[k0, k1, k2] x
intersectionWithKey3 k0 -> k1 -> k2 -> v -> w -> x
f = (k0
 -> DeepMap '[k1, k2] v
 -> DeepMap '[k1, k2] w
 -> DeepMap '[k1, k2] x)
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] w
-> DeepMap '[k0, k1, k2] x
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
Ord k =>
(k -> DeepMap ks v -> DeepMap ls w -> DeepMap ms x)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w -> DeepMap (k : ms) x
intersectionWithKey ((k1 -> k2 -> v -> w -> x)
-> DeepMap '[k1, k2] v
-> DeepMap '[k1, k2] w
-> DeepMap '[k1, k2] x
forall k0 k1 v w x.
(Ord k0, Ord k1) =>
(k0 -> k1 -> v -> w -> x)
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] w
-> DeepMap '[k0, k1] x
intersectionWithKey2 ((k1 -> k2 -> v -> w -> x)
 -> DeepMap '[k1, k2] v
 -> DeepMap '[k1, k2] w
 -> DeepMap '[k1, k2] x)
-> (k0 -> k1 -> k2 -> v -> w -> x)
-> k0
-> DeepMap '[k1, k2] v
-> DeepMap '[k1, k2] w
-> DeepMap '[k1, k2] x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> v -> w -> x
f)

-- | /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
intersectionWithKey4 :: (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
intersectionWithKey4 k0 -> k1 -> k2 -> k3 -> v -> w -> x
f = (k0
 -> DeepMap '[k1, k2, k3] v
 -> DeepMap '[k1, k2, k3] w
 -> DeepMap '[k1, k2, k3] x)
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] w
-> DeepMap '[k0, k1, k2, k3] x
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
Ord k =>
(k -> DeepMap ks v -> DeepMap ls w -> DeepMap ms x)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w -> DeepMap (k : ms) x
intersectionWithKey ((k1 -> k2 -> k3 -> v -> w -> x)
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] w
-> DeepMap '[k1, k2, k3] x
forall k0 k1 k2 v w x.
(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
intersectionWithKey3 ((k1 -> k2 -> k3 -> v -> w -> x)
 -> DeepMap '[k1, k2, k3] v
 -> DeepMap '[k1, k2, k3] w
 -> DeepMap '[k1, k2, k3] x)
-> (k0 -> k1 -> k2 -> k3 -> v -> w -> x)
-> k0
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] w
-> DeepMap '[k1, k2, k3] x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> v -> w -> x
f)

-- | /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
intersectionWithKey5 :: (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
intersectionWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> w -> x
f = (k0
 -> DeepMap '[k1, k2, k3, k4] v
 -> DeepMap '[k1, k2, k3, k4] w
 -> DeepMap '[k1, k2, k3, k4] x)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] w
-> DeepMap '[k0, k1, k2, k3, k4] x
forall k (ks :: [*]) v (ls :: [*]) w (ms :: [*]) x.
Ord k =>
(k -> DeepMap ks v -> DeepMap ls w -> DeepMap ms x)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w -> DeepMap (k : ms) x
intersectionWithKey ((k1 -> k2 -> k3 -> k4 -> v -> w -> x)
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] w
-> DeepMap '[k1, k2, k3, k4] x
forall k0 k1 k2 k3 v w x.
(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
intersectionWithKey4 ((k1 -> k2 -> k3 -> k4 -> v -> w -> x)
 -> DeepMap '[k1, k2, k3, k4] v
 -> DeepMap '[k1, k2, k3, k4] w
 -> DeepMap '[k1, k2, k3, k4] x)
-> (k0 -> k1 -> k2 -> k3 -> k4 -> v -> w -> x)
-> k0
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] w
-> DeepMap '[k1, k2, k3, k4] x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> k4 -> v -> w -> x
f)

-- | /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
mapShallow :: (DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow DeepMap ks v -> DeepMap ls w
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ls w) -> DeepMap (k : ls) w
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ls w) -> DeepMap (k : ls) w)
-> Map k (DeepMap ls w) -> DeepMap (k : ls) w
forall a b. (a -> b) -> a -> b
$ (DeepMap ks v -> DeepMap ls w)
-> Map k (DeepMap ks v) -> Map k (DeepMap ls w)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DeepMap ks v -> DeepMap ls w
f Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
mapShallowWithKey :: (k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey k -> DeepMap ks v -> DeepMap ls w
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ls w) -> DeepMap (k : ls) w
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ls w) -> DeepMap (k : ls) w)
-> Map k (DeepMap ls w) -> DeepMap (k : ls) w
forall a b. (a -> b) -> a -> b
$ (k -> DeepMap ks v -> DeepMap ls w)
-> Map k (DeepMap ks v) -> Map k (DeepMap ls w)
forall k a b. (k -> a -> b) -> Map k a -> Map k b
Map.mapWithKey k -> DeepMap ks v -> DeepMap ls w
f Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /O(n)/. Like 'fmap' but the function has access to the outer keys.
mapWithKey1 :: (k -> v -> w) -> DeepMap '[k] v -> DeepMap '[k] w
mapWithKey1 :: (k -> v -> w) -> DeepMap '[k] v -> DeepMap '[k] w
mapWithKey1 k -> v -> w
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks w) -> DeepMap (k : ks) w
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks w) -> DeepMap (k : ks) w)
-> Map k (DeepMap ks w) -> DeepMap (k : ks) w
forall a b. (a -> b) -> a -> b
$ (k -> DeepMap ks v -> DeepMap ks w)
-> Map k (DeepMap ks v) -> Map k (DeepMap ks w)
forall k a b. (k -> a -> b) -> Map k a -> Map k b
Map.mapWithKey ((v -> w) -> DeepMap ks v -> DeepMap ks w
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((v -> w) -> DeepMap ks v -> DeepMap ks w)
-> (k -> v -> w) -> k -> DeepMap ks v -> DeepMap ks w
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> v -> w
f) Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
mapWithKey2 :: (k0 -> k1 -> v -> w) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] w
mapWithKey2 k0 -> k1 -> v -> w
f = (k0 -> DeepMap '[k1] v -> DeepMap '[k1] w)
-> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] w
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey ((k1 -> v -> w) -> DeepMap '[k1] v -> DeepMap '[k1] w
forall k v w. (k -> v -> w) -> DeepMap '[k] v -> DeepMap '[k] w
mapWithKey1 ((k1 -> v -> w) -> DeepMap '[k1] v -> DeepMap '[k1] w)
-> (k0 -> k1 -> v -> w) -> k0 -> DeepMap '[k1] v -> DeepMap '[k1] w
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> v -> w
f)

-- | /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
mapWithKey3 :: (k0 -> k1 -> k2 -> v -> w)
-> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] w
mapWithKey3 k0 -> k1 -> k2 -> v -> w
f = (k0 -> DeepMap '[k1, k2] v -> DeepMap '[k1, k2] w)
-> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] w
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey ((k1 -> k2 -> v -> w) -> DeepMap '[k1, k2] v -> DeepMap '[k1, k2] w
forall k0 k1 v w.
(k0 -> k1 -> v -> w) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] w
mapWithKey2 ((k1 -> k2 -> v -> w)
 -> DeepMap '[k1, k2] v -> DeepMap '[k1, k2] w)
-> (k0 -> k1 -> k2 -> v -> w)
-> k0
-> DeepMap '[k1, k2] v
-> DeepMap '[k1, k2] w
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> v -> w
f)

-- | /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
mapWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> w)
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] w
mapWithKey4 k0 -> k1 -> k2 -> k3 -> v -> w
f = (k0 -> DeepMap '[k1, k2, k3] v -> DeepMap '[k1, k2, k3] w)
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] w
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey ((k1 -> k2 -> k3 -> v -> w)
-> DeepMap '[k1, k2, k3] v -> DeepMap '[k1, k2, k3] w
forall k0 k1 k2 v w.
(k0 -> k1 -> k2 -> v -> w)
-> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] w
mapWithKey3 ((k1 -> k2 -> k3 -> v -> w)
 -> DeepMap '[k1, k2, k3] v -> DeepMap '[k1, k2, k3] w)
-> (k0 -> k1 -> k2 -> k3 -> v -> w)
-> k0
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] w
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> v -> w
f)

-- | /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
mapWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> w)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] w
mapWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> w
f = (k0 -> DeepMap '[k1, k2, k3, k4] v -> DeepMap '[k1, k2, k3, k4] w)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] w
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey ((k1 -> k2 -> k3 -> k4 -> v -> w)
-> DeepMap '[k1, k2, k3, k4] v -> DeepMap '[k1, k2, k3, k4] w
forall k0 k1 k2 k3 v w.
(k0 -> k1 -> k2 -> k3 -> v -> w)
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] w
mapWithKey4 ((k1 -> k2 -> k3 -> k4 -> v -> w)
 -> DeepMap '[k1, k2, k3, k4] v -> DeepMap '[k1, k2, k3, k4] w)
-> (k0 -> k1 -> k2 -> k3 -> k4 -> v -> w)
-> k0
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] w
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> k4 -> v -> w
f)

-- | /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)
traverseShallow :: (DeepMap ks v -> f (DeepMap ls w))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseShallow DeepMap ks v -> f (DeepMap ls w)
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ls w) -> DeepMap (k : ls) w
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ls w) -> DeepMap (k : ls) w)
-> f (Map k (DeepMap ls w)) -> f (DeepMap (k : ls) w)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DeepMap ks v -> f (DeepMap ls w))
-> Map k (DeepMap ks v) -> f (Map k (DeepMap ls w))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse DeepMap ks v -> f (DeepMap ls w)
f Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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)
traverseShallowWithKey :: (k -> DeepMap ks v -> f (DeepMap ls w))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseShallowWithKey k -> DeepMap ks v -> f (DeepMap ls w)
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ls w) -> DeepMap (k : ls) w
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ls w) -> DeepMap (k : ls) w)
-> f (Map k (DeepMap ls w)) -> f (DeepMap (k : ls) w)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (k -> DeepMap ks v -> f (DeepMap ls w))
-> Map k (DeepMap ks v) -> f (Map k (DeepMap ls w))
forall (t :: * -> *) k a b.
Applicative t =>
(k -> a -> t b) -> Map k a -> t (Map k b)
Map.traverseWithKey k -> DeepMap ks v -> f (DeepMap ls w)
f Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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)
traverseWithKey1 :: (k -> v -> f w) -> DeepMap '[k] v -> f (DeepMap '[k] w)
traverseWithKey1 k -> v -> f w
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks w) -> DeepMap (k : ks) w
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks w) -> DeepMap (k : ks) w)
-> f (Map k (DeepMap ks w)) -> f (DeepMap (k : ks) w)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (k -> DeepMap ks v -> f (DeepMap ks w))
-> Map k (DeepMap ks v) -> f (Map k (DeepMap ks w))
forall (t :: * -> *) k a b.
Applicative t =>
(k -> a -> t b) -> Map k a -> t (Map k b)
Map.traverseWithKey ((v -> f w) -> DeepMap ks v -> f (DeepMap ks w)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse ((v -> f w) -> DeepMap ks v -> f (DeepMap ks w))
-> (k -> v -> f w) -> k -> DeepMap ks v -> f (DeepMap ks w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> v -> f w
f) Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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)
traverseWithKey2 :: (k0 -> k1 -> v -> f w)
-> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] w)
traverseWithKey2 k0 -> k1 -> v -> f w
f = (k0 -> DeepMap '[k1] v -> f (DeepMap '[k1] w))
-> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] w)
forall (f :: * -> *) k (ks :: [*]) v (ls :: [*]) w.
Applicative f =>
(k -> DeepMap ks v -> f (DeepMap ls w))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseShallowWithKey ((k1 -> v -> f w) -> DeepMap '[k1] v -> f (DeepMap '[k1] w)
forall (f :: * -> *) k v w.
Applicative f =>
(k -> v -> f w) -> DeepMap '[k] v -> f (DeepMap '[k] w)
traverseWithKey1 ((k1 -> v -> f w) -> DeepMap '[k1] v -> f (DeepMap '[k1] w))
-> (k0 -> k1 -> v -> f w)
-> k0
-> DeepMap '[k1] v
-> f (DeepMap '[k1] w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> v -> f w
f)

-- | /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)
traverseWithKey3 :: (k0 -> k1 -> k2 -> v -> f w)
-> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] w)
traverseWithKey3 k0 -> k1 -> k2 -> v -> f w
f = (k0 -> DeepMap '[k1, k2] v -> f (DeepMap '[k1, k2] w))
-> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] w)
forall (f :: * -> *) k (ks :: [*]) v (ls :: [*]) w.
Applicative f =>
(k -> DeepMap ks v -> f (DeepMap ls w))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseShallowWithKey ((k1 -> k2 -> v -> f w)
-> DeepMap '[k1, k2] v -> f (DeepMap '[k1, k2] w)
forall (f :: * -> *) k0 k1 v w.
Applicative f =>
(k0 -> k1 -> v -> f w)
-> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] w)
traverseWithKey2 ((k1 -> k2 -> v -> f w)
 -> DeepMap '[k1, k2] v -> f (DeepMap '[k1, k2] w))
-> (k0 -> k1 -> k2 -> v -> f w)
-> k0
-> DeepMap '[k1, k2] v
-> f (DeepMap '[k1, k2] w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> v -> f w
f)

-- | /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)
traverseWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> f w)
-> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] w)
traverseWithKey4 k0 -> k1 -> k2 -> k3 -> v -> f w
f = (k0 -> DeepMap '[k1, k2, k3] v -> f (DeepMap '[k1, k2, k3] w))
-> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] w)
forall (f :: * -> *) k (ks :: [*]) v (ls :: [*]) w.
Applicative f =>
(k -> DeepMap ks v -> f (DeepMap ls w))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseShallowWithKey ((k1 -> k2 -> k3 -> v -> f w)
-> DeepMap '[k1, k2, k3] v -> f (DeepMap '[k1, k2, k3] w)
forall (f :: * -> *) k0 k1 k2 v w.
Applicative f =>
(k0 -> k1 -> k2 -> v -> f w)
-> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] w)
traverseWithKey3 ((k1 -> k2 -> k3 -> v -> f w)
 -> DeepMap '[k1, k2, k3] v -> f (DeepMap '[k1, k2, k3] w))
-> (k0 -> k1 -> k2 -> k3 -> v -> f w)
-> k0
-> DeepMap '[k1, k2, k3] v
-> f (DeepMap '[k1, k2, k3] w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> v -> f w
f)

-- | /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)
traverseWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> f w)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> f (DeepMap '[k0, k1, k2, k3, k4] w)
traverseWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> f w
f = (k0
 -> DeepMap '[k1, k2, k3, k4] v -> f (DeepMap '[k1, k2, k3, k4] w))
-> DeepMap '[k0, k1, k2, k3, k4] v
-> f (DeepMap '[k0, k1, k2, k3, k4] w)
forall (f :: * -> *) k (ks :: [*]) v (ls :: [*]) w.
Applicative f =>
(k -> DeepMap ks v -> f (DeepMap ls w))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseShallowWithKey ((k1 -> k2 -> k3 -> k4 -> v -> f w)
-> DeepMap '[k1, k2, k3, k4] v -> f (DeepMap '[k1, k2, k3, k4] w)
forall (f :: * -> *) k0 k1 k2 k3 v w.
Applicative f =>
(k0 -> k1 -> k2 -> k3 -> v -> f w)
-> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] w)
traverseWithKey4 ((k1 -> k2 -> k3 -> k4 -> v -> f w)
 -> DeepMap '[k1, k2, k3, k4] v -> f (DeepMap '[k1, k2, k3, k4] w))
-> (k0 -> k1 -> k2 -> k3 -> k4 -> v -> f w)
-> k0
-> DeepMap '[k1, k2, k3, k4] v
-> f (DeepMap '[k1, k2, k3, k4] w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> k4 -> v -> f w
f)

-- | /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)
traverseMaybeWithKey :: (k -> DeepMap ks v -> f (Maybe (DeepMap ls w)))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseMaybeWithKey k -> DeepMap ks v -> f (Maybe (DeepMap ls w))
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ls w) -> DeepMap (k : ls) w
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ls w) -> DeepMap (k : ls) w)
-> f (Map k (DeepMap ls w)) -> f (DeepMap (k : ls) w)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (k -> DeepMap ks v -> f (Maybe (DeepMap ls w)))
-> Map k (DeepMap ks v) -> f (Map k (DeepMap ls w))
forall (f :: * -> *) k a b.
Applicative f =>
(k -> a -> f (Maybe b)) -> Map k a -> f (Map k b)
Map.traverseMaybeWithKey k -> DeepMap ks v -> f (Maybe (DeepMap ls w))
f Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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)
traverseMaybeWithKey1 :: (k -> v -> f (Maybe w)) -> DeepMap '[k] v -> f (DeepMap '[k] w)
traverseMaybeWithKey1 k -> v -> f (Maybe w)
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap '[] w) -> DeepMap '[k] w
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap '[] w) -> DeepMap '[k] w)
-> f (Map k (DeepMap '[] w)) -> f (DeepMap '[k] w)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (k -> DeepMap ks v -> f (Maybe (DeepMap '[] w)))
-> Map k (DeepMap ks v) -> f (Map k (DeepMap '[] w))
forall (f :: * -> *) k a b.
Applicative f =>
(k -> a -> f (Maybe b)) -> Map k a -> f (Map k b)
Map.traverseMaybeWithKey (\k
k (Bare v
v) -> (w -> DeepMap '[] w) -> Maybe w -> Maybe (DeepMap '[] w)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap w -> DeepMap '[] w
forall v. v -> DeepMap '[] v
Bare (Maybe w -> Maybe (DeepMap '[] w))
-> f (Maybe w) -> f (Maybe (DeepMap '[] w))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> k -> v -> f (Maybe w)
f k
k
k v
v) Map k (DeepMap ks v)
m

-- | /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)
traverseMaybeWithKey2 :: (k0 -> k1 -> v -> f (Maybe w))
-> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] w)
traverseMaybeWithKey2 k0 -> k1 -> v -> f (Maybe w)
f = (k0 -> DeepMap '[k1] v -> f (Maybe (DeepMap '[k1] w)))
-> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] w)
forall (f :: * -> *) k (ks :: [*]) v (ls :: [*]) w.
Applicative f =>
(k -> DeepMap ks v -> f (Maybe (DeepMap ls w)))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseMaybeWithKey ((f (DeepMap '[k1] w) -> f (Maybe (DeepMap '[k1] w)))
-> (DeepMap '[k1] v -> f (DeepMap '[k1] w))
-> DeepMap '[k1] v
-> f (Maybe (DeepMap '[k1] w))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((DeepMap '[k1] w -> Maybe (DeepMap '[k1] w))
-> f (DeepMap '[k1] w) -> f (Maybe (DeepMap '[k1] w))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DeepMap '[k1] w -> Maybe (DeepMap '[k1] w)
forall a. a -> Maybe a
Just) ((DeepMap '[k1] v -> f (DeepMap '[k1] w))
 -> DeepMap '[k1] v -> f (Maybe (DeepMap '[k1] w)))
-> (k0 -> DeepMap '[k1] v -> f (DeepMap '[k1] w))
-> k0
-> DeepMap '[k1] v
-> f (Maybe (DeepMap '[k1] w))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k1 -> v -> f (Maybe w)) -> DeepMap '[k1] v -> f (DeepMap '[k1] w)
forall (f :: * -> *) k v w.
Applicative f =>
(k -> v -> f (Maybe w)) -> DeepMap '[k] v -> f (DeepMap '[k] w)
traverseMaybeWithKey1 ((k1 -> v -> f (Maybe w))
 -> DeepMap '[k1] v -> f (DeepMap '[k1] w))
-> (k0 -> k1 -> v -> f (Maybe w))
-> k0
-> DeepMap '[k1] v
-> f (DeepMap '[k1] w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> v -> f (Maybe w)
f)

-- | /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)
traverseMaybeWithKey3 :: (k0 -> k1 -> k2 -> v -> f (Maybe w))
-> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] w)
traverseMaybeWithKey3 k0 -> k1 -> k2 -> v -> f (Maybe w)
f = (k0 -> DeepMap '[k1, k2] v -> f (Maybe (DeepMap '[k1, k2] w)))
-> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] w)
forall (f :: * -> *) k (ks :: [*]) v (ls :: [*]) w.
Applicative f =>
(k -> DeepMap ks v -> f (Maybe (DeepMap ls w)))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseMaybeWithKey ((f (DeepMap '[k1, k2] w) -> f (Maybe (DeepMap '[k1, k2] w)))
-> (DeepMap '[k1, k2] v -> f (DeepMap '[k1, k2] w))
-> DeepMap '[k1, k2] v
-> f (Maybe (DeepMap '[k1, k2] w))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((DeepMap '[k1, k2] w -> Maybe (DeepMap '[k1, k2] w))
-> f (DeepMap '[k1, k2] w) -> f (Maybe (DeepMap '[k1, k2] w))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DeepMap '[k1, k2] w -> Maybe (DeepMap '[k1, k2] w)
forall a. a -> Maybe a
Just) ((DeepMap '[k1, k2] v -> f (DeepMap '[k1, k2] w))
 -> DeepMap '[k1, k2] v -> f (Maybe (DeepMap '[k1, k2] w)))
-> (k0 -> DeepMap '[k1, k2] v -> f (DeepMap '[k1, k2] w))
-> k0
-> DeepMap '[k1, k2] v
-> f (Maybe (DeepMap '[k1, k2] w))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k1 -> k2 -> v -> f (Maybe w))
-> DeepMap '[k1, k2] v -> f (DeepMap '[k1, k2] w)
forall (f :: * -> *) k0 k1 v w.
Applicative f =>
(k0 -> k1 -> v -> f (Maybe w))
-> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] w)
traverseMaybeWithKey2 ((k1 -> k2 -> v -> f (Maybe w))
 -> DeepMap '[k1, k2] v -> f (DeepMap '[k1, k2] w))
-> (k0 -> k1 -> k2 -> v -> f (Maybe w))
-> k0
-> DeepMap '[k1, k2] v
-> f (DeepMap '[k1, k2] w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> v -> f (Maybe w)
f)

-- | /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)
traverseMaybeWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> f (Maybe w))
-> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] w)
traverseMaybeWithKey4 k0 -> k1 -> k2 -> k3 -> v -> f (Maybe w)
f = (k0
 -> DeepMap '[k1, k2, k3] v -> f (Maybe (DeepMap '[k1, k2, k3] w)))
-> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] w)
forall (f :: * -> *) k (ks :: [*]) v (ls :: [*]) w.
Applicative f =>
(k -> DeepMap ks v -> f (Maybe (DeepMap ls w)))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseMaybeWithKey ((f (DeepMap '[k1, k2, k3] w)
 -> f (Maybe (DeepMap '[k1, k2, k3] w)))
-> (DeepMap '[k1, k2, k3] v -> f (DeepMap '[k1, k2, k3] w))
-> DeepMap '[k1, k2, k3] v
-> f (Maybe (DeepMap '[k1, k2, k3] w))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((DeepMap '[k1, k2, k3] w -> Maybe (DeepMap '[k1, k2, k3] w))
-> f (DeepMap '[k1, k2, k3] w)
-> f (Maybe (DeepMap '[k1, k2, k3] w))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DeepMap '[k1, k2, k3] w -> Maybe (DeepMap '[k1, k2, k3] w)
forall a. a -> Maybe a
Just) ((DeepMap '[k1, k2, k3] v -> f (DeepMap '[k1, k2, k3] w))
 -> DeepMap '[k1, k2, k3] v -> f (Maybe (DeepMap '[k1, k2, k3] w)))
-> (k0 -> DeepMap '[k1, k2, k3] v -> f (DeepMap '[k1, k2, k3] w))
-> k0
-> DeepMap '[k1, k2, k3] v
-> f (Maybe (DeepMap '[k1, k2, k3] w))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k1 -> k2 -> k3 -> v -> f (Maybe w))
-> DeepMap '[k1, k2, k3] v -> f (DeepMap '[k1, k2, k3] w)
forall (f :: * -> *) k0 k1 k2 v w.
Applicative f =>
(k0 -> k1 -> k2 -> v -> f (Maybe w))
-> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] w)
traverseMaybeWithKey3 ((k1 -> k2 -> k3 -> v -> f (Maybe w))
 -> DeepMap '[k1, k2, k3] v -> f (DeepMap '[k1, k2, k3] w))
-> (k0 -> k1 -> k2 -> k3 -> v -> f (Maybe w))
-> k0
-> DeepMap '[k1, k2, k3] v
-> f (DeepMap '[k1, k2, k3] w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> v -> f (Maybe w)
f)

-- | /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)
traverseMaybeWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> f (Maybe w))
-> DeepMap '[k0, k1, k2, k3, k4] v
-> f (DeepMap '[k0, k1, k2, k3, k4] w)
traverseMaybeWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> f (Maybe w)
f = (k0
 -> DeepMap '[k1, k2, k3, k4] v
 -> f (Maybe (DeepMap '[k1, k2, k3, k4] w)))
-> DeepMap '[k0, k1, k2, k3, k4] v
-> f (DeepMap '[k0, k1, k2, k3, k4] w)
forall (f :: * -> *) k (ks :: [*]) v (ls :: [*]) w.
Applicative f =>
(k -> DeepMap ks v -> f (Maybe (DeepMap ls w)))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseMaybeWithKey ((f (DeepMap '[k1, k2, k3, k4] w)
 -> f (Maybe (DeepMap '[k1, k2, k3, k4] w)))
-> (DeepMap '[k1, k2, k3, k4] v -> f (DeepMap '[k1, k2, k3, k4] w))
-> DeepMap '[k1, k2, k3, k4] v
-> f (Maybe (DeepMap '[k1, k2, k3, k4] w))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((DeepMap '[k1, k2, k3, k4] w
 -> Maybe (DeepMap '[k1, k2, k3, k4] w))
-> f (DeepMap '[k1, k2, k3, k4] w)
-> f (Maybe (DeepMap '[k1, k2, k3, k4] w))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DeepMap '[k1, k2, k3, k4] w -> Maybe (DeepMap '[k1, k2, k3, k4] w)
forall a. a -> Maybe a
Just) ((DeepMap '[k1, k2, k3, k4] v -> f (DeepMap '[k1, k2, k3, k4] w))
 -> DeepMap '[k1, k2, k3, k4] v
 -> f (Maybe (DeepMap '[k1, k2, k3, k4] w)))
-> (k0
    -> DeepMap '[k1, k2, k3, k4] v -> f (DeepMap '[k1, k2, k3, k4] w))
-> k0
-> DeepMap '[k1, k2, k3, k4] v
-> f (Maybe (DeepMap '[k1, k2, k3, k4] w))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k1 -> k2 -> k3 -> k4 -> v -> f (Maybe w))
-> DeepMap '[k1, k2, k3, k4] v -> f (DeepMap '[k1, k2, k3, k4] w)
forall (f :: * -> *) k0 k1 k2 k3 v w.
Applicative f =>
(k0 -> k1 -> k2 -> k3 -> v -> f (Maybe w))
-> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] w)
traverseMaybeWithKey4 ((k1 -> k2 -> k3 -> k4 -> v -> f (Maybe w))
 -> DeepMap '[k1, k2, k3, k4] v -> f (DeepMap '[k1, k2, k3, k4] w))
-> (k0 -> k1 -> k2 -> k3 -> k4 -> v -> f (Maybe w))
-> k0
-> DeepMap '[k1, k2, k3, k4] v
-> f (DeepMap '[k1, k2, k3, k4] w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> k4 -> v -> f (Maybe w)
f)

-- | /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)
mapAccum :: (acc -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> DeepMap (k : ks) v -> (acc, DeepMap (k : ls) w)
mapAccum acc -> DeepMap ks v -> (acc, DeepMap ls w)
f acc
acc (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ls w) -> DeepMap (k : ls) w
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ls w) -> DeepMap (k : ls) w)
-> (acc, Map k (DeepMap ls w)) -> (acc, DeepMap (k : ls) w)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (acc -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> Map k (DeepMap ks v) -> (acc, Map k (DeepMap ls w))
forall a b c k. (a -> b -> (a, c)) -> a -> Map k b -> (a, Map k c)
Map.mapAccum acc -> DeepMap ks v -> (acc, DeepMap ls w)
f acc
acc Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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)
mapAccum1 :: (acc -> v -> (acc, w))
-> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
mapAccum1 acc -> v -> (acc, w)
f = (acc -> DeepMap '[] v -> (acc, DeepMap '[] w))
-> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
forall acc (ks :: [*]) v (ls :: [*]) w k.
(acc -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> DeepMap (k : ks) v -> (acc, DeepMap (k : ls) w)
mapAccum (\acc
a (Bare v
v) -> w -> DeepMap '[] w
forall v. v -> DeepMap '[] v
Bare (w -> DeepMap '[] w) -> (acc, w) -> (acc, DeepMap '[] w)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> acc -> v -> (acc, w)
f acc
a v
v)

-- | /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)
mapAccumR :: (acc -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> DeepMap (k : ks) v -> (acc, DeepMap (k : ls) w)
mapAccumR acc -> DeepMap ks v -> (acc, DeepMap ls w)
f acc
acc (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ls w) -> DeepMap (k : ls) w
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ls w) -> DeepMap (k : ls) w)
-> (acc, Map k (DeepMap ls w)) -> (acc, DeepMap (k : ls) w)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (acc -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> Map k (DeepMap ks v) -> (acc, Map k (DeepMap ls w))
forall a b c k. (a -> b -> (a, c)) -> a -> Map k b -> (a, Map k c)
Map.mapAccum acc -> DeepMap ks v -> (acc, DeepMap ls w)
f acc
acc Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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)
mapAccumR1 :: (acc -> v -> (acc, w))
-> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
mapAccumR1 acc -> v -> (acc, w)
f = (acc -> DeepMap '[] v -> (acc, DeepMap '[] w))
-> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
forall acc (ks :: [*]) v (ls :: [*]) w k.
(acc -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> DeepMap (k : ks) v -> (acc, DeepMap (k : ls) w)
mapAccumR (\acc
a (Bare v
v) -> w -> DeepMap '[] w
forall v. v -> DeepMap '[] v
Bare (w -> DeepMap '[] w) -> (acc, w) -> (acc, DeepMap '[] w)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> acc -> v -> (acc, w)
f acc
a v
v)

-- | /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)
mapAccumWithKey :: (acc -> k -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> DeepMap (k : ks) v -> (acc, DeepMap (k : ls) w)
mapAccumWithKey acc -> k -> DeepMap ks v -> (acc, DeepMap ls w)
f acc
acc (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ls w) -> DeepMap (k : ls) w
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ls w) -> DeepMap (k : ls) w)
-> (acc, Map k (DeepMap ls w)) -> (acc, DeepMap (k : ls) w)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (acc -> k -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> Map k (DeepMap ks v) -> (acc, Map k (DeepMap ls w))
forall a k b c.
(a -> k -> b -> (a, c)) -> a -> Map k b -> (a, Map k c)
Map.mapAccumWithKey acc -> k -> DeepMap ks v -> (acc, DeepMap ls w)
f acc
acc Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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)
mapAccumWithKey1 :: (acc -> k -> v -> (acc, w))
-> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
mapAccumWithKey1 acc -> k -> v -> (acc, w)
f = (acc -> k -> DeepMap '[] v -> (acc, DeepMap '[] w))
-> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
forall acc k (ks :: [*]) v (ls :: [*]) w.
(acc -> k -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> DeepMap (k : ks) v -> (acc, DeepMap (k : ls) w)
mapAccumWithKey (\acc
k k
a (Bare v
v) -> w -> DeepMap '[] w
forall v. v -> DeepMap '[] v
Bare (w -> DeepMap '[] w) -> (acc, w) -> (acc, DeepMap '[] w)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> acc -> k -> v -> (acc, w)
f acc
k k
a v
v)

-- | /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)
mapAccumWithKey2 :: (acc -> k0 -> k1 -> v -> (acc, w))
-> acc -> DeepMap '[k0, k1] v -> (acc, DeepMap '[k0, k1] w)
mapAccumWithKey2 acc -> k0 -> k1 -> v -> (acc, w)
f = (acc -> k0 -> DeepMap '[k1] v -> (acc, DeepMap '[k1] w))
-> acc -> DeepMap '[k0, k1] v -> (acc, DeepMap '[k0, k1] w)
forall acc k (ks :: [*]) v (ls :: [*]) w.
(acc -> k -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> DeepMap (k : ks) v -> (acc, DeepMap (k : ls) w)
mapAccumWithKey (\acc
a k0
k0 -> (acc -> k1 -> v -> (acc, w))
-> acc -> DeepMap '[k1] v -> (acc, DeepMap '[k1] w)
forall acc k v w.
(acc -> k -> v -> (acc, w))
-> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
mapAccumWithKey1 (acc -> k0 -> k1 -> v -> (acc, w)
`f` k0
k0) acc
a)

-- | /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)
mapAccumWithKey3 :: (acc -> k0 -> k1 -> k2 -> v -> (acc, w))
-> acc -> DeepMap '[k0, k1, k2] v -> (acc, DeepMap '[k0, k1, k2] w)
mapAccumWithKey3 acc -> k0 -> k1 -> k2 -> v -> (acc, w)
f = (acc -> k0 -> DeepMap '[k1, k2] v -> (acc, DeepMap '[k1, k2] w))
-> acc -> DeepMap '[k0, k1, k2] v -> (acc, DeepMap '[k0, k1, k2] w)
forall acc k (ks :: [*]) v (ls :: [*]) w.
(acc -> k -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> DeepMap (k : ks) v -> (acc, DeepMap (k : ls) w)
mapAccumWithKey (\acc
a k0
k0 -> (acc -> k1 -> k2 -> v -> (acc, w))
-> acc -> DeepMap '[k1, k2] v -> (acc, DeepMap '[k1, k2] w)
forall acc k0 k1 v w.
(acc -> k0 -> k1 -> v -> (acc, w))
-> acc -> DeepMap '[k0, k1] v -> (acc, DeepMap '[k0, k1] w)
mapAccumWithKey2 (acc -> k0 -> k1 -> k2 -> v -> (acc, w)
`f` k0
k0) acc
a)

-- | /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)
mapAccumWithKey4 :: (acc -> k0 -> k1 -> k2 -> k3 -> v -> (acc, w))
-> acc
-> DeepMap '[k0, k1, k2, k3] v
-> (acc, DeepMap '[k0, k1, k2, k3] w)
mapAccumWithKey4 acc -> k0 -> k1 -> k2 -> k3 -> v -> (acc, w)
f = (acc
 -> k0 -> DeepMap '[k1, k2, k3] v -> (acc, DeepMap '[k1, k2, k3] w))
-> acc
-> DeepMap '[k0, k1, k2, k3] v
-> (acc, DeepMap '[k0, k1, k2, k3] w)
forall acc k (ks :: [*]) v (ls :: [*]) w.
(acc -> k -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> DeepMap (k : ks) v -> (acc, DeepMap (k : ls) w)
mapAccumWithKey (\acc
a k0
k0 -> (acc -> k1 -> k2 -> k3 -> v -> (acc, w))
-> acc -> DeepMap '[k1, k2, k3] v -> (acc, DeepMap '[k1, k2, k3] w)
forall acc k0 k1 k2 v w.
(acc -> k0 -> k1 -> k2 -> v -> (acc, w))
-> acc -> DeepMap '[k0, k1, k2] v -> (acc, DeepMap '[k0, k1, k2] w)
mapAccumWithKey3 (acc -> k0 -> k1 -> k2 -> k3 -> v -> (acc, w)
`f` k0
k0) acc
a)

-- | /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)
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)
mapAccumWithKey5 acc -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> (acc, w)
f = (acc
 -> k0
 -> DeepMap '[k1, k2, k3, k4] v
 -> (acc, DeepMap '[k1, k2, k3, k4] w))
-> acc
-> DeepMap '[k0, k1, k2, k3, k4] v
-> (acc, DeepMap '[k0, k1, k2, k3, k4] w)
forall acc k (ks :: [*]) v (ls :: [*]) w.
(acc -> k -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> DeepMap (k : ks) v -> (acc, DeepMap (k : ls) w)
mapAccumWithKey (\acc
a k0
k0 -> (acc -> k1 -> k2 -> k3 -> k4 -> v -> (acc, w))
-> acc
-> DeepMap '[k1, k2, k3, k4] v
-> (acc, DeepMap '[k1, k2, k3, k4] w)
forall acc k0 k1 k2 k3 v w.
(acc -> k0 -> k1 -> k2 -> k3 -> v -> (acc, w))
-> acc
-> DeepMap '[k0, k1, k2, k3] v
-> (acc, DeepMap '[k0, k1, k2, k3] w)
mapAccumWithKey4 (acc -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> (acc, w)
`f` k0
k0) acc
a)

-- | /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)
mapAccumRWithKey :: (acc -> k -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> DeepMap (k : ks) v -> (acc, DeepMap (k : ls) w)
mapAccumRWithKey acc -> k -> DeepMap ks v -> (acc, DeepMap ls w)
f acc
acc (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ls w) -> DeepMap (k : ls) w
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ls w) -> DeepMap (k : ls) w)
-> (acc, Map k (DeepMap ls w)) -> (acc, DeepMap (k : ls) w)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (acc -> k -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> Map k (DeepMap ks v) -> (acc, Map k (DeepMap ls w))
forall a k b c.
(a -> k -> b -> (a, c)) -> a -> Map k b -> (a, Map k c)
Map.mapAccumRWithKey acc -> k -> DeepMap ks v -> (acc, DeepMap ls w)
f acc
acc Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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)
mapAccumRWithKey1 :: (acc -> k -> v -> (acc, w))
-> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
mapAccumRWithKey1 acc -> k -> v -> (acc, w)
f = (acc -> k -> DeepMap '[] v -> (acc, DeepMap '[] w))
-> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
forall acc k (ks :: [*]) v (ls :: [*]) w.
(acc -> k -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> DeepMap (k : ks) v -> (acc, DeepMap (k : ls) w)
mapAccumRWithKey (\acc
k k
a (Bare v
v) -> w -> DeepMap '[] w
forall v. v -> DeepMap '[] v
Bare (w -> DeepMap '[] w) -> (acc, w) -> (acc, DeepMap '[] w)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> acc -> k -> v -> (acc, w)
f acc
k k
a v
v)

-- | /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)
mapAccumRWithKey2 :: (acc -> k0 -> k1 -> v -> (acc, w))
-> acc -> DeepMap '[k0, k1] v -> (acc, DeepMap '[k0, k1] w)
mapAccumRWithKey2 acc -> k0 -> k1 -> v -> (acc, w)
f = (acc -> k0 -> DeepMap '[k1] v -> (acc, DeepMap '[k1] w))
-> acc -> DeepMap '[k0, k1] v -> (acc, DeepMap '[k0, k1] w)
forall acc k (ks :: [*]) v (ls :: [*]) w.
(acc -> k -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> DeepMap (k : ks) v -> (acc, DeepMap (k : ls) w)
mapAccumRWithKey (\acc
a k0
k0 -> (acc -> k1 -> v -> (acc, w))
-> acc -> DeepMap '[k1] v -> (acc, DeepMap '[k1] w)
forall acc k v w.
(acc -> k -> v -> (acc, w))
-> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
mapAccumRWithKey1 (acc -> k0 -> k1 -> v -> (acc, w)
`f` k0
k0) acc
a)

-- | /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)
mapAccumRWithKey3 :: (acc -> k0 -> k1 -> k2 -> v -> (acc, w))
-> acc -> DeepMap '[k0, k1, k2] v -> (acc, DeepMap '[k0, k1, k2] w)
mapAccumRWithKey3 acc -> k0 -> k1 -> k2 -> v -> (acc, w)
f = (acc -> k0 -> DeepMap '[k1, k2] v -> (acc, DeepMap '[k1, k2] w))
-> acc -> DeepMap '[k0, k1, k2] v -> (acc, DeepMap '[k0, k1, k2] w)
forall acc k (ks :: [*]) v (ls :: [*]) w.
(acc -> k -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> DeepMap (k : ks) v -> (acc, DeepMap (k : ls) w)
mapAccumRWithKey (\acc
a k0
k0 -> (acc -> k1 -> k2 -> v -> (acc, w))
-> acc -> DeepMap '[k1, k2] v -> (acc, DeepMap '[k1, k2] w)
forall acc k0 k1 v w.
(acc -> k0 -> k1 -> v -> (acc, w))
-> acc -> DeepMap '[k0, k1] v -> (acc, DeepMap '[k0, k1] w)
mapAccumRWithKey2 (acc -> k0 -> k1 -> k2 -> v -> (acc, w)
`f` k0
k0) acc
a)

-- | /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)
mapAccumRWithKey4 :: (acc -> k0 -> k1 -> k2 -> k3 -> v -> (acc, w))
-> acc
-> DeepMap '[k0, k1, k2, k3] v
-> (acc, DeepMap '[k0, k1, k2, k3] w)
mapAccumRWithKey4 acc -> k0 -> k1 -> k2 -> k3 -> v -> (acc, w)
f = (acc
 -> k0 -> DeepMap '[k1, k2, k3] v -> (acc, DeepMap '[k1, k2, k3] w))
-> acc
-> DeepMap '[k0, k1, k2, k3] v
-> (acc, DeepMap '[k0, k1, k2, k3] w)
forall acc k (ks :: [*]) v (ls :: [*]) w.
(acc -> k -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> DeepMap (k : ks) v -> (acc, DeepMap (k : ls) w)
mapAccumRWithKey (\acc
a k0
k0 -> (acc -> k1 -> k2 -> k3 -> v -> (acc, w))
-> acc -> DeepMap '[k1, k2, k3] v -> (acc, DeepMap '[k1, k2, k3] w)
forall acc k0 k1 k2 v w.
(acc -> k0 -> k1 -> k2 -> v -> (acc, w))
-> acc -> DeepMap '[k0, k1, k2] v -> (acc, DeepMap '[k0, k1, k2] w)
mapAccumRWithKey3 (acc -> k0 -> k1 -> k2 -> k3 -> v -> (acc, w)
`f` k0
k0) acc
a)

-- | /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)
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)
mapAccumRWithKey5 acc -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> (acc, w)
f = (acc
 -> k0
 -> DeepMap '[k1, k2, k3, k4] v
 -> (acc, DeepMap '[k1, k2, k3, k4] w))
-> acc
-> DeepMap '[k0, k1, k2, k3, k4] v
-> (acc, DeepMap '[k0, k1, k2, k3, k4] w)
forall acc k (ks :: [*]) v (ls :: [*]) w.
(acc -> k -> DeepMap ks v -> (acc, DeepMap ls w))
-> acc -> DeepMap (k : ks) v -> (acc, DeepMap (k : ls) w)
mapAccumRWithKey (\acc
a k0
k0 -> (acc -> k1 -> k2 -> k3 -> k4 -> v -> (acc, w))
-> acc
-> DeepMap '[k1, k2, k3, k4] v
-> (acc, DeepMap '[k1, k2, k3, k4] w)
forall acc k0 k1 k2 k3 v w.
(acc -> k0 -> k1 -> k2 -> k3 -> v -> (acc, w))
-> acc
-> DeepMap '[k0, k1, k2, k3] v
-> (acc, DeepMap '[k0, k1, k2, k3] w)
mapAccumRWithKey4 (acc -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> (acc, w)
`f` k0
k0) acc
a)

-- | /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 'Data.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
mapKeys :: (j -> k) -> DeepMap (j : ks) v -> DeepMap (k : ks) v
mapKeys j -> k
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> (j -> k) -> Map j (DeepMap ks v) -> Map k (DeepMap ks v)
forall k2 a k1.
Ord k2 =>
(a -> a -> a) -> (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeysWith DeepMap ks v -> DeepMap ks v -> DeepMap ks v
forall a. Semigroup a => a -> a -> a
(<>) j -> k
f Map j (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
mapKeys1 :: (j -> k) -> DeepMap '[j] v -> DeepMap '[k] v
mapKeys1 = (j -> k) -> DeepMap '[j] v -> DeepMap '[k] v
forall k (ks :: [*]) v j.
(Ord k, Semigroup (DeepMap ks v)) =>
(j -> k) -> DeepMap (j : ks) v -> DeepMap (k : ks) v
mapKeys

-- | /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
mapKeys2 :: (j0 -> k0)
-> (j1 -> k1)
-> DeepMap (j0 : j1 : ks) v
-> DeepMap (k0 : k1 : ks) v
mapKeys2 j0 -> k0
f0 j1 -> k1
f1 DeepMap (j0 : j1 : ks) v
m = (j0 -> k0) -> DeepMap (j0 : k1 : ks) v -> DeepMap (k0 : k1 : ks) v
forall k (ks :: [*]) v j.
(Ord k, Semigroup (DeepMap ks v)) =>
(j -> k) -> DeepMap (j : ks) v -> DeepMap (k : ks) v
mapKeys j0 -> k0
f0 (DeepMap (j0 : k1 : ks) v -> DeepMap (k0 : k1 : ks) v)
-> DeepMap (j0 : k1 : ks) v -> DeepMap (k0 : k1 : ks) v
forall a b. (a -> b) -> a -> b
$ (DeepMap (j1 : ks) v -> DeepMap (k1 : ks) v)
-> DeepMap (j0 : j1 : ks) v -> DeepMap (j0 : k1 : ks) v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow ((j1 -> k1) -> DeepMap (j1 : ks) v -> DeepMap (k1 : ks) v
forall k (ks :: [*]) v j.
(Ord k, Semigroup (DeepMap ks v)) =>
(j -> k) -> DeepMap (j : ks) v -> DeepMap (k : ks) v
mapKeys j1 -> k1
f1) DeepMap (j0 : j1 : ks) v
m

-- | /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
mapKeys3 :: (j0 -> k0)
-> (j1 -> k1)
-> (j2 -> k2)
-> DeepMap (j0 : j1 : j2 : ks) v
-> DeepMap (k0 : k1 : k2 : ks) v
mapKeys3 j0 -> k0
f0 j1 -> k1
f1 j2 -> k2
f2 DeepMap (j0 : j1 : j2 : ks) v
m = (j0 -> k0)
-> DeepMap (j0 : k1 : k2 : ks) v -> DeepMap (k0 : k1 : k2 : ks) v
forall k (ks :: [*]) v j.
(Ord k, Semigroup (DeepMap ks v)) =>
(j -> k) -> DeepMap (j : ks) v -> DeepMap (k : ks) v
mapKeys j0 -> k0
f0 (DeepMap (j0 : k1 : k2 : ks) v -> DeepMap (k0 : k1 : k2 : ks) v)
-> DeepMap (j0 : k1 : k2 : ks) v -> DeepMap (k0 : k1 : k2 : ks) v
forall a b. (a -> b) -> a -> b
$ (DeepMap (j1 : j2 : ks) v -> DeepMap (k1 : k2 : ks) v)
-> DeepMap (j0 : j1 : j2 : ks) v -> DeepMap (j0 : k1 : k2 : ks) v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow ((j1 -> k1)
-> (j2 -> k2)
-> DeepMap (j1 : j2 : ks) v
-> DeepMap (k1 : k2 : ks) v
forall k0 k1 (ks :: [*]) v j0 j1.
(Ord k0, Ord k1, Semigroup (DeepMap ks v)) =>
(j0 -> k0)
-> (j1 -> k1)
-> DeepMap (j0 : j1 : ks) v
-> DeepMap (k0 : k1 : ks) v
mapKeys2 j1 -> k1
f1 j2 -> k2
f2) DeepMap (j0 : j1 : j2 : ks) v
m

-- | /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
mapKeys4 :: (j0 -> k0)
-> (j1 -> k1)
-> (j2 -> k2)
-> (j3 -> k3)
-> DeepMap (j0 : j1 : j2 : j3 : ks) v
-> DeepMap (k0 : k1 : k2 : k3 : ks) v
mapKeys4 j0 -> k0
f0 j1 -> k1
f1 j2 -> k2
f2 j3 -> k3
f3 DeepMap (j0 : j1 : j2 : j3 : ks) v
m = (j0 -> k0)
-> DeepMap (j0 : k1 : k2 : k3 : ks) v
-> DeepMap (k0 : k1 : k2 : k3 : ks) v
forall k (ks :: [*]) v j.
(Ord k, Semigroup (DeepMap ks v)) =>
(j -> k) -> DeepMap (j : ks) v -> DeepMap (k : ks) v
mapKeys j0 -> k0
f0 (DeepMap (j0 : k1 : k2 : k3 : ks) v
 -> DeepMap (k0 : k1 : k2 : k3 : ks) v)
-> DeepMap (j0 : k1 : k2 : k3 : ks) v
-> DeepMap (k0 : k1 : k2 : k3 : ks) v
forall a b. (a -> b) -> a -> b
$ (DeepMap (j1 : j2 : j3 : ks) v -> DeepMap (k1 : k2 : k3 : ks) v)
-> DeepMap (j0 : j1 : j2 : j3 : ks) v
-> DeepMap (j0 : k1 : k2 : k3 : ks) v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow ((j1 -> k1)
-> (j2 -> k2)
-> (j3 -> k3)
-> DeepMap (j1 : j2 : j3 : ks) v
-> DeepMap (k1 : k2 : k3 : ks) v
forall k0 k1 k2 (ks :: [*]) v j0 j1 j2.
(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
mapKeys3 j1 -> k1
f1 j2 -> k2
f2 j3 -> k3
f3) DeepMap (j0 : j1 : j2 : j3 : ks) v
m

-- | /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
mapKeys5 :: (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
mapKeys5 j0 -> k0
f0 j1 -> k1
f1 j2 -> k2
f2 j3 -> k3
f3 j4 -> k4
f4 DeepMap (j0 : j1 : j2 : j3 : j4 : ks) v
m = (j0 -> k0)
-> DeepMap (j0 : k1 : k2 : k3 : k4 : ks) v
-> DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
forall k (ks :: [*]) v j.
(Ord k, Semigroup (DeepMap ks v)) =>
(j -> k) -> DeepMap (j : ks) v -> DeepMap (k : ks) v
mapKeys j0 -> k0
f0 (DeepMap (j0 : k1 : k2 : k3 : k4 : ks) v
 -> DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v)
-> DeepMap (j0 : k1 : k2 : k3 : k4 : ks) v
-> DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
forall a b. (a -> b) -> a -> b
$ (DeepMap (j1 : j2 : j3 : j4 : ks) v
 -> DeepMap (k1 : k2 : k3 : k4 : ks) v)
-> DeepMap (j0 : j1 : j2 : j3 : j4 : ks) v
-> DeepMap (j0 : k1 : k2 : k3 : k4 : ks) v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow ((j1 -> k1)
-> (j2 -> k2)
-> (j3 -> k3)
-> (j4 -> k4)
-> DeepMap (j1 : j2 : j3 : j4 : ks) v
-> DeepMap (k1 : k2 : k3 : k4 : ks) v
forall k0 k1 k2 k3 (ks :: [*]) v j0 j1 j2 j3.
(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
mapKeys4 j1 -> k1
f1 j2 -> k2
f2 j3 -> k3
f3 j4 -> k4
f4) DeepMap (j0 : j1 : j2 : j3 : j4 : ks) v
m

-- | /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
mapKeysWith :: (DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> (j -> k) -> DeepMap (j : ks) v -> DeepMap (k : ks) v
mapKeysWith DeepMap ks v -> DeepMap ks v -> DeepMap ks v
(~~) j -> k
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> (j -> k) -> Map j (DeepMap ks v) -> Map k (DeepMap ks v)
forall k2 a k1.
Ord k2 =>
(a -> a -> a) -> (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeysWith DeepMap ks v -> DeepMap ks v -> DeepMap ks v
(~~) j -> k
f Map j (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
mapKeysWith1 :: (v -> v -> v) -> (j -> k) -> DeepMap '[j] v -> DeepMap '[k] v
mapKeysWith1 v -> v -> v
(~~) = (DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v)
-> (j -> k) -> DeepMap '[j] v -> DeepMap '[k] v
forall k (ks :: [*]) v j.
Ord k =>
(DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> (j -> k) -> DeepMap (j : ks) v -> DeepMap (k : ks) v
mapKeysWith ((v -> v -> v) -> DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v
forall v w x.
(v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x
onBare2 v -> v -> 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
mapKeysWith2 :: (v -> v -> v)
-> (j0 -> k0)
-> (j1 -> k1)
-> DeepMap '[j0, j1] v
-> DeepMap '[k0, k1] v
mapKeysWith2 v -> v -> v
(~~) j0 -> k0
f0 j1 -> k1
f1 DeepMap '[j0, j1] v
m = (DeepMap '[k1] v -> DeepMap '[k1] v -> DeepMap '[k1] v)
-> (j0 -> k0) -> DeepMap '[j0, k1] v -> DeepMap '[k0, k1] v
forall k (ks :: [*]) v j.
Ord k =>
(DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> (j -> k) -> DeepMap (j : ks) v -> DeepMap (k : ks) v
mapKeysWith ((v -> v -> v)
-> DeepMap '[k1] v -> DeepMap '[k1] v -> DeepMap '[k1] v
forall k v.
Ord k =>
(v -> v -> v) -> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
unionWith1 v -> v -> v
(~~)) j0 -> k0
f0 (DeepMap '[j0, k1] v -> DeepMap '[k0, k1] v)
-> DeepMap '[j0, k1] v -> DeepMap '[k0, k1] v
forall a b. (a -> b) -> a -> b
$ (DeepMap '[j1] v -> DeepMap '[k1] v)
-> DeepMap '[j0, j1] v -> DeepMap '[j0, k1] v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow ((v -> v -> v) -> (j1 -> k1) -> DeepMap '[j1] v -> DeepMap '[k1] v
forall k v j.
Ord k =>
(v -> v -> v) -> (j -> k) -> DeepMap '[j] v -> DeepMap '[k] v
mapKeysWith1 v -> v -> v
(~~) j1 -> k1
f1) DeepMap '[j0, j1] v
m

-- | /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
mapKeysWith3 :: (v -> v -> v)
-> (j0 -> k0)
-> (j1 -> k1)
-> (j2 -> k2)
-> DeepMap '[j0, j1, j2] v
-> DeepMap '[k0, k1, k2] v
mapKeysWith3 v -> v -> v
(~~) j0 -> k0
f0 j1 -> k1
f1 j2 -> k2
f2 DeepMap '[j0, j1, j2] v
m = (DeepMap '[k1, k2] v -> DeepMap '[k1, k2] v -> DeepMap '[k1, k2] v)
-> (j0 -> k0) -> DeepMap '[j0, k1, k2] v -> DeepMap '[k0, k1, k2] v
forall k (ks :: [*]) v j.
Ord k =>
(DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> (j -> k) -> DeepMap (j : ks) v -> DeepMap (k : ks) v
mapKeysWith ((v -> v -> v)
-> DeepMap '[k1, k2] v
-> DeepMap '[k1, k2] v
-> DeepMap '[k1, k2] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
(v -> v -> v)
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] v
unionWith2 v -> v -> v
(~~)) j0 -> k0
f0 (DeepMap '[j0, k1, k2] v -> DeepMap '[k0, k1, k2] v)
-> DeepMap '[j0, k1, k2] v -> DeepMap '[k0, k1, k2] v
forall a b. (a -> b) -> a -> b
$ (DeepMap '[j1, j2] v -> DeepMap '[k1, k2] v)
-> DeepMap '[j0, j1, j2] v -> DeepMap '[j0, k1, k2] v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow ((v -> v -> v)
-> (j1 -> k1)
-> (j2 -> k2)
-> DeepMap '[j1, j2] v
-> DeepMap '[k1, k2] v
forall k0 k1 v j0 j1.
(Ord k0, Ord k1) =>
(v -> v -> v)
-> (j0 -> k0)
-> (j1 -> k1)
-> DeepMap '[j0, j1] v
-> DeepMap '[k0, k1] v
mapKeysWith2 v -> v -> v
(~~) j1 -> k1
f1 j2 -> k2
f2) DeepMap '[j0, j1, j2] v
m

-- | /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
mapKeysWith4 :: (v -> v -> v)
-> (j0 -> k0)
-> (j1 -> k1)
-> (j2 -> k2)
-> (j3 -> k3)
-> DeepMap '[j0, j1, j2, j3] v
-> DeepMap '[k0, k1, k2, k3] v
mapKeysWith4 v -> v -> v
(~~) j0 -> k0
f0 j1 -> k1
f1 j2 -> k2
f2 j3 -> k3
f3 DeepMap '[j0, j1, j2, j3] v
m = (DeepMap '[k1, k2, k3] v
 -> DeepMap '[k1, k2, k3] v -> DeepMap '[k1, k2, k3] v)
-> (j0 -> k0)
-> DeepMap '[j0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] v
forall k (ks :: [*]) v j.
Ord k =>
(DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> (j -> k) -> DeepMap (j : ks) v -> DeepMap (k : ks) v
mapKeysWith ((v -> v -> v)
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
forall k0 k1 k2 v.
(Ord k0, Ord k1, Ord k2) =>
(v -> v -> v)
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
unionWith3 v -> v -> v
(~~)) j0 -> k0
f0 (DeepMap '[j0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v)
-> DeepMap '[j0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
forall a b. (a -> b) -> a -> b
$ (DeepMap '[j1, j2, j3] v -> DeepMap '[k1, k2, k3] v)
-> DeepMap '[j0, j1, j2, j3] v -> DeepMap '[j0, k1, k2, k3] v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow ((v -> v -> v)
-> (j1 -> k1)
-> (j2 -> k2)
-> (j3 -> k3)
-> DeepMap '[j1, j2, j3] v
-> DeepMap '[k1, k2, k3] v
forall k0 k1 k2 v j0 j1 j2.
(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
mapKeysWith3 v -> v -> v
(~~) j1 -> k1
f1 j2 -> k2
f2 j3 -> k3
f3) DeepMap '[j0, j1, j2, j3] v
m

-- | /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
mapKeysWith5 :: (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
mapKeysWith5 v -> v -> v
(~~) j0 -> k0
f0 j1 -> k1
f1 j2 -> k2
f2 j3 -> k3
f3 j4 -> k4
f4 DeepMap '[j0, j1, j2, j3, j4] v
m = (DeepMap '[k1, k2, k3, k4] v
 -> DeepMap '[k1, k2, k3, k4] v -> DeepMap '[k1, k2, k3, k4] v)
-> (j0 -> k0)
-> DeepMap '[j0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k (ks :: [*]) v j.
Ord k =>
(DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> (j -> k) -> DeepMap (j : ks) v -> DeepMap (k : ks) v
mapKeysWith ((v -> v -> v)
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
forall k0 k1 k2 k3 v.
(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
unionWith4 v -> v -> v
(~~)) j0 -> k0
f0 (DeepMap '[j0, k1, k2, k3, k4] v
 -> DeepMap '[k0, k1, k2, k3, k4] v)
-> DeepMap '[j0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall a b. (a -> b) -> a -> b
$ (DeepMap '[j1, j2, j3, j4] v -> DeepMap '[k1, k2, k3, k4] v)
-> DeepMap '[j0, j1, j2, j3, j4] v
-> DeepMap '[j0, k1, k2, k3, k4] v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow ((v -> v -> v)
-> (j1 -> k1)
-> (j2 -> k2)
-> (j3 -> k3)
-> (j4 -> k4)
-> DeepMap '[j1, j2, j3, j4] v
-> DeepMap '[k1, k2, k3, k4] v
forall k0 k1 k2 k3 v j0 j1 j2 j3.
(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
mapKeysWith4 v -> v -> v
(~~) j1 -> k1
f1 j2 -> k2
f2 j3 -> k3
f3 j4 -> k4
f4) DeepMap '[j0, j1, j2, j3, j4] v
m

-- | /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)
traverseKeys :: (j -> f k) -> DeepMap (j : ks) v -> f (DeepMap (k : ks) v)
traverseKeys j -> f k
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> f (Map k (DeepMap ks v)) -> f (DeepMap (k : ks) v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (j -> f k) -> Map j (DeepMap ks v) -> f (Map k (DeepMap ks v))
forall (f :: * -> *) k j a.
(Applicative f, Ord k) =>
(j -> f k) -> Map j a -> f (Map k a)
traverseKeysMap j -> f k
f Map j (DeepMap ks v)
Map k (DeepMap ks v)
m
  where
    traverseKeysMap :: (Applicative f, Ord k) => (j -> f k) -> Map j a -> f (Map k a)
    traverseKeysMap :: (j -> f k) -> Map j a -> f (Map k a)
traverseKeysMap j -> f k
f0 = ([(k, a)] -> Map k a) -> f [(k, a)] -> f (Map k a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [(k, a)] -> Map k a
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList (f [(k, a)] -> f (Map k a))
-> (Map j a -> f [(k, a)]) -> Map j a -> f (Map k a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((j, a) -> f (k, a)) -> [(j, a)] -> f [(k, a)]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (\(j
j, a
a) -> (,a
a) (k -> (k, a)) -> f k -> f (k, a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> j -> f k
f0 j
j) ([(j, a)] -> f [(k, a)])
-> (Map j a -> [(j, a)]) -> Map j a -> f [(k, a)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map j a -> [(j, a)]
forall k a. Map k a -> [(k, a)]
Map.assocs

-- | /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)
traverseKeysWith :: (DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> (j -> f k) -> DeepMap (j : ks) v -> f (DeepMap (k : ks) v)
traverseKeysWith DeepMap ks v -> DeepMap ks v -> DeepMap ks v
(~~) j -> f k
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> f (Map k (DeepMap ks v)) -> f (DeepMap (k : ks) v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> (j -> f k) -> Map j (DeepMap ks v) -> f (Map k (DeepMap ks v))
forall (f :: * -> *) k a j.
(Applicative f, Ord k) =>
(a -> a -> a) -> (j -> f k) -> Map j a -> f (Map k a)
traverseKeysWithMap DeepMap ks v -> DeepMap ks v -> DeepMap ks v
(~~) j -> f k
f Map j (DeepMap ks v)
Map k (DeepMap ks v)
m
  where
    traverseKeysWithMap :: (Applicative f, Ord k) => (a -> a -> a) -> (j -> f k) -> Map j a -> f (Map k a)
    traverseKeysWithMap :: (a -> a -> a) -> (j -> f k) -> Map j a -> f (Map k a)
traverseKeysWithMap a -> a -> a
c j -> f k
f0 = ([(k, a)] -> Map k a) -> f [(k, a)] -> f (Map k a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> a -> a) -> [(k, a)] -> Map k a
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith a -> a -> a
c) (f [(k, a)] -> f (Map k a))
-> (Map j a -> f [(k, a)]) -> Map j a -> f (Map k a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((j, a) -> f (k, a)) -> [(j, a)] -> f [(k, a)]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (\(j
j, a
a) -> (,a
a) (k -> (k, a)) -> f k -> f (k, a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> j -> f k
f0 j
j) ([(j, a)] -> f [(k, a)])
-> (Map j a -> [(j, a)]) -> Map j a -> f [(k, a)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map j a -> [(j, a)]
forall k a. Map k a -> [(k, a)]
Map.assocs

-- | /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)
mapKeysM :: (j -> m k) -> DeepMap (j : ks) v -> m (DeepMap (k : ks) v)
mapKeysM = (j -> m k) -> DeepMap (j : ks) v -> m (DeepMap (k : ks) v)
forall (f :: * -> *) k (ks :: [*]) v j.
(Applicative f, Ord k, Semigroup (DeepMap ks v)) =>
(j -> f k) -> DeepMap (j : ks) v -> f (DeepMap (k : ks) v)
traverseKeys

-- | /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)
mapKeysM1 :: (j -> m k) -> DeepMap (j : ks) v -> m (DeepMap (k : ks) v)
mapKeysM1 = (j -> m k) -> DeepMap (j : ks) v -> m (DeepMap (k : ks) v)
forall (m :: * -> *) k (ks :: [*]) v j.
(Monad m, Ord k, Semigroup (DeepMap ks v)) =>
(j -> m k) -> DeepMap (j : ks) v -> m (DeepMap (k : ks) v)
mapKeysM

-- | /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)
mapKeysM2 :: (j0 -> m k0)
-> (j1 -> m k1)
-> DeepMap (j0 : j1 : ks) v
-> m (DeepMap (k0 : k1 : ks) v)
mapKeysM2 j0 -> m k0
f0 j1 -> m k1
f1 DeepMap (j0 : j1 : ks) v
m = (j0 -> m k0)
-> DeepMap (j0 : k1 : ks) v -> m (DeepMap (k0 : k1 : ks) v)
forall (m :: * -> *) k (ks :: [*]) v j.
(Monad m, Ord k, Semigroup (DeepMap ks v)) =>
(j -> m k) -> DeepMap (j : ks) v -> m (DeepMap (k : ks) v)
mapKeysM j0 -> m k0
f0 (DeepMap (j0 : k1 : ks) v -> m (DeepMap (k0 : k1 : ks) v))
-> m (DeepMap (j0 : k1 : ks) v) -> m (DeepMap (k0 : k1 : ks) v)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (DeepMap (j1 : ks) v -> m (DeepMap (k1 : ks) v))
-> DeepMap (j0 : j1 : ks) v -> m (DeepMap (j0 : k1 : ks) v)
forall (f :: * -> *) (ks :: [*]) v (ls :: [*]) w k.
Applicative f =>
(DeepMap ks v -> f (DeepMap ls w))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseShallow ((j1 -> m k1) -> DeepMap (j1 : ks) v -> m (DeepMap (k1 : ks) v)
forall (m :: * -> *) k (ks :: [*]) v j.
(Monad m, Ord k, Semigroup (DeepMap ks v)) =>
(j -> m k) -> DeepMap (j : ks) v -> m (DeepMap (k : ks) v)
mapKeysM1 j1 -> m k1
f1) DeepMap (j0 : j1 : ks) v
m

-- | /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)
mapKeysM3 :: (j0 -> m k0)
-> (j1 -> m k1)
-> (j2 -> m k2)
-> DeepMap (j0 : j1 : j2 : ks) v
-> m (DeepMap (k0 : k1 : k2 : ks) v)
mapKeysM3 j0 -> m k0
f0 j1 -> m k1
f1 j2 -> m k2
f2 DeepMap (j0 : j1 : j2 : ks) v
m = (j0 -> m k0)
-> DeepMap (j0 : k1 : k2 : ks) v
-> m (DeepMap (k0 : k1 : k2 : ks) v)
forall (m :: * -> *) k (ks :: [*]) v j.
(Monad m, Ord k, Semigroup (DeepMap ks v)) =>
(j -> m k) -> DeepMap (j : ks) v -> m (DeepMap (k : ks) v)
mapKeysM j0 -> m k0
f0 (DeepMap (j0 : k1 : k2 : ks) v
 -> m (DeepMap (k0 : k1 : k2 : ks) v))
-> m (DeepMap (j0 : k1 : k2 : ks) v)
-> m (DeepMap (k0 : k1 : k2 : ks) v)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (DeepMap (j1 : j2 : ks) v -> m (DeepMap (k1 : k2 : ks) v))
-> DeepMap (j0 : j1 : j2 : ks) v
-> m (DeepMap (j0 : k1 : k2 : ks) v)
forall (f :: * -> *) (ks :: [*]) v (ls :: [*]) w k.
Applicative f =>
(DeepMap ks v -> f (DeepMap ls w))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseShallow ((j1 -> m k1)
-> (j2 -> m k2)
-> DeepMap (j1 : j2 : ks) v
-> m (DeepMap (k1 : k2 : ks) v)
forall (m :: * -> *) k0 k1 (ks :: [*]) v j0 j1.
(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)
mapKeysM2 j1 -> m k1
f1 j2 -> m k2
f2) DeepMap (j0 : j1 : j2 : ks) v
m

-- | /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)
mapKeysM4 :: (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)
mapKeysM4 j0 -> m k0
f0 j1 -> m k1
f1 j2 -> m k2
f2 j3 -> m k3
f3 DeepMap (j0 : j1 : j2 : j3 : ks) v
m = (j0 -> m k0)
-> DeepMap (j0 : k1 : k2 : k3 : ks) v
-> m (DeepMap (k0 : k1 : k2 : k3 : ks) v)
forall (m :: * -> *) k (ks :: [*]) v j.
(Monad m, Ord k, Semigroup (DeepMap ks v)) =>
(j -> m k) -> DeepMap (j : ks) v -> m (DeepMap (k : ks) v)
mapKeysM j0 -> m k0
f0 (DeepMap (j0 : k1 : k2 : k3 : ks) v
 -> m (DeepMap (k0 : k1 : k2 : k3 : ks) v))
-> m (DeepMap (j0 : k1 : k2 : k3 : ks) v)
-> m (DeepMap (k0 : k1 : k2 : k3 : ks) v)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (DeepMap (j1 : j2 : j3 : ks) v
 -> m (DeepMap (k1 : k2 : k3 : ks) v))
-> DeepMap (j0 : j1 : j2 : j3 : ks) v
-> m (DeepMap (j0 : k1 : k2 : k3 : ks) v)
forall (f :: * -> *) (ks :: [*]) v (ls :: [*]) w k.
Applicative f =>
(DeepMap ks v -> f (DeepMap ls w))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseShallow ((j1 -> m k1)
-> (j2 -> m k2)
-> (j3 -> m k3)
-> DeepMap (j1 : j2 : j3 : ks) v
-> m (DeepMap (k1 : k2 : k3 : ks) v)
forall (m :: * -> *) k0 k1 k2 (ks :: [*]) v j0 j1 j2.
(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)
mapKeysM3 j1 -> m k1
f1 j2 -> m k2
f2 j3 -> m k3
f3) DeepMap (j0 : j1 : j2 : j3 : ks) v
m

-- | /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)
mapKeysM5 :: (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)
mapKeysM5 j0 -> m k0
f0 j1 -> m k1
f1 j2 -> m k2
f2 j3 -> m k3
f3 j4 -> m k4
f4 DeepMap (j0 : j1 : j2 : j3 : j4 : ks) v
m = (j0 -> m k0)
-> DeepMap (j0 : k1 : k2 : k3 : k4 : ks) v
-> m (DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v)
forall (m :: * -> *) k (ks :: [*]) v j.
(Monad m, Ord k, Semigroup (DeepMap ks v)) =>
(j -> m k) -> DeepMap (j : ks) v -> m (DeepMap (k : ks) v)
mapKeysM j0 -> m k0
f0 (DeepMap (j0 : k1 : k2 : k3 : k4 : ks) v
 -> m (DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v))
-> m (DeepMap (j0 : k1 : k2 : k3 : k4 : ks) v)
-> m (DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (DeepMap (j1 : j2 : j3 : j4 : ks) v
 -> m (DeepMap (k1 : k2 : k3 : k4 : ks) v))
-> DeepMap (j0 : j1 : j2 : j3 : j4 : ks) v
-> m (DeepMap (j0 : k1 : k2 : k3 : k4 : ks) v)
forall (f :: * -> *) (ks :: [*]) v (ls :: [*]) w k.
Applicative f =>
(DeepMap ks v -> f (DeepMap ls w))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseShallow ((j1 -> m k1)
-> (j2 -> m k2)
-> (j3 -> m k3)
-> (j4 -> m k4)
-> DeepMap (j1 : j2 : j3 : j4 : ks) v
-> m (DeepMap (k1 : k2 : k3 : k4 : ks) v)
forall (m :: * -> *) k0 k1 k2 k3 (ks :: [*]) v j0 j1 j2 j3.
(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)
mapKeysM4 j1 -> m k1
f1 j2 -> m k2
f2 j3 -> m k3
f3 j4 -> m k4
f4) DeepMap (j0 : j1 : j2 : j3 : j4 : ks) v
m

-- | /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)
mapKeysMWith :: (DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> (j -> m k) -> DeepMap (j : ks) v -> m (DeepMap (k : ks) v)
mapKeysMWith = (DeepMap ks v -> DeepMap ks v -> DeepMap ks v)
-> (j -> m k) -> DeepMap (j : ks) v -> m (DeepMap (k : ks) v)
forall (f :: * -> *) k (ks :: [*]) v j.
(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)
traverseKeysWith

-- | /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)
mapKeysMWith1 :: (v -> v -> v) -> (j -> m k) -> DeepMap '[j] v -> m (DeepMap '[k] v)
mapKeysMWith1 v -> v -> v
(~~) = (DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v)
-> (j -> m k) -> DeepMap '[j] v -> m (DeepMap '[k] v)
forall (m :: * -> *) k (ks :: [*]) v j.
(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)
mapKeysMWith ((v -> v -> v) -> DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v
forall v w x.
(v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x
onBare2 v -> v -> 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)
mapKeysMWith2 :: (v -> v -> v)
-> (j0 -> m k0)
-> (j1 -> m k1)
-> DeepMap '[j0, j1] v
-> m (DeepMap '[k0, k1] v)
mapKeysMWith2 v -> v -> v
(~~) j0 -> m k0
f0 j1 -> m k1
f1 DeepMap '[j0, j1] v
m = (DeepMap '[k1] v -> DeepMap '[k1] v -> DeepMap '[k1] v)
-> (j0 -> m k0) -> DeepMap '[j0, k1] v -> m (DeepMap '[k0, k1] v)
forall (m :: * -> *) k (ks :: [*]) v j.
(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)
mapKeysMWith ((v -> v -> v)
-> DeepMap '[k1] v -> DeepMap '[k1] v -> DeepMap '[k1] v
forall k v.
Ord k =>
(v -> v -> v) -> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
unionWith1 v -> v -> v
(~~)) j0 -> m k0
f0 (DeepMap '[j0, k1] v -> m (DeepMap '[k0, k1] v))
-> m (DeepMap '[j0, k1] v) -> m (DeepMap '[k0, k1] v)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (DeepMap '[j1] v -> m (DeepMap '[k1] v))
-> DeepMap '[j0, j1] v -> m (DeepMap '[j0, k1] v)
forall (f :: * -> *) (ks :: [*]) v (ls :: [*]) w k.
Applicative f =>
(DeepMap ks v -> f (DeepMap ls w))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseShallow ((v -> v -> v)
-> (j1 -> m k1) -> DeepMap '[j1] v -> m (DeepMap '[k1] v)
forall (m :: * -> *) k v j.
(Monad m, Ord k) =>
(v -> v -> v) -> (j -> m k) -> DeepMap '[j] v -> m (DeepMap '[k] v)
mapKeysMWith1 v -> v -> v
(~~) j1 -> m k1
f1) DeepMap '[j0, j1] v
m

-- | /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)
mapKeysMWith3 :: (v -> v -> v)
-> (j0 -> m k0)
-> (j1 -> m k1)
-> (j2 -> m k2)
-> DeepMap '[j0, j1, j2] v
-> m (DeepMap '[k0, k1, k2] v)
mapKeysMWith3 v -> v -> v
(~~) j0 -> m k0
f0 j1 -> m k1
f1 j2 -> m k2
f2 DeepMap '[j0, j1, j2] v
m = (DeepMap '[k1, k2] v -> DeepMap '[k1, k2] v -> DeepMap '[k1, k2] v)
-> (j0 -> m k0)
-> DeepMap '[j0, k1, k2] v
-> m (DeepMap '[k0, k1, k2] v)
forall (m :: * -> *) k (ks :: [*]) v j.
(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)
mapKeysMWith ((v -> v -> v)
-> DeepMap '[k1, k2] v
-> DeepMap '[k1, k2] v
-> DeepMap '[k1, k2] v
forall k0 k1 v.
(Ord k0, Ord k1) =>
(v -> v -> v)
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] v
-> DeepMap '[k0, k1] v
unionWith2 v -> v -> v
(~~)) j0 -> m k0
f0 (DeepMap '[j0, k1, k2] v -> m (DeepMap '[k0, k1, k2] v))
-> m (DeepMap '[j0, k1, k2] v) -> m (DeepMap '[k0, k1, k2] v)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (DeepMap '[j1, j2] v -> m (DeepMap '[k1, k2] v))
-> DeepMap '[j0, j1, j2] v -> m (DeepMap '[j0, k1, k2] v)
forall (f :: * -> *) (ks :: [*]) v (ls :: [*]) w k.
Applicative f =>
(DeepMap ks v -> f (DeepMap ls w))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseShallow ((v -> v -> v)
-> (j1 -> m k1)
-> (j2 -> m k2)
-> DeepMap '[j1, j2] v
-> m (DeepMap '[k1, k2] v)
forall (m :: * -> *) k0 k1 v j0 j1.
(Monad m, Ord k0, Ord k1) =>
(v -> v -> v)
-> (j0 -> m k0)
-> (j1 -> m k1)
-> DeepMap '[j0, j1] v
-> m (DeepMap '[k0, k1] v)
mapKeysMWith2 v -> v -> v
(~~) j1 -> m k1
f1 j2 -> m k2
f2) DeepMap '[j0, j1, j2] v
m

-- | /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)
mapKeysMWith4 :: (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)
mapKeysMWith4 v -> v -> v
(~~) j0 -> m k0
f0 j1 -> m k1
f1 j2 -> m k2
f2 j3 -> m k3
f3 DeepMap '[j0, j1, j2, j3] v
m = (DeepMap '[k1, k2, k3] v
 -> DeepMap '[k1, k2, k3] v -> DeepMap '[k1, k2, k3] v)
-> (j0 -> m k0)
-> DeepMap '[j0, k1, k2, k3] v
-> m (DeepMap '[k0, k1, k2, k3] v)
forall (m :: * -> *) k (ks :: [*]) v j.
(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)
mapKeysMWith ((v -> v -> v)
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] v
forall k0 k1 k2 v.
(Ord k0, Ord k1, Ord k2) =>
(v -> v -> v)
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
-> DeepMap '[k0, k1, k2] v
unionWith3 v -> v -> v
(~~)) j0 -> m k0
f0 (DeepMap '[j0, k1, k2, k3] v -> m (DeepMap '[k0, k1, k2, k3] v))
-> m (DeepMap '[j0, k1, k2, k3] v)
-> m (DeepMap '[k0, k1, k2, k3] v)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (DeepMap '[j1, j2, j3] v -> m (DeepMap '[k1, k2, k3] v))
-> DeepMap '[j0, j1, j2, j3] v -> m (DeepMap '[j0, k1, k2, k3] v)
forall (f :: * -> *) (ks :: [*]) v (ls :: [*]) w k.
Applicative f =>
(DeepMap ks v -> f (DeepMap ls w))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseShallow ((v -> v -> v)
-> (j1 -> m k1)
-> (j2 -> m k2)
-> (j3 -> m k3)
-> DeepMap '[j1, j2, j3] v
-> m (DeepMap '[k1, k2, k3] v)
forall (m :: * -> *) k0 k1 k2 v j0 j1 j2.
(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)
mapKeysMWith3 v -> v -> v
(~~) j1 -> m k1
f1 j2 -> m k2
f2 j3 -> m k3
f3) DeepMap '[j0, j1, j2, j3] v
m

-- | /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)
mapKeysMWith5 :: (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)
mapKeysMWith5 v -> v -> v
(~~) j0 -> m k0
f0 j1 -> m k1
f1 j2 -> m k2
f2 j3 -> m k3
f3 j4 -> m k4
f4 DeepMap '[j0, j1, j2, j3, j4] v
m = (DeepMap '[k1, k2, k3, k4] v
 -> DeepMap '[k1, k2, k3, k4] v -> DeepMap '[k1, k2, k3, k4] v)
-> (j0 -> m k0)
-> DeepMap '[j0, k1, k2, k3, k4] v
-> m (DeepMap '[k0, k1, k2, k3, k4] v)
forall (m :: * -> *) k (ks :: [*]) v j.
(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)
mapKeysMWith ((v -> v -> v)
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] v
forall k0 k1 k2 k3 v.
(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
unionWith4 v -> v -> v
(~~)) j0 -> m k0
f0 (DeepMap '[j0, k1, k2, k3, k4] v
 -> m (DeepMap '[k0, k1, k2, k3, k4] v))
-> m (DeepMap '[j0, k1, k2, k3, k4] v)
-> m (DeepMap '[k0, k1, k2, k3, k4] v)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (DeepMap '[j1, j2, j3, j4] v -> m (DeepMap '[k1, k2, k3, k4] v))
-> DeepMap '[j0, j1, j2, j3, j4] v
-> m (DeepMap '[j0, k1, k2, k3, k4] v)
forall (f :: * -> *) (ks :: [*]) v (ls :: [*]) w k.
Applicative f =>
(DeepMap ks v -> f (DeepMap ls w))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseShallow ((v -> v -> v)
-> (j1 -> m k1)
-> (j2 -> m k2)
-> (j3 -> m k3)
-> (j4 -> m k4)
-> DeepMap '[j1, j2, j3, j4] v
-> m (DeepMap '[k1, k2, k3, k4] v)
forall (m :: * -> *) k0 k1 k2 k3 v j0 j1 j2 j3.
(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)
mapKeysMWith4 v -> v -> v
(~~) j1 -> m k1
f1 j2 -> m k2
f2 j3 -> m k3
f3 j4 -> m k4
f4) DeepMap '[j0, j1, j2, j3, j4] v
m

foldShallow :: (Monoid (DeepMap ks v)) => DeepMap (k ': ks) v -> DeepMap ks v
foldShallow :: DeepMap (k : ks) v -> DeepMap ks v
foldShallow (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap ks v
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold Map k (DeepMap ks v)
m

-- | /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
foldrWithKey :: (k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k : ks) v -> b
foldrWithKey k -> DeepMap ks v -> b -> b
f b
z (Nest Map k (DeepMap ks v)
m) = (k -> DeepMap ks v -> b -> b) -> b -> Map k (DeepMap ks v) -> b
forall k a b. (k -> a -> b -> b) -> b -> Map k a -> b
Map.foldrWithKey k -> DeepMap ks v -> b -> b
f b
z Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /O(n)/. Fold the keys and values using the given right-associative binary operator.
foldrWithKey1 :: (k -> v -> b -> b) -> b -> DeepMap '[k] v -> b
foldrWithKey1 :: (k -> v -> b -> b) -> b -> DeepMap '[k] v -> b
foldrWithKey1 k -> v -> b -> b
f = (k -> DeepMap '[] v -> b -> b) -> b -> DeepMap '[k] v -> b
forall k (ks :: [*]) v b.
(k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k : ks) v -> b
foldrWithKey (\k
k (Bare v
v) -> k -> v -> b -> b
f k
k v
v)

-- | /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
foldrWithKey2 :: (k0 -> k1 -> v -> b -> b) -> b -> DeepMap '[k0, k1] v -> b
foldrWithKey2 k0 -> k1 -> v -> b -> b
f = (k0 -> DeepMap '[k1] v -> b -> b) -> b -> DeepMap '[k0, k1] v -> b
forall k (ks :: [*]) v b.
(k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k : ks) v -> b
foldrWithKey (\k0
k0 DeepMap '[k1] v
dm b
b -> (k1 -> v -> b -> b) -> b -> DeepMap '[k1] v -> b
forall k v b. (k -> v -> b -> b) -> b -> DeepMap '[k] v -> b
foldrWithKey1 (k0 -> k1 -> v -> b -> b
f k0
k0) b
b DeepMap '[k1] v
dm)

-- | /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
foldrWithKey3 :: (k0 -> k1 -> k2 -> v -> b -> b)
-> b -> DeepMap '[k0, k1, k2] v -> b
foldrWithKey3 k0 -> k1 -> k2 -> v -> b -> b
f = (k0 -> DeepMap '[k1, k2] v -> b -> b)
-> b -> DeepMap '[k0, k1, k2] v -> b
forall k (ks :: [*]) v b.
(k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k : ks) v -> b
foldrWithKey (\k0
k0 DeepMap '[k1, k2] v
dm b
b -> (k1 -> k2 -> v -> b -> b) -> b -> DeepMap '[k1, k2] v -> b
forall k0 k1 v b.
(k0 -> k1 -> v -> b -> b) -> b -> DeepMap '[k0, k1] v -> b
foldrWithKey2 (k0 -> k1 -> k2 -> v -> b -> b
f k0
k0) b
b DeepMap '[k1, k2] v
dm)

-- | /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
foldrWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> b -> b)
-> b -> DeepMap '[k0, k1, k2, k3] v -> b
foldrWithKey4 k0 -> k1 -> k2 -> k3 -> v -> b -> b
f = (k0 -> DeepMap '[k1, k2, k3] v -> b -> b)
-> b -> DeepMap '[k0, k1, k2, k3] v -> b
forall k (ks :: [*]) v b.
(k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k : ks) v -> b
foldrWithKey (\k0
k0 DeepMap '[k1, k2, k3] v
dm b
b -> (k1 -> k2 -> k3 -> v -> b -> b)
-> b -> DeepMap '[k1, k2, k3] v -> b
forall k0 k1 k2 v b.
(k0 -> k1 -> k2 -> v -> b -> b)
-> b -> DeepMap '[k0, k1, k2] v -> b
foldrWithKey3 (k0 -> k1 -> k2 -> k3 -> v -> b -> b
f k0
k0) b
b DeepMap '[k1, k2, k3] v
dm)

-- | /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
foldrWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k3 -> v -> b -> b)
-> b -> DeepMap '[k0, k1, k2, k3, k3] v -> b
foldrWithKey5 k0 -> k1 -> k2 -> k3 -> k3 -> v -> b -> b
f = (k0 -> DeepMap '[k1, k2, k3, k3] v -> b -> b)
-> b -> DeepMap '[k0, k1, k2, k3, k3] v -> b
forall k (ks :: [*]) v b.
(k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k : ks) v -> b
foldrWithKey (\k0
k0 DeepMap '[k1, k2, k3, k3] v
dm b
b -> (k1 -> k2 -> k3 -> k3 -> v -> b -> b)
-> b -> DeepMap '[k1, k2, k3, k3] v -> b
forall k0 k1 k2 k3 v b.
(k0 -> k1 -> k2 -> k3 -> v -> b -> b)
-> b -> DeepMap '[k0, k1, k2, k3] v -> b
foldrWithKey4 (k0 -> k1 -> k2 -> k3 -> k3 -> v -> b -> b
f k0
k0) b
b DeepMap '[k1, k2, k3, k3] v
dm)

-- | /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
foldlWithKey :: (b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k : ks) v -> b
foldlWithKey b -> k -> DeepMap ks v -> b
f b
z (Nest Map k (DeepMap ks v)
m) = (b -> k -> DeepMap ks v -> b) -> b -> Map k (DeepMap ks v) -> b
forall a k b. (a -> k -> b -> a) -> a -> Map k b -> a
Map.foldlWithKey b -> k -> DeepMap ks v -> b
f b
z Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
foldlWithKey1 :: (b -> k -> v -> b) -> b -> DeepMap '[k] v -> b
foldlWithKey1 b -> k -> v -> b
f = (b -> k -> DeepMap '[] v -> b) -> b -> DeepMap '[k] v -> b
forall b k (ks :: [*]) v.
(b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k : ks) v -> b
foldlWithKey (\b
b k
k (Bare v
v) -> b -> k -> v -> b
f b
b k
k v
v)

-- | /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
foldlWithKey2 :: (b -> k0 -> k1 -> v -> b) -> b -> DeepMap '[k0, k1] v -> b
foldlWithKey2 b -> k0 -> k1 -> v -> b
f = (b -> k0 -> DeepMap '[k1] v -> b) -> b -> DeepMap '[k0, k1] v -> b
forall b k (ks :: [*]) v.
(b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k : ks) v -> b
foldlWithKey (\b
b k0
k0 -> (b -> k1 -> v -> b) -> b -> DeepMap '[k1] v -> b
forall b k v. (b -> k -> v -> b) -> b -> DeepMap '[k] v -> b
foldlWithKey1 (b -> k0 -> k1 -> v -> b
`f` k0
k0) b
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
foldlWithKey3 :: (b -> k0 -> k1 -> k2 -> v -> b)
-> b -> DeepMap '[k0, k1, k2] v -> b
foldlWithKey3 b -> k0 -> k1 -> k2 -> v -> b
f = (b -> k0 -> DeepMap '[k1, k2] v -> b)
-> b -> DeepMap '[k0, k1, k2] v -> b
forall b k (ks :: [*]) v.
(b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k : ks) v -> b
foldlWithKey (\b
b k0
k0 -> (b -> k1 -> k2 -> v -> b) -> b -> DeepMap '[k1, k2] v -> b
forall b k0 k1 v.
(b -> k0 -> k1 -> v -> b) -> b -> DeepMap '[k0, k1] v -> b
foldlWithKey2 (b -> k0 -> k1 -> k2 -> v -> b
`f` k0
k0) b
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
foldlWithKey4 :: (b -> k0 -> k1 -> k2 -> k3 -> v -> b)
-> b -> DeepMap '[k0, k1, k2, k3] v -> b
foldlWithKey4 b -> k0 -> k1 -> k2 -> k3 -> v -> b
f = (b -> k0 -> DeepMap '[k1, k2, k3] v -> b)
-> b -> DeepMap '[k0, k1, k2, k3] v -> b
forall b k (ks :: [*]) v.
(b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k : ks) v -> b
foldlWithKey (\b
b k0
k0 -> (b -> k1 -> k2 -> k3 -> v -> b)
-> b -> DeepMap '[k1, k2, k3] v -> b
forall b k0 k1 k2 v.
(b -> k0 -> k1 -> k2 -> v -> b)
-> b -> DeepMap '[k0, k1, k2] v -> b
foldlWithKey3 (b -> k0 -> k1 -> k2 -> k3 -> v -> b
`f` k0
k0) b
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
foldlWithKey5 :: (b -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> b)
-> b -> DeepMap '[k0, k1, k2, k3, k4] v -> b
foldlWithKey5 b -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> b
f = (b -> k0 -> DeepMap '[k1, k2, k3, k4] v -> b)
-> b -> DeepMap '[k0, k1, k2, k3, k4] v -> b
forall b k (ks :: [*]) v.
(b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k : ks) v -> b
foldlWithKey (\b
b k0
k0 -> (b -> k1 -> k2 -> k3 -> k4 -> v -> b)
-> b -> DeepMap '[k1, k2, k3, k4] v -> b
forall b k0 k1 k2 k3 v.
(b -> k0 -> k1 -> k2 -> k3 -> v -> b)
-> b -> DeepMap '[k0, k1, k2, k3] v -> b
foldlWithKey4 (b -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> b
`f` k0
k0) b
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
foldrWithKey' :: (k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k : ks) v -> b
foldrWithKey' k -> DeepMap ks v -> b -> b
f b
z (Nest Map k (DeepMap ks v)
m) = (k -> DeepMap ks v -> b -> b) -> b -> Map k (DeepMap ks v) -> b
forall k a b. (k -> a -> b -> b) -> b -> Map k a -> b
Map.foldrWithKey' k -> DeepMap ks v -> b -> b
f b
z Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
foldrWithKey1' :: (k -> v -> b -> b) -> b -> DeepMap '[k] v -> b
foldrWithKey1' k -> v -> b -> b
f = (k -> DeepMap '[] v -> b -> b) -> b -> DeepMap '[k] v -> b
forall k (ks :: [*]) v b.
(k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k : ks) v -> b
foldrWithKey' (\k
k (Bare v
v) -> k -> v -> b -> b
f k
k v
v)

-- | /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
foldrWithKey2' :: (k0 -> k1 -> v -> b -> b) -> b -> DeepMap '[k0, k1] v -> b
foldrWithKey2' k0 -> k1 -> v -> b -> b
f = (k0 -> DeepMap '[k1] v -> b -> b) -> b -> DeepMap '[k0, k1] v -> b
forall k (ks :: [*]) v b.
(k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k : ks) v -> b
foldrWithKey' (\k0
k0 DeepMap '[k1] v
dm b
b -> (k1 -> v -> b -> b) -> b -> DeepMap '[k1] v -> b
forall k v b. (k -> v -> b -> b) -> b -> DeepMap '[k] v -> b
foldrWithKey1' (k0 -> k1 -> v -> b -> b
f k0
k0) b
b DeepMap '[k1] v
dm)

-- | /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
foldrWithKey3' :: (k0 -> k1 -> k2 -> v -> b -> b)
-> b -> DeepMap '[k0, k1, k2] v -> b
foldrWithKey3' k0 -> k1 -> k2 -> v -> b -> b
f = (k0 -> DeepMap '[k1, k2] v -> b -> b)
-> b -> DeepMap '[k0, k1, k2] v -> b
forall k (ks :: [*]) v b.
(k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k : ks) v -> b
foldrWithKey' (\k0
k0 DeepMap '[k1, k2] v
dm b
b -> (k1 -> k2 -> v -> b -> b) -> b -> DeepMap '[k1, k2] v -> b
forall k0 k1 v b.
(k0 -> k1 -> v -> b -> b) -> b -> DeepMap '[k0, k1] v -> b
foldrWithKey2' (k0 -> k1 -> k2 -> v -> b -> b
f k0
k0) b
b DeepMap '[k1, k2] v
dm)

-- | /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
foldrWithKey4' :: (k0 -> k1 -> k2 -> k3 -> v -> b -> b)
-> b -> DeepMap '[k0, k1, k2, k3] v -> b
foldrWithKey4' k0 -> k1 -> k2 -> k3 -> v -> b -> b
f = (k0 -> DeepMap '[k1, k2, k3] v -> b -> b)
-> b -> DeepMap '[k0, k1, k2, k3] v -> b
forall k (ks :: [*]) v b.
(k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k : ks) v -> b
foldrWithKey' (\k0
k0 DeepMap '[k1, k2, k3] v
dm b
b -> (k1 -> k2 -> k3 -> v -> b -> b)
-> b -> DeepMap '[k1, k2, k3] v -> b
forall k0 k1 k2 v b.
(k0 -> k1 -> k2 -> v -> b -> b)
-> b -> DeepMap '[k0, k1, k2] v -> b
foldrWithKey3' (k0 -> k1 -> k2 -> k3 -> v -> b -> b
f k0
k0) b
b DeepMap '[k1, k2, k3] v
dm)

-- | /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
foldrWithKey5' :: (k0 -> k1 -> k2 -> k3 -> k3 -> v -> b -> b)
-> b -> DeepMap '[k0, k1, k2, k3, k3] v -> b
foldrWithKey5' k0 -> k1 -> k2 -> k3 -> k3 -> v -> b -> b
f = (k0 -> DeepMap '[k1, k2, k3, k3] v -> b -> b)
-> b -> DeepMap '[k0, k1, k2, k3, k3] v -> b
forall k (ks :: [*]) v b.
(k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k : ks) v -> b
foldrWithKey' (\k0
k0 DeepMap '[k1, k2, k3, k3] v
dm b
b -> (k1 -> k2 -> k3 -> k3 -> v -> b -> b)
-> b -> DeepMap '[k1, k2, k3, k3] v -> b
forall k0 k1 k2 k3 v b.
(k0 -> k1 -> k2 -> k3 -> v -> b -> b)
-> b -> DeepMap '[k0, k1, k2, k3] v -> b
foldrWithKey4' (k0 -> k1 -> k2 -> k3 -> k3 -> v -> b -> b
f k0
k0) b
b DeepMap '[k1, k2, k3, k3] v
dm)

-- | /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
foldlWithKey' :: (b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k : ks) v -> b
foldlWithKey' b -> k -> DeepMap ks v -> b
f b
z (Nest Map k (DeepMap ks v)
m) = (b -> k -> DeepMap ks v -> b) -> b -> Map k (DeepMap ks v) -> b
forall a k b. (a -> k -> b -> a) -> a -> Map k b -> a
Map.foldlWithKey' b -> k -> DeepMap ks v -> b
f b
z Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
foldlWithKey1' :: (b -> k -> v -> b) -> b -> DeepMap '[k] v -> b
foldlWithKey1' b -> k -> v -> b
f = (b -> k -> DeepMap '[] v -> b) -> b -> DeepMap '[k] v -> b
forall b k (ks :: [*]) v.
(b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k : ks) v -> b
foldlWithKey' (\b
b k
k (Bare v
v) -> b -> k -> v -> b
f b
b k
k v
v)

-- | /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
foldlWithKey2' :: (b -> k0 -> k1 -> v -> b) -> b -> DeepMap '[k0, k1] v -> b
foldlWithKey2' b -> k0 -> k1 -> v -> b
f = (b -> k0 -> DeepMap '[k1] v -> b) -> b -> DeepMap '[k0, k1] v -> b
forall b k (ks :: [*]) v.
(b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k : ks) v -> b
foldlWithKey' (\b
b k0
k0 -> (b -> k1 -> v -> b) -> b -> DeepMap '[k1] v -> b
forall b k v. (b -> k -> v -> b) -> b -> DeepMap '[k] v -> b
foldlWithKey1' (b -> k0 -> k1 -> v -> b
`f` k0
k0) b
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
foldlWithKey3' :: (b -> k0 -> k1 -> k2 -> v -> b)
-> b -> DeepMap '[k0, k1, k2] v -> b
foldlWithKey3' b -> k0 -> k1 -> k2 -> v -> b
f = (b -> k0 -> DeepMap '[k1, k2] v -> b)
-> b -> DeepMap '[k0, k1, k2] v -> b
forall b k (ks :: [*]) v.
(b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k : ks) v -> b
foldlWithKey (\b
b k0
k0 -> (b -> k1 -> k2 -> v -> b) -> b -> DeepMap '[k1, k2] v -> b
forall b k0 k1 v.
(b -> k0 -> k1 -> v -> b) -> b -> DeepMap '[k0, k1] v -> b
foldlWithKey2' (b -> k0 -> k1 -> k2 -> v -> b
`f` k0
k0) b
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
foldlWithKey4' :: (b -> k0 -> k1 -> k2 -> k3 -> v -> b)
-> b -> DeepMap '[k0, k1, k2, k3] v -> b
foldlWithKey4' b -> k0 -> k1 -> k2 -> k3 -> v -> b
f = (b -> k0 -> DeepMap '[k1, k2, k3] v -> b)
-> b -> DeepMap '[k0, k1, k2, k3] v -> b
forall b k (ks :: [*]) v.
(b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k : ks) v -> b
foldlWithKey' (\b
b k0
k0 -> (b -> k1 -> k2 -> k3 -> v -> b)
-> b -> DeepMap '[k1, k2, k3] v -> b
forall b k0 k1 k2 v.
(b -> k0 -> k1 -> k2 -> v -> b)
-> b -> DeepMap '[k0, k1, k2] v -> b
foldlWithKey3' (b -> k0 -> k1 -> k2 -> k3 -> v -> b
`f` k0
k0) b
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
foldlWithKey5' :: (b -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> b)
-> b -> DeepMap '[k0, k1, k2, k3, k4] v -> b
foldlWithKey5' b -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> b
f = (b -> k0 -> DeepMap '[k1, k2, k3, k4] v -> b)
-> b -> DeepMap '[k0, k1, k2, k3, k4] v -> b
forall b k (ks :: [*]) v.
(b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k : ks) v -> b
foldlWithKey' (\b
b k0
k0 -> (b -> k1 -> k2 -> k3 -> k4 -> v -> b)
-> b -> DeepMap '[k1, k2, k3, k4] v -> b
forall b k0 k1 k2 k3 v.
(b -> k0 -> k1 -> k2 -> k3 -> v -> b)
-> b -> DeepMap '[k0, k1, k2, k3] v -> b
foldlWithKey4' (b -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> b
`f` k0
k0) b
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
foldMapWithKey :: (k -> DeepMap ks v -> m) -> DeepMap (k : ks) v -> m
foldMapWithKey k -> DeepMap ks v -> m
f (Nest Map k (DeepMap ks v)
m) = (k -> DeepMap ks v -> m) -> Map k (DeepMap ks v) -> m
forall m k a. Monoid m => (k -> a -> m) -> Map k a -> m
Map.foldMapWithKey k -> DeepMap ks v -> m
f Map k (DeepMap ks v)
Map k (DeepMap 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
foldMapWithKey1 :: (k -> v -> m) -> DeepMap '[k] v -> m
foldMapWithKey1 k -> v -> m
f = (k -> DeepMap '[] v -> m) -> DeepMap '[k] v -> m
forall m k (ks :: [*]) v.
Monoid m =>
(k -> DeepMap ks v -> m) -> DeepMap (k : ks) v -> m
foldMapWithKey (\k
k (Bare v
v) -> k -> v -> m
f k
k v
v)

-- | /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
foldMapWithKey2 :: (k0 -> k1 -> v -> m) -> DeepMap '[k0, k1] v -> m
foldMapWithKey2 k0 -> k1 -> v -> m
f = (k0 -> DeepMap '[k1] v -> m) -> DeepMap '[k0, k1] v -> m
forall m k (ks :: [*]) v.
Monoid m =>
(k -> DeepMap ks v -> m) -> DeepMap (k : ks) v -> m
foldMapWithKey ((k1 -> v -> m) -> DeepMap '[k1] v -> m
forall m k v. Monoid m => (k -> v -> m) -> DeepMap '[k] v -> m
foldMapWithKey1 ((k1 -> v -> m) -> DeepMap '[k1] v -> m)
-> (k0 -> k1 -> v -> m) -> k0 -> DeepMap '[k1] v -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> v -> m
f)

-- | /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
foldMapWithKey3 :: (k0 -> k1 -> k2 -> v -> m) -> DeepMap '[k0, k1, k2] v -> m
foldMapWithKey3 k0 -> k1 -> k2 -> v -> m
f = (k0 -> DeepMap '[k1, k2] v -> m) -> DeepMap '[k0, k1, k2] v -> m
forall m k (ks :: [*]) v.
Monoid m =>
(k -> DeepMap ks v -> m) -> DeepMap (k : ks) v -> m
foldMapWithKey ((k1 -> k2 -> v -> m) -> DeepMap '[k1, k2] v -> m
forall m k0 k1 v.
Monoid m =>
(k0 -> k1 -> v -> m) -> DeepMap '[k0, k1] v -> m
foldMapWithKey2 ((k1 -> k2 -> v -> m) -> DeepMap '[k1, k2] v -> m)
-> (k0 -> k1 -> k2 -> v -> m) -> k0 -> DeepMap '[k1, k2] v -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> v -> m
f)

-- | /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
foldMapWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> m)
-> DeepMap '[k0, k1, k2, k3] v -> m
foldMapWithKey4 k0 -> k1 -> k2 -> k3 -> v -> m
f = (k0 -> DeepMap '[k1, k2, k3] v -> m)
-> DeepMap '[k0, k1, k2, k3] v -> m
forall m k (ks :: [*]) v.
Monoid m =>
(k -> DeepMap ks v -> m) -> DeepMap (k : ks) v -> m
foldMapWithKey ((k1 -> k2 -> k3 -> v -> m) -> DeepMap '[k1, k2, k3] v -> m
forall m k0 k1 k2 v.
Monoid m =>
(k0 -> k1 -> k2 -> v -> m) -> DeepMap '[k0, k1, k2] v -> m
foldMapWithKey3 ((k1 -> k2 -> k3 -> v -> m) -> DeepMap '[k1, k2, k3] v -> m)
-> (k0 -> k1 -> k2 -> k3 -> v -> m)
-> k0
-> DeepMap '[k1, k2, k3] v
-> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> v -> m
f)

-- | /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
foldMapWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> m)
-> DeepMap '[k0, k1, k2, k3, k4] v -> m
foldMapWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> m
f = (k0 -> DeepMap '[k1, k2, k3, k4] v -> m)
-> DeepMap '[k0, k1, k2, k3, k4] v -> m
forall m k (ks :: [*]) v.
Monoid m =>
(k -> DeepMap ks v -> m) -> DeepMap (k : ks) v -> m
foldMapWithKey ((k1 -> k2 -> k3 -> k4 -> v -> m)
-> DeepMap '[k1, k2, k3, k4] v -> m
forall m k0 k1 k2 k3 v.
Monoid m =>
(k0 -> k1 -> k2 -> k3 -> v -> m)
-> DeepMap '[k0, k1, k2, k3] v -> m
foldMapWithKey4 ((k1 -> k2 -> k3 -> k4 -> v -> m)
 -> DeepMap '[k1, k2, k3, k4] v -> m)
-> (k0 -> k1 -> k2 -> k3 -> k4 -> v -> m)
-> k0
-> DeepMap '[k1, k2, k3, k4] v
-> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> k4 -> v -> m
f)

-- | /O(n)/. Fold the keys and submaps using the given monoid.
foldMapWithKey' :: (Monoid m) => (k -> DeepMap ks v -> m) -> DeepMap (k ': ks) v -> m
foldMapWithKey' :: (k -> DeepMap ks v -> m) -> DeepMap (k : ks) v -> m
foldMapWithKey' k -> DeepMap ks v -> m
f (Nest Map k (DeepMap ks v)
m) = (m -> k -> DeepMap ks v -> m) -> m -> Map k (DeepMap ks v) -> m
forall a k b. (a -> k -> b -> a) -> a -> Map k b -> a
Map.foldlWithKey' (\m
acc k
k DeepMap ks v
v -> m
acc m -> m -> m
forall a. Semigroup a => a -> a -> a
<> k -> DeepMap ks v -> m
f k
k DeepMap ks v
v) m
forall a. Monoid a => a
mempty Map k (DeepMap ks v)
Map k (DeepMap 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
foldMapWithKey1' :: (k -> v -> m) -> DeepMap '[k] v -> m
foldMapWithKey1' k -> v -> m
f = (k -> DeepMap '[] v -> m) -> DeepMap '[k] v -> m
forall m k (ks :: [*]) v.
Monoid m =>
(k -> DeepMap ks v -> m) -> DeepMap (k : ks) v -> m
foldMapWithKey' (\k
k (Bare v
v) -> k -> v -> m
f k
k v
v)

-- | /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
foldMapWithKey2' :: (k0 -> k1 -> v -> m) -> DeepMap '[k0, k1] v -> m
foldMapWithKey2' k0 -> k1 -> v -> m
f = (k0 -> DeepMap '[k1] v -> m) -> DeepMap '[k0, k1] v -> m
forall m k (ks :: [*]) v.
Monoid m =>
(k -> DeepMap ks v -> m) -> DeepMap (k : ks) v -> m
foldMapWithKey' ((k1 -> v -> m) -> DeepMap '[k1] v -> m
forall m k v. Monoid m => (k -> v -> m) -> DeepMap '[k] v -> m
foldMapWithKey1' ((k1 -> v -> m) -> DeepMap '[k1] v -> m)
-> (k0 -> k1 -> v -> m) -> k0 -> DeepMap '[k1] v -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> v -> m
f)

-- | /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
foldMapWithKey3' :: (k0 -> k1 -> k2 -> v -> m) -> DeepMap '[k0, k1, k2] v -> m
foldMapWithKey3' k0 -> k1 -> k2 -> v -> m
f = (k0 -> DeepMap '[k1, k2] v -> m) -> DeepMap '[k0, k1, k2] v -> m
forall m k (ks :: [*]) v.
Monoid m =>
(k -> DeepMap ks v -> m) -> DeepMap (k : ks) v -> m
foldMapWithKey' ((k1 -> k2 -> v -> m) -> DeepMap '[k1, k2] v -> m
forall m k0 k1 v.
Monoid m =>
(k0 -> k1 -> v -> m) -> DeepMap '[k0, k1] v -> m
foldMapWithKey2' ((k1 -> k2 -> v -> m) -> DeepMap '[k1, k2] v -> m)
-> (k0 -> k1 -> k2 -> v -> m) -> k0 -> DeepMap '[k1, k2] v -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> v -> m
f)

-- | /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
foldMapWithKey4' :: (k0 -> k1 -> k2 -> k3 -> v -> m)
-> DeepMap '[k0, k1, k2, k3] v -> m
foldMapWithKey4' k0 -> k1 -> k2 -> k3 -> v -> m
f = (k0 -> DeepMap '[k1, k2, k3] v -> m)
-> DeepMap '[k0, k1, k2, k3] v -> m
forall m k (ks :: [*]) v.
Monoid m =>
(k -> DeepMap ks v -> m) -> DeepMap (k : ks) v -> m
foldMapWithKey' ((k1 -> k2 -> k3 -> v -> m) -> DeepMap '[k1, k2, k3] v -> m
forall m k0 k1 k2 v.
Monoid m =>
(k0 -> k1 -> k2 -> v -> m) -> DeepMap '[k0, k1, k2] v -> m
foldMapWithKey3' ((k1 -> k2 -> k3 -> v -> m) -> DeepMap '[k1, k2, k3] v -> m)
-> (k0 -> k1 -> k2 -> k3 -> v -> m)
-> k0
-> DeepMap '[k1, k2, k3] v
-> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> v -> m
f)

-- | /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
foldMapWithKey5' :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> m)
-> DeepMap '[k0, k1, k2, k3, k4] v -> m
foldMapWithKey5' k0 -> k1 -> k2 -> k3 -> k4 -> v -> m
f = (k0 -> DeepMap '[k1, k2, k3, k4] v -> m)
-> DeepMap '[k0, k1, k2, k3, k4] v -> m
forall m k (ks :: [*]) v.
Monoid m =>
(k -> DeepMap ks v -> m) -> DeepMap (k : ks) v -> m
foldMapWithKey' ((k1 -> k2 -> k3 -> k4 -> v -> m)
-> DeepMap '[k1, k2, k3, k4] v -> m
forall m k0 k1 k2 k3 v.
Monoid m =>
(k0 -> k1 -> k2 -> k3 -> v -> m)
-> DeepMap '[k0, k1, k2, k3] v -> m
foldMapWithKey4' ((k1 -> k2 -> k3 -> k4 -> v -> m)
 -> DeepMap '[k1, k2, k3, k4] v -> m)
-> (k0 -> k1 -> k2 -> k3 -> k4 -> v -> m)
-> k0
-> DeepMap '[k1, k2, k3, k4] v
-> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> k4 -> v -> m
f)

-- | /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)]
toAscList :: DeepMap (k : ks) v -> [(k, DeepMap ks v)]
toAscList (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> [(k, DeepMap ks v)]
forall k a. Map k a -> [(k, a)]
Map.toAscList Map k (DeepMap ks v)
m

-- | /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)]
toDescList :: DeepMap (k : ks) v -> [(k, DeepMap ks v)]
toDescList (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> [(k, DeepMap ks v)]
forall k a. Map k a -> [(k, a)]
Map.toDescList Map k (DeepMap ks v)
m

-- | /O(n)/. Filter all submaps that satisfy the predicate.
filter :: (DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
filter :: (DeepMap ks v -> Bool) -> DeepMap (k : ks) v -> DeepMap (k : ks) v
filter DeepMap ks v -> Bool
p (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (DeepMap ks v -> Bool)
-> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter DeepMap ks v -> Bool
p Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /O(n)/. Filter all values that satisfy the predicate.
filter1 :: (v -> Bool) -> DeepMap '[k] v -> DeepMap '[k] v
filter1 :: (v -> Bool) -> DeepMap '[k] v -> DeepMap '[k] v
filter1 v -> Bool
p (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap '[] v) -> DeepMap '[k] v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap '[] v) -> DeepMap '[k] v)
-> Map k (DeepMap '[] v) -> DeepMap '[k] v
forall a b. (a -> b) -> a -> b
$ (DeepMap '[] v -> Bool)
-> Map k (DeepMap '[] v) -> Map k (DeepMap '[] v)
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter (v -> Bool
p (v -> Bool) -> (DeepMap '[] v -> v) -> DeepMap '[] v -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DeepMap '[] v -> v
forall v. DeepMap '[] v -> v
getBare) Map k (DeepMap ks v)
Map k (DeepMap '[] v)
m

-- | /O(n)/. Filter all values that satisfy the predicate.
filter2 :: (v -> Bool) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
filter2 :: (v -> Bool) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
filter2 v -> Bool
p DeepMap '[k0, k1] v
m = (DeepMap '[k1] v -> DeepMap '[k1] v)
-> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow ((v -> Bool) -> DeepMap '[k1] v -> DeepMap '[k1] v
forall v k. (v -> Bool) -> DeepMap '[k] v -> DeepMap '[k] v
filter1 v -> Bool
p) (DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v)
-> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall a b. (a -> b) -> a -> b
$ (DeepMap '[k1] v -> Bool)
-> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall (ks :: [*]) v k.
(DeepMap ks v -> Bool) -> DeepMap (k : ks) v -> DeepMap (k : ks) v
filter ((v -> Bool) -> DeepMap '[k1] v -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any v -> Bool
p) DeepMap '[k0, k1] v
m

-- | /O(n)/. Filter all values that satisfy the predicate.
filter3 :: (v -> Bool) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
filter3 :: (v -> Bool) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
filter3 v -> Bool
p DeepMap '[k0, k1, k2] v
m = (DeepMap '[k1, k2] v -> DeepMap '[k1, k2] v)
-> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow ((v -> Bool) -> DeepMap '[k1, k2] v -> DeepMap '[k1, k2] v
forall v k0 k1.
(v -> Bool) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
filter2 v -> Bool
p) (DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v)
-> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
forall a b. (a -> b) -> a -> b
$ (DeepMap '[k1, k2] v -> Bool)
-> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
forall (ks :: [*]) v k.
(DeepMap ks v -> Bool) -> DeepMap (k : ks) v -> DeepMap (k : ks) v
filter ((v -> Bool) -> DeepMap '[k1, k2] v -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any v -> Bool
p) DeepMap '[k0, k1, k2] v
m

-- | /O(n)/. Filter all values that satisfy the predicate.
filter4 :: (v -> Bool) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
filter4 :: (v -> Bool)
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
filter4 v -> Bool
p DeepMap '[k0, k1, k2, k3] v
m = (DeepMap '[k1, k2, k3] v -> DeepMap '[k1, k2, k3] v)
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow ((v -> Bool) -> DeepMap '[k1, k2, k3] v -> DeepMap '[k1, k2, k3] v
forall v k0 k1 k2.
(v -> Bool) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
filter3 v -> Bool
p) (DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v)
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
forall a b. (a -> b) -> a -> b
$ (DeepMap '[k1, k2, k3] v -> Bool)
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
forall (ks :: [*]) v k.
(DeepMap ks v -> Bool) -> DeepMap (k : ks) v -> DeepMap (k : ks) v
filter ((v -> Bool) -> DeepMap '[k1, k2, k3] v -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any v -> Bool
p) DeepMap '[k0, k1, k2, k3] v
m

-- | /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
filter5 :: (v -> Bool)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
filter5 v -> Bool
p DeepMap '[k0, k1, k2, k3, k4] v
m = (DeepMap '[k1, k2, k3, k4] v -> DeepMap '[k1, k2, k3, k4] v)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow ((v -> Bool)
-> DeepMap '[k1, k2, k3, k4] v -> DeepMap '[k1, k2, k3, k4] v
forall v k0 k1 k2 k3.
(v -> Bool)
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
filter4 v -> Bool
p) (DeepMap '[k0, k1, k2, k3, k4] v
 -> DeepMap '[k0, k1, k2, k3, k4] v)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall a b. (a -> b) -> a -> b
$ (DeepMap '[k1, k2, k3, k4] v -> Bool)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall (ks :: [*]) v k.
(DeepMap ks v -> Bool) -> DeepMap (k : ks) v -> DeepMap (k : ks) v
filter ((v -> Bool) -> DeepMap '[k1, k2, k3, k4] v -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any v -> Bool
p) DeepMap '[k0, k1, k2, k3, k4] v
m

-- | /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
filterWithKey :: (k -> DeepMap ks v -> Bool)
-> DeepMap (k : ks) v -> DeepMap (k : ks) v
filterWithKey k -> DeepMap ks v -> Bool
p (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (k -> DeepMap ks v -> Bool)
-> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall k a. (k -> a -> Bool) -> Map k a -> Map k a
Map.filterWithKey k -> DeepMap ks v -> Bool
p Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /O(n)/. Filter all key/value pairs that satisfy the predicate.
filterWithKey1 :: (k -> v -> Bool) -> DeepMap '[k] v -> DeepMap '[k] v
filterWithKey1 :: (k -> v -> Bool) -> DeepMap '[k] v -> DeepMap '[k] v
filterWithKey1 k -> v -> Bool
p DeepMap '[k] v
m = Identity (DeepMap '[k] v) -> DeepMap '[k] v
forall a. Identity a -> a
runIdentity (Identity (DeepMap '[k] v) -> DeepMap '[k] v)
-> Identity (DeepMap '[k] v) -> DeepMap '[k] v
forall a b. (a -> b) -> a -> b
$ (k -> v -> Identity (Maybe v))
-> DeepMap '[k] v -> Identity (DeepMap '[k] v)
forall (f :: * -> *) k v w.
Applicative f =>
(k -> v -> f (Maybe w)) -> DeepMap '[k] v -> f (DeepMap '[k] w)
traverseMaybeWithKey1 (\k
k0 -> Maybe v -> Identity (Maybe v)
forall a. a -> Identity a
Identity (Maybe v -> Identity (Maybe v))
-> (v -> Maybe v) -> v -> Identity (Maybe v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((v -> Maybe v) -> (v -> Maybe v) -> Bool -> v -> Maybe v
forall a. a -> a -> Bool -> a
bool (Maybe v -> v -> Maybe v
forall a b. a -> b -> a
const Maybe v
forall a. Maybe a
Nothing) v -> Maybe v
forall a. a -> Maybe a
Just (Bool -> v -> Maybe v) -> (v -> Bool) -> v -> Maybe v
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< k -> v -> Bool
p k
k0)) DeepMap '[k] v
m

-- | /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
filterWithKey2 :: (k0 -> k1 -> v -> Bool)
-> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
filterWithKey2 k0 -> k1 -> v -> Bool
p DeepMap '[k0, k1] v
m = Identity (DeepMap '[k0, k1] v) -> DeepMap '[k0, k1] v
forall a. Identity a -> a
runIdentity (Identity (DeepMap '[k0, k1] v) -> DeepMap '[k0, k1] v)
-> Identity (DeepMap '[k0, k1] v) -> DeepMap '[k0, k1] v
forall a b. (a -> b) -> a -> b
$ (k0 -> k1 -> v -> Identity (Maybe v))
-> DeepMap '[k0, k1] v -> Identity (DeepMap '[k0, k1] v)
forall (f :: * -> *) k0 k1 v w.
Applicative f =>
(k0 -> k1 -> v -> f (Maybe w))
-> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] w)
traverseMaybeWithKey2 (\k0
k0 k1
k1 -> Maybe v -> Identity (Maybe v)
forall a. a -> Identity a
Identity (Maybe v -> Identity (Maybe v))
-> (v -> Maybe v) -> v -> Identity (Maybe v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((v -> Maybe v) -> (v -> Maybe v) -> Bool -> v -> Maybe v
forall a. a -> a -> Bool -> a
bool (Maybe v -> v -> Maybe v
forall a b. a -> b -> a
const Maybe v
forall a. Maybe a
Nothing) v -> Maybe v
forall a. a -> Maybe a
Just (Bool -> v -> Maybe v) -> (v -> Bool) -> v -> Maybe v
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< k0 -> k1 -> v -> Bool
p k0
k0 k1
k1)) DeepMap '[k0, k1] v
m

-- | /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
filterWithKey3 :: (k0 -> k1 -> k2 -> v -> Bool)
-> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
filterWithKey3 k0 -> k1 -> k2 -> v -> Bool
p DeepMap '[k0, k1, k2] v
m = Identity (DeepMap '[k0, k1, k2] v) -> DeepMap '[k0, k1, k2] v
forall a. Identity a -> a
runIdentity (Identity (DeepMap '[k0, k1, k2] v) -> DeepMap '[k0, k1, k2] v)
-> Identity (DeepMap '[k0, k1, k2] v) -> DeepMap '[k0, k1, k2] v
forall a b. (a -> b) -> a -> b
$ (k0 -> k1 -> k2 -> v -> Identity (Maybe v))
-> DeepMap '[k0, k1, k2] v -> Identity (DeepMap '[k0, k1, k2] v)
forall (f :: * -> *) k0 k1 k2 v w.
Applicative f =>
(k0 -> k1 -> k2 -> v -> f (Maybe w))
-> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] w)
traverseMaybeWithKey3 (\k0
k0 k1
k1 k2
k2 -> Maybe v -> Identity (Maybe v)
forall a. a -> Identity a
Identity (Maybe v -> Identity (Maybe v))
-> (v -> Maybe v) -> v -> Identity (Maybe v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((v -> Maybe v) -> (v -> Maybe v) -> Bool -> v -> Maybe v
forall a. a -> a -> Bool -> a
bool (Maybe v -> v -> Maybe v
forall a b. a -> b -> a
const Maybe v
forall a. Maybe a
Nothing) v -> Maybe v
forall a. a -> Maybe a
Just (Bool -> v -> Maybe v) -> (v -> Bool) -> v -> Maybe v
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< k0 -> k1 -> k2 -> v -> Bool
p k0
k0 k1
k1 k2
k2)) DeepMap '[k0, k1, k2] v
m

-- | /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
filterWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> Bool)
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
filterWithKey4 k0 -> k1 -> k2 -> k3 -> v -> Bool
p DeepMap '[k0, k1, k2, k3] v
m = Identity (DeepMap '[k0, k1, k2, k3] v)
-> DeepMap '[k0, k1, k2, k3] v
forall a. Identity a -> a
runIdentity (Identity (DeepMap '[k0, k1, k2, k3] v)
 -> DeepMap '[k0, k1, k2, k3] v)
-> Identity (DeepMap '[k0, k1, k2, k3] v)
-> DeepMap '[k0, k1, k2, k3] v
forall a b. (a -> b) -> a -> b
$ (k0 -> k1 -> k2 -> k3 -> v -> Identity (Maybe v))
-> DeepMap '[k0, k1, k2, k3] v
-> Identity (DeepMap '[k0, k1, k2, k3] v)
forall (f :: * -> *) k0 k1 k2 k3 v w.
Applicative f =>
(k0 -> k1 -> k2 -> k3 -> v -> f (Maybe w))
-> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] w)
traverseMaybeWithKey4 (\k0
k0 k1
k1 k2
k2 k3
k3 -> Maybe v -> Identity (Maybe v)
forall a. a -> Identity a
Identity (Maybe v -> Identity (Maybe v))
-> (v -> Maybe v) -> v -> Identity (Maybe v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((v -> Maybe v) -> (v -> Maybe v) -> Bool -> v -> Maybe v
forall a. a -> a -> Bool -> a
bool (Maybe v -> v -> Maybe v
forall a b. a -> b -> a
const Maybe v
forall a. Maybe a
Nothing) v -> Maybe v
forall a. a -> Maybe a
Just (Bool -> v -> Maybe v) -> (v -> Bool) -> v -> Maybe v
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< k0 -> k1 -> k2 -> k3 -> v -> Bool
p k0
k0 k1
k1 k2
k2 k3
k3)) DeepMap '[k0, k1, k2, k3] v
m

-- | /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
filterWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Bool)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
filterWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> Bool
p DeepMap '[k0, k1, k2, k3, k4] v
m = Identity (DeepMap '[k0, k1, k2, k3, k4] v)
-> DeepMap '[k0, k1, k2, k3, k4] v
forall a. Identity a -> a
runIdentity (Identity (DeepMap '[k0, k1, k2, k3, k4] v)
 -> DeepMap '[k0, k1, k2, k3, k4] v)
-> Identity (DeepMap '[k0, k1, k2, k3, k4] v)
-> DeepMap '[k0, k1, k2, k3, k4] v
forall a b. (a -> b) -> a -> b
$ (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Identity (Maybe v))
-> DeepMap '[k0, k1, k2, k3, k4] v
-> Identity (DeepMap '[k0, k1, k2, k3, k4] v)
forall (f :: * -> *) k0 k1 k2 k3 k4 v w.
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)
traverseMaybeWithKey5 (\k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 -> Maybe v -> Identity (Maybe v)
forall a. a -> Identity a
Identity (Maybe v -> Identity (Maybe v))
-> (v -> Maybe v) -> v -> Identity (Maybe v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((v -> Maybe v) -> (v -> Maybe v) -> Bool -> v -> Maybe v
forall a. a -> a -> Bool -> a
bool (Maybe v -> v -> Maybe v
forall a b. a -> b -> a
const Maybe v
forall a. Maybe a
Nothing) v -> Maybe v
forall a. a -> Maybe a
Just (Bool -> v -> Maybe v) -> (v -> Bool) -> v -> Maybe v
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< k0 -> k1 -> k2 -> k3 -> k4 -> v -> Bool
p k0
k0 k1
k1 k2
k2 k3
k3 k4
k4)) DeepMap '[k0, k1, k2, k3, k4] v
m

-- | /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
restrictKeys :: DeepMap (k : ks) v -> Set k -> DeepMap (k : ks) v
restrictKeys (Nest Map k (DeepMap ks v)
m) Set k
s = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ Map k (DeepMap ks v) -> Set k -> Map k (DeepMap ks v)
forall k a. Ord k => Map k a -> Set k -> Map k a
Map.restrictKeys Map k (DeepMap ks v)
m Set k
Set k
s

-- | /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
restrictKeys2 :: DeepMap (k0 : k1 : ks) v
-> Set (k0, k1) -> DeepMap (k0 : k1 : ks) v
restrictKeys2 DeepMap (k0 : k1 : ks) v
m Set (k0, k1)
s = (DeepMap (k1 : ks) v -> DeepMap (k1 : ks) v)
-> DeepMap (k0 : k1 : ks) v -> DeepMap (k0 : k1 : ks) v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow (\DeepMap (k1 : ks) v
dm -> DeepMap (k1 : ks) v -> Set k1 -> DeepMap (k1 : ks) v
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> Set k -> DeepMap (k : ks) v
restrictKeys DeepMap (k1 : ks) v
dm (((k0, k1) -> k1) -> Set (k0, k1) -> Set k1
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (k0, k1) -> k1
forall a b. (a, b) -> b
snd Set (k0, k1)
s)) (DeepMap (k0 : k1 : ks) v -> DeepMap (k0 : k1 : ks) v)
-> DeepMap (k0 : k1 : ks) v -> DeepMap (k0 : k1 : ks) v
forall a b. (a -> b) -> a -> b
$ DeepMap (k0 : k1 : ks) v -> Set k0 -> DeepMap (k0 : k1 : ks) v
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> Set k -> DeepMap (k : ks) v
restrictKeys DeepMap (k0 : k1 : ks) v
m (((k0, k1) -> k0) -> Set (k0, k1) -> Set k0
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (k0, k1) -> k0
forall a b. (a, b) -> a
fst Set (k0, k1)
s)

-- | /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
restrictKeys3 :: DeepMap (k0 : k1 : k2 : ks) v
-> Set (k0, k1, k2) -> DeepMap (k0 : k1 : k2 : ks) v
restrictKeys3 DeepMap (k0 : k1 : k2 : ks) v
m Set (k0, k1, k2)
s =
    (DeepMap (k1 : k2 : ks) v -> DeepMap (k1 : k2 : ks) v)
-> DeepMap (k0 : k1 : k2 : ks) v -> DeepMap (k0 : k1 : k2 : ks) v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow (\DeepMap (k1 : k2 : ks) v
dm -> DeepMap (k1 : k2 : ks) v
-> Set (k1, k2) -> DeepMap (k1 : k2 : ks) v
forall k0 k1 (ks :: [*]) v.
(Ord k0, Ord k1) =>
DeepMap (k0 : k1 : ks) v
-> Set (k0, k1) -> DeepMap (k0 : k1 : ks) v
restrictKeys2 DeepMap (k1 : k2 : ks) v
dm (((k0, k1, k2) -> (k1, k2)) -> Set (k0, k1, k2) -> Set (k1, k2)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\(k0
_, k1
b, k2
c) -> (k1
b, k2
c)) Set (k0, k1, k2)
s)) (DeepMap (k0 : k1 : k2 : ks) v -> DeepMap (k0 : k1 : k2 : ks) v)
-> DeepMap (k0 : k1 : k2 : ks) v -> DeepMap (k0 : k1 : k2 : ks) v
forall a b. (a -> b) -> a -> b
$
        DeepMap (k0 : k1 : k2 : ks) v
-> Set k0 -> DeepMap (k0 : k1 : k2 : ks) v
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> Set k -> DeepMap (k : ks) v
restrictKeys DeepMap (k0 : k1 : k2 : ks) v
m (((k0, k1, k2) -> k0) -> Set (k0, k1, k2) -> Set k0
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\(k0
a, k1
_, k2
_) -> k0
a) Set (k0, k1, k2)
s)

-- | /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
restrictKeys4 :: DeepMap (k0 : k1 : k2 : k3 : ks) v
-> Set (k0, k1, k2, k3) -> DeepMap (k0 : k1 : k2 : k3 : ks) v
restrictKeys4 DeepMap (k0 : k1 : k2 : k3 : ks) v
m Set (k0, k1, k2, k3)
s = (DeepMap (k1 : k2 : k3 : ks) v -> DeepMap (k1 : k2 : k3 : ks) v)
-> DeepMap (k0 : k1 : k2 : k3 : ks) v
-> DeepMap (k0 : k1 : k2 : k3 : ks) v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow (\DeepMap (k1 : k2 : k3 : ks) v
dm -> DeepMap (k1 : k2 : k3 : ks) v
-> Set (k1, k2, k3) -> DeepMap (k1 : k2 : k3 : ks) v
forall k0 k1 k2 (ks :: [*]) v.
(Ord k0, Ord k1, Ord k2) =>
DeepMap (k0 : k1 : k2 : ks) v
-> Set (k0, k1, k2) -> DeepMap (k0 : k1 : k2 : ks) v
restrictKeys3 DeepMap (k1 : k2 : k3 : ks) v
dm (((k0, k1, k2, k3) -> (k1, k2, k3))
-> Set (k0, k1, k2, k3) -> Set (k1, k2, k3)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\(k0
_, k1
b, k2
c, k3
d) -> (k1
b, k2
c, k3
d)) Set (k0, k1, k2, k3)
s)) (DeepMap (k0 : k1 : k2 : k3 : ks) v
 -> DeepMap (k0 : k1 : k2 : k3 : ks) v)
-> DeepMap (k0 : k1 : k2 : k3 : ks) v
-> DeepMap (k0 : k1 : k2 : k3 : ks) v
forall a b. (a -> b) -> a -> b
$ DeepMap (k0 : k1 : k2 : k3 : ks) v
-> Set k0 -> DeepMap (k0 : k1 : k2 : k3 : ks) v
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> Set k -> DeepMap (k : ks) v
restrictKeys DeepMap (k0 : k1 : k2 : k3 : ks) v
m (((k0, k1, k2, k3) -> k0) -> Set (k0, k1, k2, k3) -> Set k0
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\(k0
a, k1
_, k2
_, k3
_) -> k0
a) Set (k0, k1, k2, k3)
s)

-- | /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
restrictKeys5 :: DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
-> Set (k0, k1, k2, k3, k4)
-> DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
restrictKeys5 DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
m Set (k0, k1, k2, k3, k4)
s = (DeepMap (k1 : k2 : k3 : k4 : ks) v
 -> DeepMap (k1 : k2 : k3 : k4 : ks) v)
-> DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
-> DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow (\DeepMap (k1 : k2 : k3 : k4 : ks) v
dm -> DeepMap (k1 : k2 : k3 : k4 : ks) v
-> Set (k1, k2, k3, k4) -> DeepMap (k1 : k2 : k3 : k4 : ks) v
forall k0 k1 k2 k3 (ks :: [*]) v.
(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
restrictKeys4 DeepMap (k1 : k2 : k3 : k4 : ks) v
dm (((k0, k1, k2, k3, k4) -> (k1, k2, k3, k4))
-> Set (k0, k1, k2, k3, k4) -> Set (k1, k2, k3, k4)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\(k0
_, k1
b, k2
c, k3
d, k4
e) -> (k1
b, k2
c, k3
d, k4
e)) Set (k0, k1, k2, k3, k4)
s)) (DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
 -> DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v)
-> DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
-> DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
forall a b. (a -> b) -> a -> b
$ DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
-> Set k0 -> DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> Set k -> DeepMap (k : ks) v
restrictKeys DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
m (((k0, k1, k2, k3, k4) -> k0) -> Set (k0, k1, k2, k3, k4) -> Set k0
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\(k0
a, k1
_, k2
_, k3
_, k4
_) -> k0
a) Set (k0, k1, k2, k3, k4)
s)

-- | /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
withoutKeys :: DeepMap (k : ks) v -> Set k -> DeepMap (k : ks) v
withoutKeys (Nest Map k (DeepMap ks v)
m) Set k
s = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ Map k (DeepMap ks v) -> Set k -> Map k (DeepMap ks v)
forall k a. Ord k => Map k a -> Set k -> Map k a
Map.withoutKeys Map k (DeepMap ks v)
m Set k
Set k
s

-- | /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
withoutKeys2 :: DeepMap (k0 : k1 : ks) v
-> Set (k0, k1) -> DeepMap (k0 : k1 : ks) v
withoutKeys2 DeepMap (k0 : k1 : ks) v
m Set (k0, k1)
s = (DeepMap (k1 : ks) v -> DeepMap (k1 : ks) v)
-> DeepMap (k0 : k1 : ks) v -> DeepMap (k0 : k1 : ks) v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow (\DeepMap (k1 : ks) v
dm -> DeepMap (k1 : ks) v -> Set k1 -> DeepMap (k1 : ks) v
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> Set k -> DeepMap (k : ks) v
withoutKeys DeepMap (k1 : ks) v
dm (((k0, k1) -> k1) -> Set (k0, k1) -> Set k1
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (k0, k1) -> k1
forall a b. (a, b) -> b
snd Set (k0, k1)
s)) (DeepMap (k0 : k1 : ks) v -> DeepMap (k0 : k1 : ks) v)
-> DeepMap (k0 : k1 : ks) v -> DeepMap (k0 : k1 : ks) v
forall a b. (a -> b) -> a -> b
$ DeepMap (k0 : k1 : ks) v -> Set k0 -> DeepMap (k0 : k1 : ks) v
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> Set k -> DeepMap (k : ks) v
withoutKeys DeepMap (k0 : k1 : ks) v
m (((k0, k1) -> k0) -> Set (k0, k1) -> Set k0
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (k0, k1) -> k0
forall a b. (a, b) -> a
fst Set (k0, k1)
s)

-- | /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
withoutKeys3 :: DeepMap (k0 : k1 : k2 : ks) v
-> Set (k0, k1, k2) -> DeepMap (k0 : k1 : k2 : ks) v
withoutKeys3 DeepMap (k0 : k1 : k2 : ks) v
m Set (k0, k1, k2)
s = (DeepMap (k1 : k2 : ks) v -> DeepMap (k1 : k2 : ks) v)
-> DeepMap (k0 : k1 : k2 : ks) v -> DeepMap (k0 : k1 : k2 : ks) v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow (\DeepMap (k1 : k2 : ks) v
dm -> DeepMap (k1 : k2 : ks) v
-> Set (k1, k2) -> DeepMap (k1 : k2 : ks) v
forall k0 k1 (ks :: [*]) v.
(Ord k0, Ord k1) =>
DeepMap (k0 : k1 : ks) v
-> Set (k0, k1) -> DeepMap (k0 : k1 : ks) v
withoutKeys2 DeepMap (k1 : k2 : ks) v
dm (((k0, k1, k2) -> (k1, k2)) -> Set (k0, k1, k2) -> Set (k1, k2)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\(k0
_, k1
b, k2
c) -> (k1
b, k2
c)) Set (k0, k1, k2)
s)) (DeepMap (k0 : k1 : k2 : ks) v -> DeepMap (k0 : k1 : k2 : ks) v)
-> DeepMap (k0 : k1 : k2 : ks) v -> DeepMap (k0 : k1 : k2 : ks) v
forall a b. (a -> b) -> a -> b
$ DeepMap (k0 : k1 : k2 : ks) v
-> Set k0 -> DeepMap (k0 : k1 : k2 : ks) v
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> Set k -> DeepMap (k : ks) v
withoutKeys DeepMap (k0 : k1 : k2 : ks) v
m (((k0, k1, k2) -> k0) -> Set (k0, k1, k2) -> Set k0
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\(k0
a, k1
_, k2
_) -> k0
a) Set (k0, k1, k2)
s)

-- | /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
withoutKeys4 :: DeepMap (k0 : k1 : k2 : k3 : ks) v
-> Set (k0, k1, k2, k3) -> DeepMap (k0 : k1 : k2 : k3 : ks) v
withoutKeys4 DeepMap (k0 : k1 : k2 : k3 : ks) v
m Set (k0, k1, k2, k3)
s = (DeepMap (k1 : k2 : k3 : ks) v -> DeepMap (k1 : k2 : k3 : ks) v)
-> DeepMap (k0 : k1 : k2 : k3 : ks) v
-> DeepMap (k0 : k1 : k2 : k3 : ks) v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow (\DeepMap (k1 : k2 : k3 : ks) v
dm -> DeepMap (k1 : k2 : k3 : ks) v
-> Set (k1, k2, k3) -> DeepMap (k1 : k2 : k3 : ks) v
forall k0 k1 k2 (ks :: [*]) v.
(Ord k0, Ord k1, Ord k2) =>
DeepMap (k0 : k1 : k2 : ks) v
-> Set (k0, k1, k2) -> DeepMap (k0 : k1 : k2 : ks) v
withoutKeys3 DeepMap (k1 : k2 : k3 : ks) v
dm (((k0, k1, k2, k3) -> (k1, k2, k3))
-> Set (k0, k1, k2, k3) -> Set (k1, k2, k3)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\(k0
_, k1
b, k2
c, k3
d) -> (k1
b, k2
c, k3
d)) Set (k0, k1, k2, k3)
s)) (DeepMap (k0 : k1 : k2 : k3 : ks) v
 -> DeepMap (k0 : k1 : k2 : k3 : ks) v)
-> DeepMap (k0 : k1 : k2 : k3 : ks) v
-> DeepMap (k0 : k1 : k2 : k3 : ks) v
forall a b. (a -> b) -> a -> b
$ DeepMap (k0 : k1 : k2 : k3 : ks) v
-> Set k0 -> DeepMap (k0 : k1 : k2 : k3 : ks) v
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> Set k -> DeepMap (k : ks) v
withoutKeys DeepMap (k0 : k1 : k2 : k3 : ks) v
m (((k0, k1, k2, k3) -> k0) -> Set (k0, k1, k2, k3) -> Set k0
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\(k0
a, k1
_, k2
_, k3
_) -> k0
a) Set (k0, k1, k2, k3)
s)

-- | /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
withoutKeys5 :: DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
-> Set (k0, k1, k2, k3, k4)
-> DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
withoutKeys5 DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
m Set (k0, k1, k2, k3, k4)
s = (DeepMap (k1 : k2 : k3 : k4 : ks) v
 -> DeepMap (k1 : k2 : k3 : k4 : ks) v)
-> DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
-> DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
forall (ks :: [*]) v (ls :: [*]) w k.
(DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallow (\DeepMap (k1 : k2 : k3 : k4 : ks) v
dm -> DeepMap (k1 : k2 : k3 : k4 : ks) v
-> Set (k1, k2, k3, k4) -> DeepMap (k1 : k2 : k3 : k4 : ks) v
forall k0 k1 k2 k3 (ks :: [*]) v.
(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
withoutKeys4 DeepMap (k1 : k2 : k3 : k4 : ks) v
dm (((k0, k1, k2, k3, k4) -> (k1, k2, k3, k4))
-> Set (k0, k1, k2, k3, k4) -> Set (k1, k2, k3, k4)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\(k0
_, k1
b, k2
c, k3
d, k4
e) -> (k1
b, k2
c, k3
d, k4
e)) Set (k0, k1, k2, k3, k4)
s)) (DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
 -> DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v)
-> DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
-> DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
forall a b. (a -> b) -> a -> b
$ DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
-> Set k0 -> DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
forall k (ks :: [*]) v.
Ord k =>
DeepMap (k : ks) v -> Set k -> DeepMap (k : ks) v
withoutKeys DeepMap (k0 : k1 : k2 : k3 : k4 : ks) v
m (((k0, k1, k2, k3, k4) -> k0) -> Set (k0, k1, k2, k3, k4) -> Set k0
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\(k0
a, k1
_, k2
_, k3
_, k4
_) -> k0
a) Set (k0, k1, k2, k3, k4)
s)

-- | /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)
partition :: (DeepMap ks v -> Bool)
-> DeepMap (k : ks) v -> (DeepMap (k : ks) v, DeepMap (k : ks) v)
partition DeepMap ks v -> Bool
p (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> (Map k (DeepMap ks v), Map k (DeepMap ks v))
-> (DeepMap (k : ks) v, DeepMap (k : ks) v)
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest ((Map k (DeepMap ks v), Map k (DeepMap ks v))
 -> (DeepMap (k : ks) v, DeepMap (k : ks) v))
-> (Map k (DeepMap ks v), Map k (DeepMap ks v))
-> (DeepMap (k : ks) v, DeepMap (k : ks) v)
forall a b. (a -> b) -> a -> b
$ (DeepMap ks v -> Bool)
-> Map k (DeepMap ks v)
-> (Map k (DeepMap ks v), Map k (DeepMap ks v))
forall a k. (a -> Bool) -> Map k a -> (Map k a, Map k a)
Map.partition DeepMap ks v -> Bool
p Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /O(n)/. Partition the map according to a predicate (satisfied, failed).
partition1 :: (v -> Bool) -> DeepMap '[k] v -> (DeepMap '[k] v, DeepMap '[k] v)
partition1 :: (v -> Bool) -> DeepMap '[k] v -> (DeepMap '[k] v, DeepMap '[k] v)
partition1 v -> Bool
p = (DeepMap '[] v -> Bool)
-> DeepMap '[k] v -> (DeepMap '[k] v, DeepMap '[k] v)
forall (ks :: [*]) v k.
(DeepMap ks v -> Bool)
-> DeepMap (k : ks) v -> (DeepMap (k : ks) v, DeepMap (k : ks) v)
partition (v -> Bool
p (v -> Bool) -> (DeepMap '[] v -> v) -> DeepMap '[] v -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DeepMap '[] v -> v
forall v. DeepMap '[] v -> v
getBare)

-- | /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)
partition2 :: (v -> Bool)
-> DeepMap '[k0, k1] v
-> (DeepMap '[k0, k1] v, DeepMap '[k0, k1] v)
partition2 v -> Bool
p = (v -> Bool) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall v k0 k1.
(v -> Bool) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
filter2 v -> Bool
p (DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v)
-> (DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v)
-> DeepMap '[k0, k1] v
-> (DeepMap '[k0, k1] v, DeepMap '[k0, k1] v)
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& (v -> Bool) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall v k0 k1.
(v -> Bool) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
filter2 (Bool -> Bool
not (Bool -> Bool) -> (v -> Bool) -> v -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v -> Bool
p)

-- | /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)
partition3 :: (v -> Bool)
-> DeepMap '[k0, k1, k2] v
-> (DeepMap '[k0, k1, k2] v, DeepMap '[k0, k1, k2] v)
partition3 v -> Bool
p = (v -> Bool) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
forall v k0 k1 k2.
(v -> Bool) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
filter3 v -> Bool
p (DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v)
-> (DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v)
-> DeepMap '[k0, k1, k2] v
-> (DeepMap '[k0, k1, k2] v, DeepMap '[k0, k1, k2] v)
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& (v -> Bool) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
forall v k0 k1 k2.
(v -> Bool) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
filter3 (Bool -> Bool
not (Bool -> Bool) -> (v -> Bool) -> v -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v -> Bool
p)

-- | /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)
partition4 :: (v -> Bool)
-> DeepMap '[k0, k1, k2, k3] v
-> (DeepMap '[k0, k1, k2, k3] v, DeepMap '[k0, k1, k2, k3] v)
partition4 v -> Bool
p = (v -> Bool)
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
forall v k0 k1 k2 k3.
(v -> Bool)
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
filter4 v -> Bool
p (DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v)
-> (DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v)
-> DeepMap '[k0, k1, k2, k3] v
-> (DeepMap '[k0, k1, k2, k3] v, DeepMap '[k0, k1, k2, k3] v)
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& (v -> Bool)
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
forall v k0 k1 k2 k3.
(v -> Bool)
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
filter4 (Bool -> Bool
not (Bool -> Bool) -> (v -> Bool) -> v -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v -> Bool
p)

-- | /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)
partition5 :: (v -> Bool)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> (DeepMap '[k0, k1, k2, k3, k4] v,
    DeepMap '[k0, k1, k2, k3, k4] v)
partition5 v -> Bool
p = (v -> Bool)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall v k0 k1 k2 k3 k4.
(v -> Bool)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
filter5 v -> Bool
p (DeepMap '[k0, k1, k2, k3, k4] v
 -> DeepMap '[k0, k1, k2, k3, k4] v)
-> (DeepMap '[k0, k1, k2, k3, k4] v
    -> DeepMap '[k0, k1, k2, k3, k4] v)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> (DeepMap '[k0, k1, k2, k3, k4] v,
    DeepMap '[k0, k1, k2, k3, k4] v)
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& (v -> Bool)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall v k0 k1 k2 k3 k4.
(v -> Bool)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
filter5 (Bool -> Bool
not (Bool -> Bool) -> (v -> Bool) -> v -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v -> Bool
p)

-- | /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)
partitionWithKey :: (k -> DeepMap ks v -> Bool)
-> DeepMap (k : ks) v -> (DeepMap (k : ks) v, DeepMap (k : ks) v)
partitionWithKey k -> DeepMap ks v -> Bool
p (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> (Map k (DeepMap ks v), Map k (DeepMap ks v))
-> (DeepMap (k : ks) v, DeepMap (k : ks) v)
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest ((Map k (DeepMap ks v), Map k (DeepMap ks v))
 -> (DeepMap (k : ks) v, DeepMap (k : ks) v))
-> (Map k (DeepMap ks v), Map k (DeepMap ks v))
-> (DeepMap (k : ks) v, DeepMap (k : ks) v)
forall a b. (a -> b) -> a -> b
$ (k -> DeepMap ks v -> Bool)
-> Map k (DeepMap ks v)
-> (Map k (DeepMap ks v), Map k (DeepMap ks v))
forall k a. (k -> a -> Bool) -> Map k a -> (Map k a, Map k a)
Map.partitionWithKey k -> DeepMap ks v -> Bool
p Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /O(n)/. Partition the map according to a predicate (satisfied, failed).
partitionWithKey1 :: (k -> v -> Bool) -> DeepMap '[k] v -> (DeepMap '[k] v, DeepMap '[k] v)
partitionWithKey1 :: (k -> v -> Bool)
-> DeepMap '[k] v -> (DeepMap '[k] v, DeepMap '[k] v)
partitionWithKey1 k -> v -> Bool
p = (k -> DeepMap '[] v -> Bool)
-> DeepMap '[k] v -> (DeepMap '[k] v, DeepMap '[k] v)
forall k (ks :: [*]) v.
(k -> DeepMap ks v -> Bool)
-> DeepMap (k : ks) v -> (DeepMap (k : ks) v, DeepMap (k : ks) v)
partitionWithKey (\k
k -> k -> v -> Bool
p k
k (v -> Bool) -> (DeepMap '[] v -> v) -> DeepMap '[] v -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DeepMap '[] v -> v
forall v. DeepMap '[] v -> v
getBare)

-- | /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)
partitionWithKey2 :: (k0 -> k1 -> v -> Bool)
-> DeepMap '[k0, k1] v
-> (DeepMap '[k0, k1] v, DeepMap '[k0, k1] v)
partitionWithKey2 k0 -> k1 -> v -> Bool
p = (k0 -> k1 -> v -> Bool)
-> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k0 k1 v.
(k0 -> k1 -> v -> Bool)
-> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
filterWithKey2 k0 -> k1 -> v -> Bool
p (DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v)
-> (DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v)
-> DeepMap '[k0, k1] v
-> (DeepMap '[k0, k1] v, DeepMap '[k0, k1] v)
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& (k0 -> k1 -> v -> Bool)
-> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
forall k0 k1 v.
(k0 -> k1 -> v -> Bool)
-> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
filterWithKey2 (\k0
k0 k1
k1 -> Bool -> Bool
not (Bool -> Bool) -> (v -> Bool) -> v -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> v -> Bool
p k0
k0 k1
k1)

-- | /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)
partitionWithKey3 :: (k0 -> k1 -> k2 -> v -> Bool)
-> DeepMap '[k0, k1, k2] v
-> (DeepMap '[k0, k1, k2] v, DeepMap '[k0, k1, k2] v)
partitionWithKey3 k0 -> k1 -> k2 -> v -> Bool
p = (k0 -> k1 -> k2 -> v -> Bool)
-> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
forall k0 k1 k2 v.
(k0 -> k1 -> k2 -> v -> Bool)
-> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
filterWithKey3 k0 -> k1 -> k2 -> v -> Bool
p (DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v)
-> (DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v)
-> DeepMap '[k0, k1, k2] v
-> (DeepMap '[k0, k1, k2] v, DeepMap '[k0, k1, k2] v)
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& (k0 -> k1 -> k2 -> v -> Bool)
-> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
forall k0 k1 k2 v.
(k0 -> k1 -> k2 -> v -> Bool)
-> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
filterWithKey3 (\k0
k0 k1
k1 k2
k2 -> Bool -> Bool
not (Bool -> Bool) -> (v -> Bool) -> v -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> v -> Bool
p k0
k0 k1
k1 k2
k2)

-- | /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)
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)
partitionWithKey4 k0 -> k1 -> k2 -> k3 -> v -> Bool
p = (k0 -> k1 -> k2 -> k3 -> v -> Bool)
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
forall k0 k1 k2 k3 v.
(k0 -> k1 -> k2 -> k3 -> v -> Bool)
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
filterWithKey4 k0 -> k1 -> k2 -> k3 -> v -> Bool
p (DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v)
-> (DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v)
-> DeepMap '[k0, k1, k2, k3] v
-> (DeepMap '[k0, k1, k2, k3] v, DeepMap '[k0, k1, k2, k3] v)
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& (k0 -> k1 -> k2 -> k3 -> v -> Bool)
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
forall k0 k1 k2 k3 v.
(k0 -> k1 -> k2 -> k3 -> v -> Bool)
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
filterWithKey4 (\k0
k0 k1
k1 k2
k2 k3
k3 -> Bool -> Bool
not (Bool -> Bool) -> (v -> Bool) -> v -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> v -> Bool
p k0
k0 k1
k1 k2
k2 k3
k3)

-- | /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)
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)
partitionWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> Bool
p = (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Bool)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k0 k1 k2 k3 k4 v.
(k0 -> k1 -> k2 -> k3 -> k4 -> v -> Bool)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
filterWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> Bool
p (DeepMap '[k0, k1, k2, k3, k4] v
 -> DeepMap '[k0, k1, k2, k3, k4] v)
-> (DeepMap '[k0, k1, k2, k3, k4] v
    -> DeepMap '[k0, k1, k2, k3, k4] v)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> (DeepMap '[k0, k1, k2, k3, k4] v,
    DeepMap '[k0, k1, k2, k3, k4] v)
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Bool)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
forall k0 k1 k2 k3 k4 v.
(k0 -> k1 -> k2 -> k3 -> k4 -> v -> Bool)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] v
filterWithKey5 (\k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 -> Bool -> Bool
not (Bool -> Bool) -> (v -> Bool) -> v -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> k4 -> v -> Bool
p k0
k0 k1
k1 k2
k2 k3
k3 k4
k4)

-- | /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
takeWhileAntitone :: (k -> Bool) -> DeepMap (k : ks) v -> DeepMap (k : ks) v
takeWhileAntitone k -> Bool
p (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (k -> Bool) -> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall k a. (k -> Bool) -> Map k a -> Map k a
Map.takeWhileAntitone k -> Bool
p Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
dropWhileAntitone :: (k -> Bool) -> DeepMap (k : ks) v -> DeepMap (k : ks) v
dropWhileAntitone k -> Bool
p (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (k -> Bool) -> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall k a. (k -> Bool) -> Map k a -> Map k a
Map.dropWhileAntitone k -> Bool
p Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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)
spanAntitone :: (k -> Bool)
-> DeepMap (k : ks) v -> (DeepMap (k : ks) v, DeepMap (k : ks) v)
spanAntitone k -> Bool
p (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> (Map k (DeepMap ks v), Map k (DeepMap ks v))
-> (DeepMap (k : ks) v, DeepMap (k : ks) v)
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest ((Map k (DeepMap ks v), Map k (DeepMap ks v))
 -> (DeepMap (k : ks) v, DeepMap (k : ks) v))
-> (Map k (DeepMap ks v), Map k (DeepMap ks v))
-> (DeepMap (k : ks) v, DeepMap (k : ks) v)
forall a b. (a -> b) -> a -> b
$ (k -> Bool)
-> Map k (DeepMap ks v)
-> (Map k (DeepMap ks v), Map k (DeepMap ks v))
forall k a. (k -> Bool) -> Map k a -> (Map k a, Map k a)
Map.spanAntitone k -> Bool
p Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /O(n)/. Map values and collect the 'Just' results.
mapMaybe :: (v -> Maybe w) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) w
mapMaybe :: (v -> Maybe w) -> DeepMap (k : ks) v -> DeepMap (k : ks) w
mapMaybe v -> Maybe w
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks w) -> DeepMap (k : ks) w
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks w) -> DeepMap (k : ks) w)
-> Map k (DeepMap ks w) -> DeepMap (k : ks) w
forall a b. (a -> b) -> a -> b
$ (DeepMap ks v -> Maybe (DeepMap ks w))
-> Map k (DeepMap ks v) -> Map k (DeepMap ks w)
forall a b k. (a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybe ((v -> Maybe w) -> DeepMap ks v -> Maybe (DeepMap ks w)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse v -> Maybe w
f) Map k (DeepMap ks v)
m

-- | /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
mapShallowMaybe :: (DeepMap ks v -> Maybe (DeepMap ls w))
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowMaybe DeepMap ks v -> Maybe (DeepMap ls w)
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ls w) -> DeepMap (k : ls) w
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ls w) -> DeepMap (k : ls) w)
-> Map k (DeepMap ls w) -> DeepMap (k : ls) w
forall a b. (a -> b) -> a -> b
$ (DeepMap ks v -> Maybe (DeepMap ls w))
-> Map k (DeepMap ks v) -> Map k (DeepMap ls w)
forall a b k. (a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybe DeepMap ks v -> Maybe (DeepMap ls w)
f Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
mapShallowMaybeWithKey :: (k -> DeepMap ks v -> Maybe (DeepMap ls w))
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowMaybeWithKey k -> DeepMap ks v -> Maybe (DeepMap ls w)
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ls w) -> DeepMap (k : ls) w
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ls w) -> DeepMap (k : ls) w)
-> Map k (DeepMap ls w) -> DeepMap (k : ls) w
forall a b. (a -> b) -> a -> b
$ (k -> DeepMap ks v -> Maybe (DeepMap ls w))
-> Map k (DeepMap ks v) -> Map k (DeepMap ls w)
forall k a b. (k -> a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybeWithKey k -> DeepMap ks v -> Maybe (DeepMap ls w)
f Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /O(n)/. Map values and collect the 'Just' results.
mapMaybeWithKey1 :: (k -> v -> Maybe w) -> DeepMap '[k] v -> DeepMap '[k] w
mapMaybeWithKey1 :: (k -> v -> Maybe w) -> DeepMap '[k] v -> DeepMap '[k] w
mapMaybeWithKey1 k -> v -> Maybe w
f = (k -> DeepMap '[] v -> Maybe (DeepMap '[] w))
-> DeepMap '[k] v -> DeepMap '[k] w
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> Maybe (DeepMap ls w))
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowMaybeWithKey (\k
k -> (w -> DeepMap '[] w) -> Maybe w -> Maybe (DeepMap '[] w)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap w -> DeepMap '[] w
forall v. v -> DeepMap '[] v
Bare (Maybe w -> Maybe (DeepMap '[] w))
-> (DeepMap '[] v -> Maybe w)
-> DeepMap '[] v
-> Maybe (DeepMap '[] w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> v -> Maybe w
f k
k (v -> Maybe w) -> (DeepMap '[] v -> v) -> DeepMap '[] v -> Maybe w
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DeepMap '[] v -> v
forall v. DeepMap '[] v -> v
getBare)

-- | /O(n)/. Map values and collect the 'Just' results.
mapMaybeWithKey2 :: (k0 -> k1 -> v -> Maybe w) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] w
mapMaybeWithKey2 :: (k0 -> k1 -> v -> Maybe w)
-> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] w
mapMaybeWithKey2 k0 -> k1 -> v -> Maybe w
f DeepMap '[k0, k1] v
m =
    let g :: k0 -> k1 -> v -> Identity (Maybe w)
g k0
k0 k1
k1 v
v = Maybe w -> Identity (Maybe w)
forall a. a -> Identity a
Identity (Maybe w -> Identity (Maybe w)) -> Maybe w -> Identity (Maybe w)
forall a b. (a -> b) -> a -> b
$ k0 -> k1 -> v -> Maybe w
f k0
k0 k1
k1 v
v
     in Identity (DeepMap '[k0, k1] w) -> DeepMap '[k0, k1] w
forall a. Identity a -> a
runIdentity (Identity (DeepMap '[k0, k1] w) -> DeepMap '[k0, k1] w)
-> Identity (DeepMap '[k0, k1] w) -> DeepMap '[k0, k1] w
forall a b. (a -> b) -> a -> b
$ (k0 -> DeepMap '[k1] v -> Identity (Maybe (DeepMap '[k1] w)))
-> DeepMap '[k0, k1] v -> Identity (DeepMap '[k0, k1] w)
forall (f :: * -> *) k (ks :: [*]) v (ls :: [*]) w.
Applicative f =>
(k -> DeepMap ks v -> f (Maybe (DeepMap ls w)))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseMaybeWithKey ((Identity (DeepMap '[k1] w) -> Identity (Maybe (DeepMap '[k1] w)))
-> (DeepMap '[k1] v -> Identity (DeepMap '[k1] w))
-> DeepMap '[k1] v
-> Identity (Maybe (DeepMap '[k1] w))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((DeepMap '[k1] w -> Maybe (DeepMap '[k1] w))
-> Identity (DeepMap '[k1] w) -> Identity (Maybe (DeepMap '[k1] w))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DeepMap '[k1] w -> Maybe (DeepMap '[k1] w)
forall a. a -> Maybe a
Just) ((DeepMap '[k1] v -> Identity (DeepMap '[k1] w))
 -> DeepMap '[k1] v -> Identity (Maybe (DeepMap '[k1] w)))
-> (k0 -> DeepMap '[k1] v -> Identity (DeepMap '[k1] w))
-> k0
-> DeepMap '[k1] v
-> Identity (Maybe (DeepMap '[k1] w))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k1 -> v -> Identity (Maybe w))
-> DeepMap '[k1] v -> Identity (DeepMap '[k1] w)
forall (f :: * -> *) k v w.
Applicative f =>
(k -> v -> f (Maybe w)) -> DeepMap '[k] v -> f (DeepMap '[k] w)
traverseMaybeWithKey1 ((k1 -> v -> Identity (Maybe w))
 -> DeepMap '[k1] v -> Identity (DeepMap '[k1] w))
-> (k0 -> k1 -> v -> Identity (Maybe w))
-> k0
-> DeepMap '[k1] v
-> Identity (DeepMap '[k1] w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> v -> Identity (Maybe w)
g) DeepMap '[k0, k1] v
m

-- | /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
mapMaybeWithKey3 :: (k0 -> k1 -> k2 -> v -> Maybe w)
-> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] w
mapMaybeWithKey3 k0 -> k1 -> k2 -> v -> Maybe w
f DeepMap '[k0, k1, k2] v
m =
    let g :: k0 -> k1 -> k2 -> v -> Identity (Maybe w)
g k0
k0 k1
k1 k2
k2 v
v = Maybe w -> Identity (Maybe w)
forall a. a -> Identity a
Identity (Maybe w -> Identity (Maybe w)) -> Maybe w -> Identity (Maybe w)
forall a b. (a -> b) -> a -> b
$ k0 -> k1 -> k2 -> v -> Maybe w
f k0
k0 k1
k1 k2
k2 v
v
     in Identity (DeepMap '[k0, k1, k2] w) -> DeepMap '[k0, k1, k2] w
forall a. Identity a -> a
runIdentity (Identity (DeepMap '[k0, k1, k2] w) -> DeepMap '[k0, k1, k2] w)
-> Identity (DeepMap '[k0, k1, k2] w) -> DeepMap '[k0, k1, k2] w
forall a b. (a -> b) -> a -> b
$ (k0
 -> DeepMap '[k1, k2] v -> Identity (Maybe (DeepMap '[k1, k2] w)))
-> DeepMap '[k0, k1, k2] v -> Identity (DeepMap '[k0, k1, k2] w)
forall (f :: * -> *) k (ks :: [*]) v (ls :: [*]) w.
Applicative f =>
(k -> DeepMap ks v -> f (Maybe (DeepMap ls w)))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseMaybeWithKey ((Identity (DeepMap '[k1, k2] w)
 -> Identity (Maybe (DeepMap '[k1, k2] w)))
-> (DeepMap '[k1, k2] v -> Identity (DeepMap '[k1, k2] w))
-> DeepMap '[k1, k2] v
-> Identity (Maybe (DeepMap '[k1, k2] w))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((DeepMap '[k1, k2] w -> Maybe (DeepMap '[k1, k2] w))
-> Identity (DeepMap '[k1, k2] w)
-> Identity (Maybe (DeepMap '[k1, k2] w))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DeepMap '[k1, k2] w -> Maybe (DeepMap '[k1, k2] w)
forall a. a -> Maybe a
Just) ((DeepMap '[k1, k2] v -> Identity (DeepMap '[k1, k2] w))
 -> DeepMap '[k1, k2] v -> Identity (Maybe (DeepMap '[k1, k2] w)))
-> (k0 -> DeepMap '[k1, k2] v -> Identity (DeepMap '[k1, k2] w))
-> k0
-> DeepMap '[k1, k2] v
-> Identity (Maybe (DeepMap '[k1, k2] w))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k1 -> k2 -> v -> Identity (Maybe w))
-> DeepMap '[k1, k2] v -> Identity (DeepMap '[k1, k2] w)
forall (f :: * -> *) k0 k1 v w.
Applicative f =>
(k0 -> k1 -> v -> f (Maybe w))
-> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] w)
traverseMaybeWithKey2 ((k1 -> k2 -> v -> Identity (Maybe w))
 -> DeepMap '[k1, k2] v -> Identity (DeepMap '[k1, k2] w))
-> (k0 -> k1 -> k2 -> v -> Identity (Maybe w))
-> k0
-> DeepMap '[k1, k2] v
-> Identity (DeepMap '[k1, k2] w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> v -> Identity (Maybe w)
g) DeepMap '[k0, k1, k2] v
m

-- | /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
mapMaybeWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> Maybe w)
-> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] w
mapMaybeWithKey4 k0 -> k1 -> k2 -> k3 -> v -> Maybe w
f DeepMap '[k0, k1, k2, k3] v
m =
    let g :: k0 -> k1 -> k2 -> k3 -> v -> Identity (Maybe w)
g k0
k0 k1
k1 k2
k2 k3
k3 v
v = Maybe w -> Identity (Maybe w)
forall a. a -> Identity a
Identity (Maybe w -> Identity (Maybe w)) -> Maybe w -> Identity (Maybe w)
forall a b. (a -> b) -> a -> b
$ k0 -> k1 -> k2 -> k3 -> v -> Maybe w
f k0
k0 k1
k1 k2
k2 k3
k3 v
v
     in Identity (DeepMap '[k0, k1, k2, k3] w)
-> DeepMap '[k0, k1, k2, k3] w
forall a. Identity a -> a
runIdentity (Identity (DeepMap '[k0, k1, k2, k3] w)
 -> DeepMap '[k0, k1, k2, k3] w)
-> Identity (DeepMap '[k0, k1, k2, k3] w)
-> DeepMap '[k0, k1, k2, k3] w
forall a b. (a -> b) -> a -> b
$ (k0
 -> DeepMap '[k1, k2, k3] v
 -> Identity (Maybe (DeepMap '[k1, k2, k3] w)))
-> DeepMap '[k0, k1, k2, k3] v
-> Identity (DeepMap '[k0, k1, k2, k3] w)
forall (f :: * -> *) k (ks :: [*]) v (ls :: [*]) w.
Applicative f =>
(k -> DeepMap ks v -> f (Maybe (DeepMap ls w)))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseMaybeWithKey ((Identity (DeepMap '[k1, k2, k3] w)
 -> Identity (Maybe (DeepMap '[k1, k2, k3] w)))
-> (DeepMap '[k1, k2, k3] v -> Identity (DeepMap '[k1, k2, k3] w))
-> DeepMap '[k1, k2, k3] v
-> Identity (Maybe (DeepMap '[k1, k2, k3] w))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((DeepMap '[k1, k2, k3] w -> Maybe (DeepMap '[k1, k2, k3] w))
-> Identity (DeepMap '[k1, k2, k3] w)
-> Identity (Maybe (DeepMap '[k1, k2, k3] w))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DeepMap '[k1, k2, k3] w -> Maybe (DeepMap '[k1, k2, k3] w)
forall a. a -> Maybe a
Just) ((DeepMap '[k1, k2, k3] v -> Identity (DeepMap '[k1, k2, k3] w))
 -> DeepMap '[k1, k2, k3] v
 -> Identity (Maybe (DeepMap '[k1, k2, k3] w)))
-> (k0
    -> DeepMap '[k1, k2, k3] v -> Identity (DeepMap '[k1, k2, k3] w))
-> k0
-> DeepMap '[k1, k2, k3] v
-> Identity (Maybe (DeepMap '[k1, k2, k3] w))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k1 -> k2 -> k3 -> v -> Identity (Maybe w))
-> DeepMap '[k1, k2, k3] v -> Identity (DeepMap '[k1, k2, k3] w)
forall (f :: * -> *) k0 k1 k2 v w.
Applicative f =>
(k0 -> k1 -> k2 -> v -> f (Maybe w))
-> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] w)
traverseMaybeWithKey3 ((k1 -> k2 -> k3 -> v -> Identity (Maybe w))
 -> DeepMap '[k1, k2, k3] v -> Identity (DeepMap '[k1, k2, k3] w))
-> (k0 -> k1 -> k2 -> k3 -> v -> Identity (Maybe w))
-> k0
-> DeepMap '[k1, k2, k3] v
-> Identity (DeepMap '[k1, k2, k3] w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> v -> Identity (Maybe w)
g) DeepMap '[k0, k1, k2, k3] v
m

-- | /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
mapMaybeWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Maybe w)
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] w
mapMaybeWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> Maybe w
f DeepMap '[k0, k1, k2, k3, k4] v
m =
    let g :: k0 -> k1 -> k2 -> k3 -> k4 -> v -> Identity (Maybe w)
g k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 v
v = Maybe w -> Identity (Maybe w)
forall a. a -> Identity a
Identity (Maybe w -> Identity (Maybe w)) -> Maybe w -> Identity (Maybe w)
forall a b. (a -> b) -> a -> b
$ k0 -> k1 -> k2 -> k3 -> k4 -> v -> Maybe w
f k0
k0 k1
k1 k2
k2 k3
k3 k4
k4 v
v
     in Identity (DeepMap '[k0, k1, k2, k3, k4] w)
-> DeepMap '[k0, k1, k2, k3, k4] w
forall a. Identity a -> a
runIdentity (Identity (DeepMap '[k0, k1, k2, k3, k4] w)
 -> DeepMap '[k0, k1, k2, k3, k4] w)
-> Identity (DeepMap '[k0, k1, k2, k3, k4] w)
-> DeepMap '[k0, k1, k2, k3, k4] w
forall a b. (a -> b) -> a -> b
$ (k0
 -> DeepMap '[k1, k2, k3, k4] v
 -> Identity (Maybe (DeepMap '[k1, k2, k3, k4] w)))
-> DeepMap '[k0, k1, k2, k3, k4] v
-> Identity (DeepMap '[k0, k1, k2, k3, k4] w)
forall (f :: * -> *) k (ks :: [*]) v (ls :: [*]) w.
Applicative f =>
(k -> DeepMap ks v -> f (Maybe (DeepMap ls w)))
-> DeepMap (k : ks) v -> f (DeepMap (k : ls) w)
traverseMaybeWithKey ((Identity (DeepMap '[k1, k2, k3, k4] w)
 -> Identity (Maybe (DeepMap '[k1, k2, k3, k4] w)))
-> (DeepMap '[k1, k2, k3, k4] v
    -> Identity (DeepMap '[k1, k2, k3, k4] w))
-> DeepMap '[k1, k2, k3, k4] v
-> Identity (Maybe (DeepMap '[k1, k2, k3, k4] w))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((DeepMap '[k1, k2, k3, k4] w
 -> Maybe (DeepMap '[k1, k2, k3, k4] w))
-> Identity (DeepMap '[k1, k2, k3, k4] w)
-> Identity (Maybe (DeepMap '[k1, k2, k3, k4] w))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DeepMap '[k1, k2, k3, k4] w -> Maybe (DeepMap '[k1, k2, k3, k4] w)
forall a. a -> Maybe a
Just) ((DeepMap '[k1, k2, k3, k4] v
  -> Identity (DeepMap '[k1, k2, k3, k4] w))
 -> DeepMap '[k1, k2, k3, k4] v
 -> Identity (Maybe (DeepMap '[k1, k2, k3, k4] w)))
-> (k0
    -> DeepMap '[k1, k2, k3, k4] v
    -> Identity (DeepMap '[k1, k2, k3, k4] w))
-> k0
-> DeepMap '[k1, k2, k3, k4] v
-> Identity (Maybe (DeepMap '[k1, k2, k3, k4] w))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k1 -> k2 -> k3 -> k4 -> v -> Identity (Maybe w))
-> DeepMap '[k1, k2, k3, k4] v
-> Identity (DeepMap '[k1, k2, k3, k4] w)
forall (f :: * -> *) k0 k1 k2 k3 v w.
Applicative f =>
(k0 -> k1 -> k2 -> k3 -> v -> f (Maybe w))
-> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] w)
traverseMaybeWithKey4 ((k1 -> k2 -> k3 -> k4 -> v -> Identity (Maybe w))
 -> DeepMap '[k1, k2, k3, k4] v
 -> Identity (DeepMap '[k1, k2, k3, k4] w))
-> (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Identity (Maybe w))
-> k0
-> DeepMap '[k1, k2, k3, k4] v
-> Identity (DeepMap '[k1, k2, k3, k4] w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> k4 -> v -> Identity (Maybe w)
g) DeepMap '[k0, k1, k2, k3, k4] v
m

-- | /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)
mapEither :: (v -> Either w x)
-> DeepMap (k : ks) v -> (DeepMap (k : ks) w, DeepMap (k : ks) x)
mapEither v -> Either w x
f DeepMap (k : ks) v
m = ((v -> Maybe w) -> DeepMap (k : ks) v -> DeepMap (k : ks) w
forall v w k (ks :: [*]).
(v -> Maybe w) -> DeepMap (k : ks) v -> DeepMap (k : ks) w
mapMaybe ((w -> Maybe w
forall a. a -> Maybe a
Just (w -> Maybe w) -> (x -> Maybe w) -> Either w x -> Maybe w
forall (a :: * -> * -> *) b d c.
ArrowChoice a =>
a b d -> a c d -> a (Either b c) d
||| Maybe w -> x -> Maybe w
forall a b. a -> b -> a
const Maybe w
forall a. Maybe a
Nothing) (Either w x -> Maybe w) -> (v -> Either w x) -> v -> Maybe w
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v -> Either w x
f) DeepMap (k : ks) v
m, (v -> Maybe x) -> DeepMap (k : ks) v -> DeepMap (k : ks) x
forall v w k (ks :: [*]).
(v -> Maybe w) -> DeepMap (k : ks) v -> DeepMap (k : ks) w
mapMaybe ((Maybe x -> w -> Maybe x
forall a b. a -> b -> a
const Maybe x
forall a. Maybe a
Nothing (w -> Maybe x) -> (x -> Maybe x) -> Either w x -> Maybe x
forall (a :: * -> * -> *) b d c.
ArrowChoice a =>
a b d -> a c d -> a (Either b c) d
||| x -> Maybe x
forall a. a -> Maybe a
Just) (Either w x -> Maybe x) -> (v -> Either w x) -> v -> Maybe x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v -> Either w x
f) DeepMap (k : ks) v
m)

-- | /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)
mapShallowEither :: (DeepMap ks v -> Either (DeepMap ls w) (DeepMap ms x))
-> DeepMap (k : ks) v -> (DeepMap (k : ls) w, DeepMap (k : ms) x)
mapShallowEither DeepMap ks v -> Either (DeepMap ls w) (DeepMap ms x)
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ls w) -> DeepMap (k : ls) w
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ls w) -> DeepMap (k : ls) w)
-> (Map k (DeepMap ms x) -> DeepMap (k : ms) x)
-> (Map k (DeepMap ls w), Map k (DeepMap ms x))
-> (DeepMap (k : ls) w, DeepMap (k : ms) x)
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** Map k (DeepMap ms x) -> DeepMap (k : ms) x
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest ((Map k (DeepMap ls w), Map k (DeepMap ms x))
 -> (DeepMap (k : ls) w, DeepMap (k : ms) x))
-> (Map k (DeepMap ls w), Map k (DeepMap ms x))
-> (DeepMap (k : ls) w, DeepMap (k : ms) x)
forall a b. (a -> b) -> a -> b
$ (DeepMap ks v -> Either (DeepMap ls w) (DeepMap ms x))
-> Map k (DeepMap ks v)
-> (Map k (DeepMap ls w), Map k (DeepMap ms x))
forall a b c k. (a -> Either b c) -> Map k a -> (Map k b, Map k c)
Map.mapEither DeepMap ks v -> Either (DeepMap ls w) (DeepMap ms x)
f Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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)
mapShallowEitherWithKey :: (k -> DeepMap ks v -> Either (DeepMap ls w) (DeepMap ms x))
-> DeepMap (k : ks) v -> (DeepMap (k : ls) w, DeepMap (k : ms) x)
mapShallowEitherWithKey k -> DeepMap ks v -> Either (DeepMap ls w) (DeepMap ms x)
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ls w) -> DeepMap (k : ls) w
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ls w) -> DeepMap (k : ls) w)
-> (Map k (DeepMap ms x) -> DeepMap (k : ms) x)
-> (Map k (DeepMap ls w), Map k (DeepMap ms x))
-> (DeepMap (k : ls) w, DeepMap (k : ms) x)
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** Map k (DeepMap ms x) -> DeepMap (k : ms) x
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest ((Map k (DeepMap ls w), Map k (DeepMap ms x))
 -> (DeepMap (k : ls) w, DeepMap (k : ms) x))
-> (Map k (DeepMap ls w), Map k (DeepMap ms x))
-> (DeepMap (k : ls) w, DeepMap (k : ms) x)
forall a b. (a -> b) -> a -> b
$ (k -> DeepMap ks v -> Either (DeepMap ls w) (DeepMap ms x))
-> Map k (DeepMap ks v)
-> (Map k (DeepMap ls w), Map k (DeepMap ms x))
forall k a b c.
(k -> a -> Either b c) -> Map k a -> (Map k b, Map k c)
Map.mapEitherWithKey k -> DeepMap ks v -> Either (DeepMap ls w) (DeepMap ms x)
f Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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)
mapEitherWithKey1 :: (k -> v -> Either w x)
-> DeepMap '[k] v -> (DeepMap '[k] w, DeepMap '[k] x)
mapEitherWithKey1 k -> v -> Either w x
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap '[] w) -> DeepMap '[k] w
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap '[] w) -> DeepMap '[k] w)
-> (Map k (DeepMap '[] x) -> DeepMap '[k] x)
-> (Map k (DeepMap '[] w), Map k (DeepMap '[] x))
-> (DeepMap '[k] w, DeepMap '[k] x)
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** Map k (DeepMap '[] x) -> DeepMap '[k] x
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest ((Map k (DeepMap '[] w), Map k (DeepMap '[] x))
 -> (DeepMap '[k] w, DeepMap '[k] x))
-> (Map k (DeepMap '[] w), Map k (DeepMap '[] x))
-> (DeepMap '[k] w, DeepMap '[k] x)
forall a b. (a -> b) -> a -> b
$ (k -> DeepMap '[] v -> Either (DeepMap '[] w) (DeepMap '[] x))
-> Map k (DeepMap '[] v)
-> (Map k (DeepMap '[] w), Map k (DeepMap '[] x))
forall k a b c.
(k -> a -> Either b c) -> Map k a -> (Map k b, Map k c)
Map.mapEitherWithKey (\k
k -> (w -> DeepMap '[] w
forall v. v -> DeepMap '[] v
Bare (w -> DeepMap '[] w)
-> (x -> DeepMap '[] x)
-> Either w x
-> Either (DeepMap '[] w) (DeepMap '[] x)
forall (a :: * -> * -> *) b c b' c'.
ArrowChoice a =>
a b c -> a b' c' -> a (Either b b') (Either c c')
+++ x -> DeepMap '[] x
forall v. v -> DeepMap '[] v
Bare) (Either w x -> Either (DeepMap '[] w) (DeepMap '[] x))
-> (DeepMap '[] v -> Either w x)
-> DeepMap '[] v
-> Either (DeepMap '[] w) (DeepMap '[] x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> v -> Either w x
f k
k (v -> Either w x)
-> (DeepMap '[] v -> v) -> DeepMap '[] v -> Either w x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DeepMap '[] v -> v
forall v. DeepMap '[] v -> v
getBare) Map k (DeepMap '[] v)
Map k (DeepMap ks v)
m

-- | /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)
mapEitherWithKey2 :: (k0 -> k1 -> v -> Either w x)
-> DeepMap '[k0, k1] v
-> (DeepMap '[k0, k1] w, DeepMap '[k0, k1] x)
mapEitherWithKey2 k0 -> k1 -> v -> Either w x
f DeepMap '[k0, k1] v
m =
    ((Either w x -> Maybe w)
-> DeepMap '[k0, k1] (Either w x) -> DeepMap '[k0, k1] w
forall v w k (ks :: [*]).
(v -> Maybe w) -> DeepMap (k : ks) v -> DeepMap (k : ks) w
mapMaybe (w -> Maybe w
forall a. a -> Maybe a
Just (w -> Maybe w) -> (x -> Maybe w) -> Either w x -> Maybe w
forall (a :: * -> * -> *) b d c.
ArrowChoice a =>
a b d -> a c d -> a (Either b c) d
||| Maybe w -> x -> Maybe w
forall a b. a -> b -> a
const Maybe w
forall a. Maybe a
Nothing) (DeepMap '[k0, k1] (Either w x) -> DeepMap '[k0, k1] w)
-> (DeepMap '[k0, k1] (Either w x) -> DeepMap '[k0, k1] x)
-> (DeepMap '[k0, k1] (Either w x), DeepMap '[k0, k1] (Either w x))
-> (DeepMap '[k0, k1] w, DeepMap '[k0, k1] x)
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** (Either w x -> Maybe x)
-> DeepMap '[k0, k1] (Either w x) -> DeepMap '[k0, k1] x
forall v w k (ks :: [*]).
(v -> Maybe w) -> DeepMap (k : ks) v -> DeepMap (k : ks) w
mapMaybe (Maybe x -> w -> Maybe x
forall a b. a -> b -> a
const Maybe x
forall a. Maybe a
Nothing (w -> Maybe x) -> (x -> Maybe x) -> Either w x -> Maybe x
forall (a :: * -> * -> *) b d c.
ArrowChoice a =>
a b d -> a c d -> a (Either b c) d
||| x -> Maybe x
forall a. a -> Maybe a
Just)) ((DeepMap '[k0, k1] (Either w x), DeepMap '[k0, k1] (Either w x))
 -> (DeepMap '[k0, k1] w, DeepMap '[k0, k1] x))
-> (DeepMap '[k0, k1] (Either w x)
    -> (DeepMap '[k0, k1] (Either w x),
        DeepMap '[k0, k1] (Either w x)))
-> DeepMap '[k0, k1] (Either w x)
-> (DeepMap '[k0, k1] w, DeepMap '[k0, k1] x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either w x -> Bool)
-> DeepMap '[k0, k1] (Either w x)
-> (DeepMap '[k0, k1] (Either w x), DeepMap '[k0, k1] (Either w x))
forall v k0 k1.
(v -> Bool)
-> DeepMap '[k0, k1] v
-> (DeepMap '[k0, k1] v, DeepMap '[k0, k1] v)
partition2 Either w x -> Bool
forall a b. Either a b -> Bool
isLeft (DeepMap '[k0, k1] (Either w x)
 -> (DeepMap '[k0, k1] w, DeepMap '[k0, k1] x))
-> DeepMap '[k0, k1] (Either w x)
-> (DeepMap '[k0, k1] w, DeepMap '[k0, k1] x)
forall a b. (a -> b) -> a -> b
$
        (k0 -> DeepMap '[k1] v -> DeepMap '[k1] (Either w x))
-> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] (Either w x)
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey (\k0
k0 -> (k1 -> DeepMap '[] v -> DeepMap '[] (Either w x))
-> DeepMap '[k1] v -> DeepMap '[k1] (Either w x)
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey ((k1 -> DeepMap '[] v -> DeepMap '[] (Either w x))
 -> DeepMap '[k1] v -> DeepMap '[k1] (Either w x))
-> (k1 -> DeepMap '[] v -> DeepMap '[] (Either w x))
-> DeepMap '[k1] v
-> DeepMap '[k1] (Either w x)
forall a b. (a -> b) -> a -> b
$ (v -> Either w x) -> DeepMap '[] v -> DeepMap '[] (Either w x)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((v -> Either w x) -> DeepMap '[] v -> DeepMap '[] (Either w x))
-> (k1 -> v -> Either w x)
-> k1
-> DeepMap '[] v
-> DeepMap '[] (Either w x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> v -> Either w x
f k0
k0) DeepMap '[k0, k1] v
m

-- | /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)
mapEitherWithKey3 :: (k0 -> k1 -> k2 -> v -> Either w x)
-> DeepMap '[k0, k1, k2] v
-> (DeepMap '[k0, k1, k2] w, DeepMap '[k0, k1, k2] x)
mapEitherWithKey3 k0 -> k1 -> k2 -> v -> Either w x
f DeepMap '[k0, k1, k2] v
m =
    ((Either w x -> Maybe w)
-> DeepMap '[k0, k1, k2] (Either w x) -> DeepMap '[k0, k1, k2] w
forall v w k (ks :: [*]).
(v -> Maybe w) -> DeepMap (k : ks) v -> DeepMap (k : ks) w
mapMaybe (w -> Maybe w
forall a. a -> Maybe a
Just (w -> Maybe w) -> (x -> Maybe w) -> Either w x -> Maybe w
forall (a :: * -> * -> *) b d c.
ArrowChoice a =>
a b d -> a c d -> a (Either b c) d
||| Maybe w -> x -> Maybe w
forall a b. a -> b -> a
const Maybe w
forall a. Maybe a
Nothing) (DeepMap '[k0, k1, k2] (Either w x) -> DeepMap '[k0, k1, k2] w)
-> (DeepMap '[k0, k1, k2] (Either w x) -> DeepMap '[k0, k1, k2] x)
-> (DeepMap '[k0, k1, k2] (Either w x),
    DeepMap '[k0, k1, k2] (Either w x))
-> (DeepMap '[k0, k1, k2] w, DeepMap '[k0, k1, k2] x)
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** (Either w x -> Maybe x)
-> DeepMap '[k0, k1, k2] (Either w x) -> DeepMap '[k0, k1, k2] x
forall v w k (ks :: [*]).
(v -> Maybe w) -> DeepMap (k : ks) v -> DeepMap (k : ks) w
mapMaybe (Maybe x -> w -> Maybe x
forall a b. a -> b -> a
const Maybe x
forall a. Maybe a
Nothing (w -> Maybe x) -> (x -> Maybe x) -> Either w x -> Maybe x
forall (a :: * -> * -> *) b d c.
ArrowChoice a =>
a b d -> a c d -> a (Either b c) d
||| x -> Maybe x
forall a. a -> Maybe a
Just)) ((DeepMap '[k0, k1, k2] (Either w x),
  DeepMap '[k0, k1, k2] (Either w x))
 -> (DeepMap '[k0, k1, k2] w, DeepMap '[k0, k1, k2] x))
-> (DeepMap '[k0, k1, k2] (Either w x)
    -> (DeepMap '[k0, k1, k2] (Either w x),
        DeepMap '[k0, k1, k2] (Either w x)))
-> DeepMap '[k0, k1, k2] (Either w x)
-> (DeepMap '[k0, k1, k2] w, DeepMap '[k0, k1, k2] x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either w x -> Bool)
-> DeepMap '[k0, k1, k2] (Either w x)
-> (DeepMap '[k0, k1, k2] (Either w x),
    DeepMap '[k0, k1, k2] (Either w x))
forall v k0 k1 k2.
(v -> Bool)
-> DeepMap '[k0, k1, k2] v
-> (DeepMap '[k0, k1, k2] v, DeepMap '[k0, k1, k2] v)
partition3 Either w x -> Bool
forall a b. Either a b -> Bool
isLeft (DeepMap '[k0, k1, k2] (Either w x)
 -> (DeepMap '[k0, k1, k2] w, DeepMap '[k0, k1, k2] x))
-> DeepMap '[k0, k1, k2] (Either w x)
-> (DeepMap '[k0, k1, k2] w, DeepMap '[k0, k1, k2] x)
forall a b. (a -> b) -> a -> b
$
        (k0 -> DeepMap '[k1, k2] v -> DeepMap '[k1, k2] (Either w x))
-> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] (Either w x)
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey
            ( \k0
k0 -> (k1 -> DeepMap '[k2] v -> DeepMap '[k2] (Either w x))
-> DeepMap '[k1, k2] v -> DeepMap '[k1, k2] (Either w x)
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey ((k1 -> DeepMap '[k2] v -> DeepMap '[k2] (Either w x))
 -> DeepMap '[k1, k2] v -> DeepMap '[k1, k2] (Either w x))
-> (k1 -> DeepMap '[k2] v -> DeepMap '[k2] (Either w x))
-> DeepMap '[k1, k2] v
-> DeepMap '[k1, k2] (Either w x)
forall a b. (a -> b) -> a -> b
$ \k1
k1 ->
                (k2 -> DeepMap '[] v -> DeepMap '[] (Either w x))
-> DeepMap '[k2] v -> DeepMap '[k2] (Either w x)
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey ((k2 -> DeepMap '[] v -> DeepMap '[] (Either w x))
 -> DeepMap '[k2] v -> DeepMap '[k2] (Either w x))
-> (k2 -> DeepMap '[] v -> DeepMap '[] (Either w x))
-> DeepMap '[k2] v
-> DeepMap '[k2] (Either w x)
forall a b. (a -> b) -> a -> b
$ (v -> Either w x) -> DeepMap '[] v -> DeepMap '[] (Either w x)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((v -> Either w x) -> DeepMap '[] v -> DeepMap '[] (Either w x))
-> (k2 -> v -> Either w x)
-> k2
-> DeepMap '[] v
-> DeepMap '[] (Either w x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> v -> Either w x
f k0
k0 k1
k1
            )
            DeepMap '[k0, k1, k2] v
m

-- | /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)
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)
mapEitherWithKey4 k0 -> k1 -> k2 -> k3 -> v -> Either w x
f DeepMap '[k0, k1, k2, k3] v
m =
    ((Either w x -> Maybe w)
-> DeepMap '[k0, k1, k2, k3] (Either w x)
-> DeepMap '[k0, k1, k2, k3] w
forall v w k (ks :: [*]).
(v -> Maybe w) -> DeepMap (k : ks) v -> DeepMap (k : ks) w
mapMaybe (w -> Maybe w
forall a. a -> Maybe a
Just (w -> Maybe w) -> (x -> Maybe w) -> Either w x -> Maybe w
forall (a :: * -> * -> *) b d c.
ArrowChoice a =>
a b d -> a c d -> a (Either b c) d
||| Maybe w -> x -> Maybe w
forall a b. a -> b -> a
const Maybe w
forall a. Maybe a
Nothing) (DeepMap '[k0, k1, k2, k3] (Either w x)
 -> DeepMap '[k0, k1, k2, k3] w)
-> (DeepMap '[k0, k1, k2, k3] (Either w x)
    -> DeepMap '[k0, k1, k2, k3] x)
-> (DeepMap '[k0, k1, k2, k3] (Either w x),
    DeepMap '[k0, k1, k2, k3] (Either w x))
-> (DeepMap '[k0, k1, k2, k3] w, DeepMap '[k0, k1, k2, k3] x)
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** (Either w x -> Maybe x)
-> DeepMap '[k0, k1, k2, k3] (Either w x)
-> DeepMap '[k0, k1, k2, k3] x
forall v w k (ks :: [*]).
(v -> Maybe w) -> DeepMap (k : ks) v -> DeepMap (k : ks) w
mapMaybe (Maybe x -> w -> Maybe x
forall a b. a -> b -> a
const Maybe x
forall a. Maybe a
Nothing (w -> Maybe x) -> (x -> Maybe x) -> Either w x -> Maybe x
forall (a :: * -> * -> *) b d c.
ArrowChoice a =>
a b d -> a c d -> a (Either b c) d
||| x -> Maybe x
forall a. a -> Maybe a
Just)) ((DeepMap '[k0, k1, k2, k3] (Either w x),
  DeepMap '[k0, k1, k2, k3] (Either w x))
 -> (DeepMap '[k0, k1, k2, k3] w, DeepMap '[k0, k1, k2, k3] x))
-> (DeepMap '[k0, k1, k2, k3] (Either w x)
    -> (DeepMap '[k0, k1, k2, k3] (Either w x),
        DeepMap '[k0, k1, k2, k3] (Either w x)))
-> DeepMap '[k0, k1, k2, k3] (Either w x)
-> (DeepMap '[k0, k1, k2, k3] w, DeepMap '[k0, k1, k2, k3] x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either w x -> Bool)
-> DeepMap '[k0, k1, k2, k3] (Either w x)
-> (DeepMap '[k0, k1, k2, k3] (Either w x),
    DeepMap '[k0, k1, k2, k3] (Either w x))
forall v k0 k1 k2 k3.
(v -> Bool)
-> DeepMap '[k0, k1, k2, k3] v
-> (DeepMap '[k0, k1, k2, k3] v, DeepMap '[k0, k1, k2, k3] v)
partition4 Either w x -> Bool
forall a b. Either a b -> Bool
isLeft (DeepMap '[k0, k1, k2, k3] (Either w x)
 -> (DeepMap '[k0, k1, k2, k3] w, DeepMap '[k0, k1, k2, k3] x))
-> DeepMap '[k0, k1, k2, k3] (Either w x)
-> (DeepMap '[k0, k1, k2, k3] w, DeepMap '[k0, k1, k2, k3] x)
forall a b. (a -> b) -> a -> b
$
        (k0
 -> DeepMap '[k1, k2, k3] v -> DeepMap '[k1, k2, k3] (Either w x))
-> DeepMap '[k0, k1, k2, k3] v
-> DeepMap '[k0, k1, k2, k3] (Either w x)
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey
            ( \k0
k0 -> (k1 -> DeepMap '[k2, k3] v -> DeepMap '[k2, k3] (Either w x))
-> DeepMap '[k1, k2, k3] v -> DeepMap '[k1, k2, k3] (Either w x)
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey ((k1 -> DeepMap '[k2, k3] v -> DeepMap '[k2, k3] (Either w x))
 -> DeepMap '[k1, k2, k3] v -> DeepMap '[k1, k2, k3] (Either w x))
-> (k1 -> DeepMap '[k2, k3] v -> DeepMap '[k2, k3] (Either w x))
-> DeepMap '[k1, k2, k3] v
-> DeepMap '[k1, k2, k3] (Either w x)
forall a b. (a -> b) -> a -> b
$ \k1
k1 ->
                (k2 -> DeepMap '[k3] v -> DeepMap '[k3] (Either w x))
-> DeepMap '[k2, k3] v -> DeepMap '[k2, k3] (Either w x)
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey ((k2 -> DeepMap '[k3] v -> DeepMap '[k3] (Either w x))
 -> DeepMap '[k2, k3] v -> DeepMap '[k2, k3] (Either w x))
-> (k2 -> DeepMap '[k3] v -> DeepMap '[k3] (Either w x))
-> DeepMap '[k2, k3] v
-> DeepMap '[k2, k3] (Either w x)
forall a b. (a -> b) -> a -> b
$ \k2
k2 ->
                    (k3 -> DeepMap '[] v -> DeepMap '[] (Either w x))
-> DeepMap '[k3] v -> DeepMap '[k3] (Either w x)
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey ((k3 -> DeepMap '[] v -> DeepMap '[] (Either w x))
 -> DeepMap '[k3] v -> DeepMap '[k3] (Either w x))
-> (k3 -> DeepMap '[] v -> DeepMap '[] (Either w x))
-> DeepMap '[k3] v
-> DeepMap '[k3] (Either w x)
forall a b. (a -> b) -> a -> b
$ (v -> Either w x) -> DeepMap '[] v -> DeepMap '[] (Either w x)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((v -> Either w x) -> DeepMap '[] v -> DeepMap '[] (Either w x))
-> (k3 -> v -> Either w x)
-> k3
-> DeepMap '[] v
-> DeepMap '[] (Either w x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> v -> Either w x
f k0
k0 k1
k1 k2
k2
            )
            DeepMap '[k0, k1, k2, k3] v
m

-- | /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)
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)
mapEitherWithKey5 k0 -> k1 -> k2 -> k3 -> k4 -> v -> Either w x
f DeepMap '[k0, k1, k2, k3, k4] v
m =
    ((Either w x -> Maybe w)
-> DeepMap '[k0, k1, k2, k3, k4] (Either w x)
-> DeepMap '[k0, k1, k2, k3, k4] w
forall v w k (ks :: [*]).
(v -> Maybe w) -> DeepMap (k : ks) v -> DeepMap (k : ks) w
mapMaybe (w -> Maybe w
forall a. a -> Maybe a
Just (w -> Maybe w) -> (x -> Maybe w) -> Either w x -> Maybe w
forall (a :: * -> * -> *) b d c.
ArrowChoice a =>
a b d -> a c d -> a (Either b c) d
||| Maybe w -> x -> Maybe w
forall a b. a -> b -> a
const Maybe w
forall a. Maybe a
Nothing) (DeepMap '[k0, k1, k2, k3, k4] (Either w x)
 -> DeepMap '[k0, k1, k2, k3, k4] w)
-> (DeepMap '[k0, k1, k2, k3, k4] (Either w x)
    -> DeepMap '[k0, k1, k2, k3, k4] x)
-> (DeepMap '[k0, k1, k2, k3, k4] (Either w x),
    DeepMap '[k0, k1, k2, k3, k4] (Either w x))
-> (DeepMap '[k0, k1, k2, k3, k4] w,
    DeepMap '[k0, k1, k2, k3, k4] x)
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** (Either w x -> Maybe x)
-> DeepMap '[k0, k1, k2, k3, k4] (Either w x)
-> DeepMap '[k0, k1, k2, k3, k4] x
forall v w k (ks :: [*]).
(v -> Maybe w) -> DeepMap (k : ks) v -> DeepMap (k : ks) w
mapMaybe (Maybe x -> w -> Maybe x
forall a b. a -> b -> a
const Maybe x
forall a. Maybe a
Nothing (w -> Maybe x) -> (x -> Maybe x) -> Either w x -> Maybe x
forall (a :: * -> * -> *) b d c.
ArrowChoice a =>
a b d -> a c d -> a (Either b c) d
||| x -> Maybe x
forall a. a -> Maybe a
Just)) ((DeepMap '[k0, k1, k2, k3, k4] (Either w x),
  DeepMap '[k0, k1, k2, k3, k4] (Either w x))
 -> (DeepMap '[k0, k1, k2, k3, k4] w,
     DeepMap '[k0, k1, k2, k3, k4] x))
-> (DeepMap '[k0, k1, k2, k3, k4] (Either w x)
    -> (DeepMap '[k0, k1, k2, k3, k4] (Either w x),
        DeepMap '[k0, k1, k2, k3, k4] (Either w x)))
-> DeepMap '[k0, k1, k2, k3, k4] (Either w x)
-> (DeepMap '[k0, k1, k2, k3, k4] w,
    DeepMap '[k0, k1, k2, k3, k4] x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either w x -> Bool)
-> DeepMap '[k0, k1, k2, k3, k4] (Either w x)
-> (DeepMap '[k0, k1, k2, k3, k4] (Either w x),
    DeepMap '[k0, k1, k2, k3, k4] (Either w x))
forall v 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)
partition5 Either w x -> Bool
forall a b. Either a b -> Bool
isLeft (DeepMap '[k0, k1, k2, k3, k4] (Either w x)
 -> (DeepMap '[k0, k1, k2, k3, k4] w,
     DeepMap '[k0, k1, k2, k3, k4] x))
-> DeepMap '[k0, k1, k2, k3, k4] (Either w x)
-> (DeepMap '[k0, k1, k2, k3, k4] w,
    DeepMap '[k0, k1, k2, k3, k4] x)
forall a b. (a -> b) -> a -> b
$
        (k0
 -> DeepMap '[k1, k2, k3, k4] v
 -> DeepMap '[k1, k2, k3, k4] (Either w x))
-> DeepMap '[k0, k1, k2, k3, k4] v
-> DeepMap '[k0, k1, k2, k3, k4] (Either w x)
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey
            ( \k0
k0 -> (k1
 -> DeepMap '[k2, k3, k4] v -> DeepMap '[k2, k3, k4] (Either w x))
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] (Either w x)
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey ((k1
  -> DeepMap '[k2, k3, k4] v -> DeepMap '[k2, k3, k4] (Either w x))
 -> DeepMap '[k1, k2, k3, k4] v
 -> DeepMap '[k1, k2, k3, k4] (Either w x))
-> (k1
    -> DeepMap '[k2, k3, k4] v -> DeepMap '[k2, k3, k4] (Either w x))
-> DeepMap '[k1, k2, k3, k4] v
-> DeepMap '[k1, k2, k3, k4] (Either w x)
forall a b. (a -> b) -> a -> b
$ \k1
k1 ->
                (k2 -> DeepMap '[k3, k4] v -> DeepMap '[k3, k4] (Either w x))
-> DeepMap '[k2, k3, k4] v -> DeepMap '[k2, k3, k4] (Either w x)
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey ((k2 -> DeepMap '[k3, k4] v -> DeepMap '[k3, k4] (Either w x))
 -> DeepMap '[k2, k3, k4] v -> DeepMap '[k2, k3, k4] (Either w x))
-> (k2 -> DeepMap '[k3, k4] v -> DeepMap '[k3, k4] (Either w x))
-> DeepMap '[k2, k3, k4] v
-> DeepMap '[k2, k3, k4] (Either w x)
forall a b. (a -> b) -> a -> b
$ \k2
k2 ->
                    (k3 -> DeepMap '[k4] v -> DeepMap '[k4] (Either w x))
-> DeepMap '[k3, k4] v -> DeepMap '[k3, k4] (Either w x)
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey ((k3 -> DeepMap '[k4] v -> DeepMap '[k4] (Either w x))
 -> DeepMap '[k3, k4] v -> DeepMap '[k3, k4] (Either w x))
-> (k3 -> DeepMap '[k4] v -> DeepMap '[k4] (Either w x))
-> DeepMap '[k3, k4] v
-> DeepMap '[k3, k4] (Either w x)
forall a b. (a -> b) -> a -> b
$ \k3
k3 ->
                        (k4 -> DeepMap '[] v -> DeepMap '[] (Either w x))
-> DeepMap '[k4] v -> DeepMap '[k4] (Either w x)
forall k (ks :: [*]) v (ls :: [*]) w.
(k -> DeepMap ks v -> DeepMap ls w)
-> DeepMap (k : ks) v -> DeepMap (k : ls) w
mapShallowWithKey ((k4 -> DeepMap '[] v -> DeepMap '[] (Either w x))
 -> DeepMap '[k4] v -> DeepMap '[k4] (Either w x))
-> (k4 -> DeepMap '[] v -> DeepMap '[] (Either w x))
-> DeepMap '[k4] v
-> DeepMap '[k4] (Either w x)
forall a b. (a -> b) -> a -> b
$ (v -> Either w x) -> DeepMap '[] v -> DeepMap '[] (Either w x)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((v -> Either w x) -> DeepMap '[] v -> DeepMap '[] (Either w x))
-> (k4 -> v -> Either w x)
-> k4
-> DeepMap '[] v
-> DeepMap '[] (Either w x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k0 -> k1 -> k2 -> k3 -> k4 -> v -> Either w x
f k0
k0 k1
k1 k2
k2 k3
k3
            )
            DeepMap '[k0, k1, k2, k3, k4] v
m

-- | /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)
split :: k -> DeepMap (k : ks) v -> (DeepMap (k : ks) v, DeepMap (k : ks) v)
split k
k (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> (Map k (DeepMap ks v), Map k (DeepMap ks v))
-> (DeepMap (k : ks) v, DeepMap (k : ks) v)
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest ((Map k (DeepMap ks v), Map k (DeepMap ks v))
 -> (DeepMap (k : ks) v, DeepMap (k : ks) v))
-> (Map k (DeepMap ks v), Map k (DeepMap ks v))
-> (DeepMap (k : ks) v, DeepMap (k : ks) v)
forall a b. (a -> b) -> a -> b
$ k
-> Map k (DeepMap ks v)
-> (Map k (DeepMap ks v), Map k (DeepMap ks v))
forall k a. Ord k => k -> Map k a -> (Map k a, Map k a)
Map.split k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /O(log n)/. Like 'split' but the middle coordinate 'lookup's 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)
splitLookup :: k
-> DeepMap (k : ks) v
-> (DeepMap (k : ks) v, Maybe (DeepMap ks v), DeepMap (k : ks) v)
splitLookup k
k (Nest Map k (DeepMap ks v)
m) = (\(Map k (DeepMap ks v)
n, Maybe (DeepMap ks v)
y, Map k (DeepMap ks v)
p) -> (Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest Map k (DeepMap ks v)
n, Maybe (DeepMap ks v)
y, Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest Map k (DeepMap ks v)
p)) ((Map k (DeepMap ks v), Maybe (DeepMap ks v), Map k (DeepMap ks v))
 -> (DeepMap (k : ks) v, Maybe (DeepMap ks v), DeepMap (k : ks) v))
-> (Map k (DeepMap ks v), Maybe (DeepMap ks v),
    Map k (DeepMap ks v))
-> (DeepMap (k : ks) v, Maybe (DeepMap ks v), DeepMap (k : ks) v)
forall a b. (a -> b) -> a -> b
$ k
-> Map k (DeepMap ks v)
-> (Map k (DeepMap ks v), Maybe (DeepMap ks v),
    Map k (DeepMap ks v))
forall k a. Ord k => k -> Map k a -> (Map k a, Maybe a, Map k a)
Map.splitLookup k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /O(1)/. Decompose a map into pieces based on the structure of the underlying tree.
splitRoot :: DeepMap (k ': ks) v -> [DeepMap (k ': ks) v]
splitRoot :: DeepMap (k : ks) v -> [DeepMap (k : ks) v]
splitRoot (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> [Map k (DeepMap ks v)] -> [DeepMap (k : ks) v]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map k (DeepMap ks v) -> [Map k (DeepMap ks v)]
forall k b. Map k b -> [Map k b]
Map.splitRoot Map k (DeepMap ks v)
m

-- | /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
isSubmapOf :: DeepMap (k : ks) v -> DeepMap (k : ks) v -> Bool
isSubmapOf (Nest Map k (DeepMap ks v)
m) (Nest Map k (DeepMap ks v)
n) = Map k (DeepMap ks v) -> Map k (DeepMap ks v) -> Bool
forall k a. (Ord k, Eq a) => Map k a -> Map k a -> Bool
Map.isSubmapOf Map k (DeepMap ks v)
m Map k (DeepMap ks v)
Map k (DeepMap ks v)
n

-- | /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
isSubmapOfBy :: (DeepMap ks v -> DeepMap ks v -> Bool)
-> DeepMap (k : ks) v -> DeepMap (k : ks) v -> Bool
isSubmapOfBy DeepMap ks v -> DeepMap ks v -> Bool
f (Nest Map k (DeepMap ks v)
m) (Nest Map k (DeepMap ks v)
n) = (DeepMap ks v -> DeepMap ks v -> Bool)
-> Map k (DeepMap ks v) -> Map k (DeepMap ks v) -> Bool
forall k a b.
Ord k =>
(a -> b -> Bool) -> Map k a -> Map k b -> Bool
Map.isSubmapOfBy DeepMap ks v -> DeepMap ks v -> Bool
f Map k (DeepMap ks v)
Map k (DeepMap ks v)
m Map k (DeepMap ks v)
Map k (DeepMap ks v)
n

-- | /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
isProperSubmapOf :: DeepMap (k : ks) v -> DeepMap (k : ks) v -> Bool
isProperSubmapOf (Nest Map k (DeepMap ks v)
m) (Nest Map k (DeepMap ks v)
n) = Map k (DeepMap ks v) -> Map k (DeepMap ks v) -> Bool
forall k a. (Ord k, Eq a) => Map k a -> Map k a -> Bool
Map.isProperSubmapOf Map k (DeepMap ks v)
m Map k (DeepMap ks v)
Map k (DeepMap ks v)
n

-- | /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
isProperSubmapOfBy :: (DeepMap ks v -> DeepMap ks v -> Bool)
-> DeepMap (k : ks) v -> DeepMap (k : ks) v -> Bool
isProperSubmapOfBy DeepMap ks v -> DeepMap ks v -> Bool
f (Nest Map k (DeepMap ks v)
m) (Nest Map k (DeepMap ks v)
n) = (DeepMap ks v -> DeepMap ks v -> Bool)
-> Map k (DeepMap ks v) -> Map k (DeepMap ks v) -> Bool
forall k a b.
Ord k =>
(a -> b -> Bool) -> Map k a -> Map k b -> Bool
Map.isProperSubmapOfBy DeepMap ks v -> DeepMap ks v -> Bool
f Map k (DeepMap ks v)
Map k (DeepMap ks v)
m Map k (DeepMap ks v)
Map k (DeepMap ks v)
n

-- | /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
lookupIndex :: k -> DeepMap (k : ks) v -> Maybe Int
lookupIndex k
k (Nest Map k (DeepMap ks v)
m) = k -> Map k (DeepMap ks v) -> Maybe Int
forall k a. Ord k => k -> Map k a -> Maybe Int
Map.lookupIndex k
k Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
findIndex :: k -> DeepMap (k : ks) v -> Int
findIndex k
i (Nest Map k (DeepMap ks v)
m) = k -> Map k (DeepMap ks v) -> Int
forall k a. Ord k => k -> Map k a -> Int
Map.findIndex k
i Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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)
elemAt :: Int -> DeepMap (k : ks) v -> (k, DeepMap ks v)
elemAt Int
i (Nest Map k (DeepMap ks v)
m) = Int -> Map k (DeepMap ks v) -> (k, DeepMap ks v)
forall k a. Int -> Map k a -> (k, a)
Map.elemAt Int
i Map k (DeepMap ks v)
m

-- | /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
updateAt :: (k -> DeepMap ks v -> Maybe (DeepMap ks v))
-> Int -> DeepMap (k : ks) v -> DeepMap (k : ks) v
updateAt k -> DeepMap ks v -> Maybe (DeepMap ks v)
f Int
i (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (k -> DeepMap ks v -> Maybe (DeepMap ks v))
-> Int -> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall k a. (k -> a -> Maybe a) -> Int -> Map k a -> Map k a
Map.updateAt k -> DeepMap ks v -> Maybe (DeepMap ks v)
f Int
i Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
deleteAt :: (k -> DeepMap ks v -> Maybe (DeepMap ks v))
-> Int -> DeepMap (k : ks) v -> DeepMap (k : ks) v
deleteAt k -> DeepMap ks v -> Maybe (DeepMap ks v)
f Int
i (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (k -> DeepMap ks v -> Maybe (DeepMap ks v))
-> Int -> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall k a. (k -> a -> Maybe a) -> Int -> Map k a -> Map k a
Map.updateAt k -> DeepMap ks v -> Maybe (DeepMap ks v)
f Int
i Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | Take the smallest @n@ keys.
take :: Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
take :: Int -> DeepMap (k : ks) v -> DeepMap (k : ks) v
take Int
n (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ Int -> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall k a. Int -> Map k a -> Map k a
Map.take Int
n Map k (DeepMap ks v)
m

-- | Drop the smallest @n@ keys.
drop :: Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
drop :: Int -> DeepMap (k : ks) v -> DeepMap (k : ks) v
drop Int
n (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ Int -> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall k a. Int -> Map k a -> Map k a
Map.take Int
n Map k (DeepMap ks v)
m

-- | /O(n)/. Split a map at a particular index.
splitAt :: Int -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)
splitAt :: Int
-> DeepMap (k : ks) v -> (DeepMap (k : ks) v, DeepMap (k : ks) v)
splitAt Int
i (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> (Map k (DeepMap ks v), Map k (DeepMap ks v))
-> (DeepMap (k : ks) v, DeepMap (k : ks) v)
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest ((Map k (DeepMap ks v), Map k (DeepMap ks v))
 -> (DeepMap (k : ks) v, DeepMap (k : ks) v))
-> (Map k (DeepMap ks v), Map k (DeepMap ks v))
-> (DeepMap (k : ks) v, DeepMap (k : ks) v)
forall a b. (a -> b) -> a -> b
$ Int
-> Map k (DeepMap ks v)
-> (Map k (DeepMap ks v), Map k (DeepMap ks v))
forall k a. Int -> Map k a -> (Map k a, Map k a)
Map.splitAt Int
i Map k (DeepMap ks v)
m

-- | /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)
lookupMin :: DeepMap (k : ks) v -> Maybe (k, DeepMap ks v)
lookupMin (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> Maybe (k, DeepMap ks v)
forall k a. Map k a -> Maybe (k, a)
Map.lookupMin Map k (DeepMap ks v)
m

-- | /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)
lookupMax :: DeepMap (k : ks) v -> Maybe (k, DeepMap ks v)
lookupMax (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> Maybe (k, DeepMap ks v)
forall k a. Map k a -> Maybe (k, a)
Map.lookupMax Map k (DeepMap ks v)
m

-- | /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)
findMin :: DeepMap (k : ks) v -> (k, DeepMap ks v)
findMin (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> (k, DeepMap ks v)
forall k a. Map k a -> (k, a)
Map.findMin Map k (DeepMap ks v)
m

-- | /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)
findMax :: DeepMap (k : ks) v -> (k, DeepMap ks v)
findMax (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> (k, DeepMap ks v)
forall k a. Map k a -> (k, a)
Map.findMax Map k (DeepMap ks v)
m

-- | /O(log n)/. Delete the minimal key.
deleteMin :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v
deleteMin :: DeepMap (k : ks) v -> DeepMap (k : ks) v
deleteMin (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall k a. Map k a -> Map k a
Map.deleteMin Map k (DeepMap ks v)
m

-- | /O(log n)/. Delete the maximal key.
deleteMax :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v
deleteMax :: DeepMap (k : ks) v -> DeepMap (k : ks) v
deleteMax (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall k a. Map k a -> Map k a
Map.deleteMax Map k (DeepMap ks v)
m

-- | /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)
deleteFindMin :: DeepMap (k : ks) v -> ((k, DeepMap ks v), DeepMap (k : ks) v)
deleteFindMin (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> ((k, DeepMap ks v), Map k (DeepMap ks v))
-> ((k, DeepMap ks v), DeepMap (k : ks) v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map k (DeepMap ks v) -> ((k, DeepMap ks v), Map k (DeepMap ks v))
forall k a. Map k a -> ((k, a), Map k a)
Map.deleteFindMin Map k (DeepMap ks v)
m

-- | /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)
deleteFindMax :: DeepMap (k : ks) v -> ((k, DeepMap ks v), DeepMap (k : ks) v)
deleteFindMax (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> ((k, DeepMap ks v), Map k (DeepMap ks v))
-> ((k, DeepMap ks v), DeepMap (k : ks) v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map k (DeepMap ks v) -> ((k, DeepMap ks v), Map k (DeepMap ks v))
forall k a. Map k a -> ((k, a), Map k a)
Map.deleteFindMax Map k (DeepMap ks v)
m

-- | /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
updateMin :: (DeepMap ks v -> Maybe (DeepMap ks v))
-> DeepMap (k : ks) v -> DeepMap (k : ks) v
updateMin DeepMap ks v -> Maybe (DeepMap ks v)
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (DeepMap ks v -> Maybe (DeepMap ks v))
-> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall a k. (a -> Maybe a) -> Map k a -> Map k a
Map.updateMin DeepMap ks v -> Maybe (DeepMap ks v)
f Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
updateMax :: (DeepMap ks v -> Maybe (DeepMap ks v))
-> DeepMap (k : ks) v -> DeepMap (k : ks) v
updateMax DeepMap ks v -> Maybe (DeepMap ks v)
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (DeepMap ks v -> Maybe (DeepMap ks v))
-> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall a k. (a -> Maybe a) -> Map k a -> Map k a
Map.updateMax DeepMap ks v -> Maybe (DeepMap ks v)
f Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
updateMinWithKey :: (k -> DeepMap ks v -> Maybe (DeepMap ks v))
-> DeepMap (k : ks) v -> DeepMap (k : ks) v
updateMinWithKey k -> DeepMap ks v -> Maybe (DeepMap ks v)
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (k -> DeepMap ks v -> Maybe (DeepMap ks v))
-> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall k a. (k -> a -> Maybe a) -> Map k a -> Map k a
Map.updateMinWithKey k -> DeepMap ks v -> Maybe (DeepMap ks v)
f Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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
updateMaxWithKey :: (k -> DeepMap ks v -> Maybe (DeepMap ks v))
-> DeepMap (k : ks) v -> DeepMap (k : ks) v
updateMaxWithKey k -> DeepMap ks v -> Maybe (DeepMap ks v)
f (Nest Map k (DeepMap ks v)
m) = Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall a b. (a -> b) -> a -> b
$ (k -> DeepMap ks v -> Maybe (DeepMap ks v))
-> Map k (DeepMap ks v) -> Map k (DeepMap ks v)
forall k a. (k -> a -> Maybe a) -> Map k a -> Map k a
Map.updateMaxWithKey k -> DeepMap ks v -> Maybe (DeepMap ks v)
f Map k (DeepMap ks v)
Map k (DeepMap ks v)
m

-- | /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)
minView :: DeepMap (k : ks) v -> Maybe (DeepMap ks v, DeepMap (k : ks) v)
minView (Nest Map k (DeepMap ks v)
m) = (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> (DeepMap ks v, Map k (DeepMap ks v))
-> (DeepMap ks v, DeepMap (k : ks) v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest ((DeepMap ks v, Map k (DeepMap ks v))
 -> (DeepMap ks v, DeepMap (k : ks) v))
-> Maybe (DeepMap ks v, Map k (DeepMap ks v))
-> Maybe (DeepMap ks v, DeepMap (k : ks) v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map k (DeepMap ks v) -> Maybe (DeepMap ks v, Map k (DeepMap ks v))
forall k a. Map k a -> Maybe (a, Map k a)
Map.minView Map k (DeepMap ks v)
m

-- | /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)
maxView :: DeepMap (k : ks) v -> Maybe (DeepMap ks v, DeepMap (k : ks) v)
maxView (Nest Map k (DeepMap ks v)
m) = (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> (DeepMap ks v, Map k (DeepMap ks v))
-> (DeepMap ks v, DeepMap (k : ks) v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest ((DeepMap ks v, Map k (DeepMap ks v))
 -> (DeepMap ks v, DeepMap (k : ks) v))
-> Maybe (DeepMap ks v, Map k (DeepMap ks v))
-> Maybe (DeepMap ks v, DeepMap (k : ks) v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map k (DeepMap ks v) -> Maybe (DeepMap ks v, Map k (DeepMap ks v))
forall k a. Map k a -> Maybe (a, Map k a)
Map.maxView Map k (DeepMap ks v)
m

-- | /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)
minViewWithKey :: DeepMap (k : ks) v -> Maybe ((k, DeepMap ks v), DeepMap (k : ks) v)
minViewWithKey (Nest Map k (DeepMap ks v)
m) = (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> ((k, DeepMap ks v), Map k (DeepMap ks v))
-> ((k, DeepMap ks v), DeepMap (k : ks) v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (((k, DeepMap ks v), Map k (DeepMap ks v))
 -> ((k, DeepMap ks v), DeepMap (k : ks) v))
-> Maybe ((k, DeepMap ks v), Map k (DeepMap ks v))
-> Maybe ((k, DeepMap ks v), DeepMap (k : ks) v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map k (DeepMap ks v)
-> Maybe ((k, DeepMap ks v), Map k (DeepMap ks v))
forall k a. Map k a -> Maybe ((k, a), Map k a)
Map.minViewWithKey Map k (DeepMap ks v)
m

-- | /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)
maxViewWithKey :: DeepMap (k : ks) v -> Maybe ((k, DeepMap ks v), DeepMap (k : ks) v)
maxViewWithKey (Nest Map k (DeepMap ks v)
m) = (Map k (DeepMap ks v) -> DeepMap (k : ks) v)
-> ((k, DeepMap ks v), Map k (DeepMap ks v))
-> ((k, DeepMap ks v), DeepMap (k : ks) v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Map k (DeepMap ks v) -> DeepMap (k : ks) v
forall k (ks :: [*]) v. Map k (DeepMap ks v) -> DeepMap (k : ks) v
Nest (((k, DeepMap ks v), Map k (DeepMap ks v))
 -> ((k, DeepMap ks v), DeepMap (k : ks) v))
-> Maybe ((k, DeepMap ks v), Map k (DeepMap ks v))
-> Maybe ((k, DeepMap ks v), DeepMap (k : ks) v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map k (DeepMap ks v)
-> Maybe ((k, DeepMap ks v), Map k (DeepMap ks v))
forall k a. Map k a -> Maybe ((k, a), Map k a)
Map.maxViewWithKey Map k (DeepMap ks v)
m

-- | "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
invertKeys :: DeepMap (j : k : ks) v -> DeepMap (k : j : ks) v
invertKeys DeepMap (j : k : ks) v
m = [DeepMap (k : j : ks) v] -> DeepMap (k : j : ks) v
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold [k
k k -> DeepMap (j : ks) v -> DeepMap (k : j : ks) v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> j
j j -> DeepMap ks v -> DeepMap (j : ks) v
forall k (ks :: [*]) v. k -> DeepMap ks v -> DeepMap (k : ks) v
@> DeepMap ks v
mv | (j
j, DeepMap (k : ks) v
mk) <- DeepMap (j : k : ks) v -> [(j, DeepMap (k : ks) v)]
forall k (ks :: [*]) v. DeepMap (k : ks) v -> [(k, DeepMap ks v)]
assocs DeepMap (j : k : ks) v
m, (k
k, DeepMap ks v
mv) <- DeepMap (k : ks) v -> [(k, DeepMap ks v)]
forall k (ks :: [*]) v. DeepMap (k : ks) v -> [(k, DeepMap ks v)]
assocs DeepMap (k : ks) v
mk]