Data.Map.Deep

This module defines a deeply-nested, semigroup-lifting map datatype, whose keys are indexed by a type-level list.

Its interface is intended to mimic that of Map from the containers package, with additional convenience functions for working with deep nestings.

Map type

data DeepMap (ks :: [Type]) (v :: Type) :: Type where

Constructors

Bare

Fields

• :: { getBare :: v
•    } -> DeepMap '[] v

Nest

Fields

• :: { getNest :: Map k (DeepMap ks v)
•    } -> DeepMap (k ': ks) v

Instances

FunctorWithIndex () (DeepMap ('[] :: [Type]))

Defined in Data.Map.Deep

Methods

imap :: (() -> a -> b) -> DeepMap '[] a -> DeepMap '[] b

FoldableWithIndex () (DeepMap ('[] :: [Type]))

Defined in Data.Map.Deep

Methods

ifoldMap :: Monoid m => (() -> a -> m) -> DeepMap '[] a -> m

ifoldMap' :: Monoid m => (() -> a -> m) -> DeepMap '[] a -> m

ifoldr :: (() -> a -> b -> b) -> b -> DeepMap '[] a -> b

ifoldl :: (() -> b -> a -> b) -> b -> DeepMap '[] a -> b

ifoldr' :: (() -> a -> b -> b) -> b -> DeepMap '[] a -> b

ifoldl' :: (() -> b -> a -> b) -> b -> DeepMap '[] a -> b

TraversableWithIndex () (DeepMap ('[] :: [Type]))

Defined in Data.Map.Deep

Methods

itraverse :: Applicative f => (() -> a -> f b) -> DeepMap '[] a -> f (DeepMap '[] b)

Functor (DeepMap ks)

Defined in Data.Map.Deep

Methods

fmap :: (a -> b) -> DeepMap ks a -> DeepMap ks b

(<$) :: a -> DeepMap ks b -> DeepMap ks a

Foldable (DeepMap ks)

Defined in Data.Map.Deep

Methods

fold :: Monoid m => DeepMap ks m -> m

foldMap :: Monoid m => (a -> m) -> DeepMap ks a -> m

foldMap' :: Monoid m => (a -> m) -> DeepMap ks a -> m

foldr :: (a -> b -> b) -> b -> DeepMap ks a -> b

foldr' :: (a -> b -> b) -> b -> DeepMap ks a -> b

foldl :: (b -> a -> b) -> b -> DeepMap ks a -> b

foldl' :: (b -> a -> b) -> b -> DeepMap ks a -> b

foldr1 :: (a -> a -> a) -> DeepMap ks a -> a

foldl1 :: (a -> a -> a) -> DeepMap ks a -> a

toList :: DeepMap ks a -> [a]

null :: DeepMap ks a -> Bool

length :: DeepMap ks a -> Int

elem :: Eq a => a -> DeepMap ks a -> Bool

maximum :: Ord a => DeepMap ks a -> a

minimum :: Ord a => DeepMap ks a -> a

sum :: Num a => DeepMap ks a -> a

product :: Num a => DeepMap ks a -> a

Traversable (DeepMap ks)

Defined in Data.Map.Deep

Methods

traverse :: Applicative f => (a -> f b) -> DeepMap ks a -> f (DeepMap ks b)

sequenceA :: Applicative f => DeepMap ks (f a) -> f (DeepMap ks a)

mapM :: Monad m => (a -> m b) -> DeepMap ks a -> m (DeepMap ks b)

sequence :: Monad m => DeepMap ks (m a) -> m (DeepMap ks a)

(Eq k, Eq (DeepMap ks v)) => Eq (DeepMap (k ': ks) v)

Defined in Data.Map.Deep

Methods

(==) :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool

(/=) :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool

Eq v => Eq (DeepMap ('[] :: [Type]) v)

Defined in Data.Map.Deep

Methods

(==) :: DeepMap '[] v -> DeepMap '[] v -> Bool

(/=) :: DeepMap '[] v -> DeepMap '[] v -> Bool

(Ord k, Data k, Typeable ks, Typeable v, Data (DeepMap ks v)) => Data (DeepMap (k ': ks) v)

Defined in Data.Map.Deep

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DeepMap (k ': ks) v -> c (DeepMap (k ': ks) v)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DeepMap (k ': ks) v)

toConstr :: DeepMap (k ': ks) v -> Constr

dataTypeOf :: DeepMap (k ': ks) v -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DeepMap (k ': ks) v))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DeepMap (k ': ks) v))

gmapT :: (forall b. Data b => b -> b) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DeepMap (k ': ks) v -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DeepMap (k ': ks) v -> r

gmapQ :: (forall d. Data d => d -> u) -> DeepMap (k ': ks) v -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DeepMap (k ': ks) v -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DeepMap (k ': ks) v -> m (DeepMap (k ': ks) v)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DeepMap (k ': ks) v -> m (DeepMap (k ': ks) v)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DeepMap (k ': ks) v -> m (DeepMap (k ': ks) v)

Data v => Data (DeepMap ('[] :: [Type]) v)

Defined in Data.Map.Deep

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DeepMap '[] v -> c (DeepMap '[] v)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DeepMap '[] v)

toConstr :: DeepMap '[] v -> Constr

dataTypeOf :: DeepMap '[] v -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DeepMap '[] v))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DeepMap '[] v))

gmapT :: (forall b. Data b => b -> b) -> DeepMap '[] v -> DeepMap '[] v

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DeepMap '[] v -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DeepMap '[] v -> r

gmapQ :: (forall d. Data d => d -> u) -> DeepMap '[] v -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DeepMap '[] v -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DeepMap '[] v -> m (DeepMap '[] v)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DeepMap '[] v -> m (DeepMap '[] v)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DeepMap '[] v -> m (DeepMap '[] v)

(Ord k, Ord (DeepMap ks v)) => Ord (DeepMap (k ': ks) v)

Defined in Data.Map.Deep

Methods

compare :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Ordering

(<) :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool

(<=) :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool

(>) :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool

(>=) :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool

max :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

min :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

Ord v => Ord (DeepMap ('[] :: [Type]) v)

Defined in Data.Map.Deep

Methods

compare :: DeepMap '[] v -> DeepMap '[] v -> Ordering

(<) :: DeepMap '[] v -> DeepMap '[] v -> Bool

(<=) :: DeepMap '[] v -> DeepMap '[] v -> Bool

(>) :: DeepMap '[] v -> DeepMap '[] v -> Bool

(>=) :: DeepMap '[] v -> DeepMap '[] v -> Bool

max :: DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v

min :: DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v

(Show k, Show (DeepMap ks v)) => Show (DeepMap (k ': ks) v)

Defined in Data.Map.Deep

Methods

showsPrec :: Int -> DeepMap (k ': ks) v -> ShowS

show :: DeepMap (k ': ks) v -> String

showList :: [DeepMap (k ': ks) v] -> ShowS

Show v => Show (DeepMap ('[] :: [Type]) v)

Defined in Data.Map.Deep

Methods

showsPrec :: Int -> DeepMap '[] v -> ShowS

show :: DeepMap '[] v -> String

showList :: [DeepMap '[] v] -> ShowS

(Ord k, Generic k, Generic (DeepMap ks v)) => Generic (DeepMap (k ': ks) v)

Defined in Data.Map.Deep

Associated Types

type Rep (DeepMap (k ': ks) v) :: Type -> Type

Methods

from :: DeepMap (k ': ks) v -> Rep (DeepMap (k ': ks) v) x

to :: Rep (DeepMap (k ': ks) v) x -> DeepMap (k ': ks) v

Generic v => Generic (DeepMap ('[] :: [Type]) v)

Defined in Data.Map.Deep

Associated Types

type Rep (DeepMap '[] v) :: Type -> Type

Methods

from :: DeepMap '[] v -> Rep (DeepMap '[] v) x

to :: Rep (DeepMap '[] v) x -> DeepMap '[] v

(Ord k, Semigroup (DeepMap ks v)) => Semigroup (DeepMap (k ': ks) v)

Defined in Data.Map.Deep

Methods

(<>) :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

sconcat :: NonEmpty (DeepMap (k ': ks) v) -> DeepMap (k ': ks) v

stimes :: Integral b => b -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

Semigroup v => Semigroup (DeepMap ('[] :: [Type]) v)

Defined in Data.Map.Deep

Methods

(<>) :: DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v

sconcat :: NonEmpty (DeepMap '[] v) -> DeepMap '[] v

stimes :: Integral b => b -> DeepMap '[] v -> DeepMap '[] v

(Ord k, Semigroup (DeepMap ks v)) => Monoid (DeepMap (k ': ks) v)

Defined in Data.Map.Deep

Methods

mempty :: DeepMap (k ': ks) v

mappend :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

mconcat :: [DeepMap (k ': ks) v] -> DeepMap (k ': ks) v

Monoid v => Monoid (DeepMap ('[] :: [Type]) v)

Defined in Data.Map.Deep

Methods

mempty :: DeepMap '[] v

mappend :: DeepMap '[] v -> DeepMap '[] v -> DeepMap '[] v

mconcat :: [DeepMap '[] v] -> DeepMap '[] v

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

Defined in Data.Map.Deep

Methods

imap :: ((k, ki) -> a -> b) -> DeepMap (k ': ks) a -> DeepMap (k ': ks) b

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

Defined in Data.Map.Deep

Methods

ifoldMap :: Monoid m => ((k, ki) -> a -> m) -> DeepMap (k ': ks) a -> m

ifoldMap' :: Monoid m => ((k, ki) -> a -> m) -> DeepMap (k ': ks) a -> m

ifoldr :: ((k, ki) -> a -> b -> b) -> b -> DeepMap (k ': ks) a -> b

ifoldl :: ((k, ki) -> b -> a -> b) -> b -> DeepMap (k ': ks) a -> b

ifoldr' :: ((k, ki) -> a -> b -> b) -> b -> DeepMap (k ': ks) a -> b

ifoldl' :: ((k, ki) -> b -> a -> b) -> b -> DeepMap (k ': ks) a -> b

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

Defined in Data.Map.Deep

Methods

itraverse :: Applicative f => ((k, ki) -> a -> f b) -> DeepMap (k ': ks) a -> f (DeepMap (k ': ks) b)

type Rep (DeepMap (k ': ks) v)

Defined in Data.Map.Deep

type Rep (DeepMap (k ': ks) v) = Compose [] ((Const k :: Type -> Type) :*: Rep (DeepMap ks v))

type Rep (DeepMap ('[] :: [Type]) v)

Defined in Data.Map.Deep

type Rep (DeepMap ('[] :: [Type]) v) = Const v :: Type -> Type

onBare2 :: (v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x

Apply a two-argument function through a shallow 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

Apply a two-argument Map function through a deep DeepMap, akin to liftA2.

Construction

empty :: DeepMap (k ': ks) v

O(1). The empty, arbitrary positive-depth DeepMap.

singleton :: k -> v -> DeepMap '[k] v

O(1). A depth-1 DeepMap with a single key/value pair.

(@>) :: k -> DeepMap ks v -> DeepMap (k ': ks) v infixr 6

A singleton DeepMap. Use with (@|) to create deep nestings:

>>> "Outer" @> 0 @| [5]
Nest {fromList [("Outer",Nest {fromList [(0,Bare [5])]})]}

(@|) :: k -> v -> DeepMap '[k] v infixr 6

Infix synonym for singleton. Use with (@>) to create deep nestings:

>>> "Outer" @> 0 @| [5]
Nest {fromList [("Outer",Nest {fromList [(0,Bare [5])]})]}

From Unordered Lists

fromList :: (Ord k, Semigroup (DeepMap ks v)) => [(k, DeepMap ks v)] -> DeepMap (k ': ks) v

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 (<>).

fromList1 :: (Ord k, Semigroup v) => [(k, v)] -> DeepMap '[k] v

O(n log n). Build a depth-1 DeepMap from a list of key/value pairs. If the list contains more than one value for the same key, the values are combined using (<>).

fromList2 :: (Ord k0, Ord k1, Semigroup v) => [(k0, k1, v)] -> DeepMap '[k0, k1] 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 (<>).

fromList3 :: (Ord k0, Ord k1, Ord k2, Semigroup v) => [(k0, k1, k2, v)] -> DeepMap '[k0, k1, k2] v

O(n log n). Build a depth-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 (<>).

fromList4 :: (Ord k0, Ord k1, Ord k2, Ord k3, Semigroup v) => [(k0, k1, k2, k3, v)] -> DeepMap '[k0, k1, k2, k3] v

O(n log n). Build a depth-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 (<>).

fromList5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4, Semigroup v) => [(k0, k1, k2, k3, k4, v)] -> DeepMap '[k0, k1, k2, k3, k4] v

O(n log n). Build a 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 (<>).

fromListWith :: Ord k => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> [(k, DeepMap ks v)] -> DeepMap (k ': ks) v

O(n log n). Build a deeper DeepMap from a list of key/DeepMap pairs using the provided combining function.

fromListWith1 :: Ord k => (v -> v -> v) -> [(k, v)] -> DeepMap '[k] v

O(n log n). Build a depth-1 DeepMap from a list of key/value pairs using the provided combining function.

fromListWithKey :: Ord k => (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> [(k, DeepMap ks v)] -> DeepMap (k ': ks) v

O(n log n). Build a deeper DeepMap from a list of key/DeepMap pairs with a combining function.

fromListWithKey1 :: Ord k => (k -> v -> v -> v) -> [(k, v)] -> DeepMap '[k] v

O(n log n). Build a depth-1 DeepMap from a list of key/value pairs with a combining function.

fromListWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v -> v) -> [(k0, k1, v)] -> DeepMap '[k0, k1] v

O(n log n). Build a depth-2 DeepMap from a list of keys and values with a combining function.

fromListWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> v -> v) -> [(k0, k1, k2, v)] -> DeepMap '[k0, k1, k2] v

O(n log n). Build a depth-3 DeepMap from a list of keys and values with a combining function.

fromListWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> v -> v) -> [(k0, k1, k2, k3, v)] -> DeepMap '[k0, k1, k2, k3] v

O(n log n). Build a depth-3 DeepMap from a list of keys and values with a combining function.

fromListWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v) -> [(k0, k1, k2, k3, k4, v)] -> DeepMap '[k0, k1, k2, k3, k4] v

O(n log n). Build a depth-3 DeepMap from a list of keys and values with a combining function.

Single-depth map isomorphisms

toMap :: DeepMap (k ': '[]) v -> Map k v

Half of the isomorphism of a depth-1 DeepMap to a Map. See also fromMap.

fromMap :: Map k v -> DeepMap '[k] v

Half of the isomorphism of a depth-1 DeepMap to a Map. See also toMap.

Insertion

insert :: (Ord k, Semigroup (DeepMap ks v)) => k -> DeepMap ks v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(log n). Insert a key/DeepMap pair into the DeepMap. If the key is already present in the map, the associated value is combined with the new value as old <> new. The overwriting behaviour from containers can be recovered by wrapping values in Last or by using overwrite.

insert1 :: (Ord k, Semigroup v) => k -> v -> DeepMap '[k] v -> DeepMap '[k] v

O(log n). Insert a new key and value into a depth-1 DeepMap. If the key is already present in the map, the associated value is combined with the new value as old <> new. The overwriting behaviour from containers can be recovered by wrapping values in Last or by using overwrite1.

insert2 :: (Ord k0, Ord k1, Semigroup v) => k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v

O(log n). Insert a new key-chain/value pair into a depth-2 DeepMap. If the key is already present in the map, the associated value is combined with the new value as old <> new. The overwriting behaviour from containers can be recovered by wrapping values in Last or by using overwrite2.

insert3 :: (Ord k0, Ord k1, Ord k2, Semigroup v) => k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v

O(log n). Insert a new key-chain/value pair into a depth-3 DeepMap. If the key is already present in the map, the associated value is combined with the new value as old <> new. so the overwriting behaviour from containers can be recovered by wrapping values in Last or by using overwrite3.

insert4 :: (Ord k0, Ord k1, Ord k2, Ord k3, Semigroup v) => k0 -> k1 -> k2 -> k3 -> v -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v

O(log n). Insert a new key-chain/value pair into a depth-4 DeepMap. If the key is already present in the map, the associated value is combined with the new value as old <> new. so the overwriting behaviour from containers can be recovered by wrapping values in Last or by using overwrite4.

insert5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4, Semigroup v) => k0 -> k1 -> k2 -> k3 -> k4 -> v -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v

O(log n). Insert a new key-chain/value pair into a depth-5 DeepMap. If the key is already present in the map, the associated value is combined with the new value as old <> new. so the overwriting behaviour from containers can be recovered by wrapping values in Last or by using overwrite5.

insertWith :: Ord k => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> k -> DeepMap ks v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(log n). Insert with a function, combining new value and old value using the supplied function.

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.

insertWith1 :: Ord k => (v -> v -> v) -> k -> v -> DeepMap '[k] v -> DeepMap '[k] v

O(log n). Insert with a function, combining new value and old value using the supplied function.

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.

insertWith2 :: (Ord k0, Ord k1) => (v -> v -> v) -> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v

O(log n). Insert with a function, combining new value and old value using the supplied function.

insertWith3 :: (Ord k0, Ord k1, Ord k2) => (v -> v -> v) -> k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v

O(log n). Insert with a function, combining new value and old value using the supplied function.

insertWith4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (v -> v -> v) -> k0 -> k1 -> k2 -> k3 -> v -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v

O(log n). Insert with a function, combining new value and old value using the supplied function.

insertWith5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (v -> v -> v) -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v

O(log n). Insert with a function, combining new value and old value using the supplied function.

insertWithKey :: Ord k => (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> k -> DeepMap ks v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(log n). Insert with a function, combining new value and old value using the supplied function.

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.

insertWithKey1 :: Ord k => (k -> v -> v -> v) -> k -> v -> DeepMap '[k] v -> DeepMap '[k] v

O(log n). Insert with a function, combining new value and old value using the supplied function with access to the given keys.

insertWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v -> v) -> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v

O(log n). Insert with a function, combining new value and old value using the supplied function with access to the given keys.

insertWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> v -> v) -> k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v

O(log n). Insert with a function, combining new value and old value using the supplied function with access to the given keys.

insertWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> v -> v) -> k0 -> k1 -> k2 -> k3 -> v -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v

O(log n). Insert with a function, combining new value and old value using the supplied function with access to the given keys.

insertWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v) -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v

O(log n). Insert with a function, combining new value and old value using the supplied function with access to the given keys.

insertLookupWithKey :: Ord k => (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> k -> DeepMap ks v -> DeepMap (k ': ks) v -> (Maybe (DeepMap ks v), DeepMap (k ': ks) v)

O(log n). Combines insertion and retrieval.

'insertLookupWithKey' f k new == 'lookup' k &&& 'insertWithKey' f k new

insertLookupWithKey1 :: Ord k => (k -> v -> v -> v) -> k -> v -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v)

O(log n). Combines insertion and retrieval.

insertLookupWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v -> v) -> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> (Maybe v, DeepMap '[k0, k1] v)

O(log n). Combines insertion and retrieval.

insertLookupWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> v -> v) -> k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> (Maybe v, DeepMap '[k0, k1, k2] v)

O(log n). Combines insertion and retrieval.

insertLookupWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> v -> v) -> k0 -> k1 -> k2 -> k3 -> v -> DeepMap '[k0, k1, k2, k3] v -> (Maybe v, DeepMap '[k0, k1, k2, k3] v)

O(log n). Combines insertion and retrieval.

insertLookupWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v) -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> DeepMap '[k0, k1, k2, k3, k4] v -> (Maybe v, DeepMap '[k0, k1, k2, k3, k4] v)

O(log n). Combines insertion and retrieval.

overwrite :: Ord k => k -> DeepMap ks v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) 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.

overwrite1 :: Ord k => k -> v -> DeepMap '[k] v -> DeepMap '[k] v

O(log n). Insert a new key/value pair into a depth-1 DeepMap. If the key is already present in the map, the associated value is replaced by the new value.

overwrite2 :: (Ord k0, Ord k1) => k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v

O(log n). Insert a new key-chain/value pair into a depth-2 DeepMap. If the key is already present in the map, the associated value is replaced by the new value.

overwrite3 :: (Ord k0, Ord k1, Ord k2) => k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v

O(log n). Insert a new key-chain/value pair into a depth-3 DeepMap. If the key is already present in the map, the associated value is replaced by the new value.

overwrite4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => k0 -> k1 -> k2 -> k3 -> v -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v

O(log n). Insert a new key-chain/value pair into a depth-4 DeepMap. If the key is already present in the map, the associated value is replaced by the new value.

overwrite5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => k0 -> k1 -> k2 -> k3 -> k4 -> v -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v

O(log n). 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.

overwriteLookup :: Ord k => k -> DeepMap ks v -> DeepMap (k ': ks) v -> (Maybe (DeepMap ks v), DeepMap (k ': ks) v)

O(log n). Combines replacement and retrieval.

overwriteLookup1 :: Ord k => k -> v -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v)

O(log n). Combines replacement and retrieval at depth 1.

overwriteLookup2 :: (Ord k0, Ord k1) => k0 -> k1 -> v -> DeepMap '[k0, k1] v -> (Maybe v, DeepMap '[k0, k1] v)

O(log n). Combines replacement and retrieval at depth 2.

overwriteLookup3 :: (Ord k0, Ord k1, Ord k2) => k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> (Maybe v, DeepMap '[k0, k1, k2] v)

O(log n). Combines replacement and retrieval at depth 3.

overwriteLookup4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => k0 -> k1 -> k2 -> k3 -> v -> DeepMap '[k0, k1, k2, k3] v -> (Maybe v, DeepMap '[k0, k1, k2, k3] v)

O(log n). Combines replacement and retrieval at depth 4.

overwriteLookup5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => k0 -> k1 -> k2 -> k3 -> k4 -> v -> DeepMap '[k0, k1, k2, k3, k4] v -> (Maybe v, DeepMap '[k0, k1, k2, k3, k4] v)

O(log n). Combines replacement and retrieval at depth 5.

Deletion/Update

delete :: Ord k => k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(log n). Delete a key and its value from the map, or do nothing if the key is missing.

delete1 :: Ord k => k -> DeepMap '[k] v -> DeepMap '[k] v

O(log n). Delete a key and its value from the map, or do nothing if the key is missing.

delete2 :: (Ord k0, Ord k1) => k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v

O(log n). Delete a key and its value from the map, or do nothing if the key is missing.

delete3 :: (Ord k0, Ord k1, Ord k2) => k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v

O(log n). Delete a key and its value from the map, or do nothing if the key is missing.

delete4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v

O(log n). Delete a key and its value from the map, or do nothing if the key is missing.

delete5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v

O(log n). Delete a key and its value from the map, 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

O(log n). Change a value at a specific key with the result of the provided function, or do nothing if the key is missing.

adjust1 :: Ord k => (v -> v) -> k -> DeepMap '[k] v -> DeepMap '[k] v

O(log n). Change a value at a specific key with the result of the provided function, or do nothing if the key is missing.

adjust2 :: (Ord k0, Ord k1) => (v -> v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v

O(log n). Change a value at specific keys with the result of the provided function, or do nothing if the key is missing.

adjust3 :: (Ord k0, Ord k1, Ord k2) => (v -> v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v

O(log n). Change a value at specific keys with the result of the provided function, or do nothing if the key is missing.

adjust4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (v -> v) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v

O(log n). Change a value at specific keys with the result of the provided function, or do nothing if the key is missing.

adjust5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (v -> v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v

O(log n). Change a value at specific keys with the result of the provided function, or do nothing if the key is missing.

adjustWithKey :: Ord k => (k -> DeepMap ks v -> DeepMap ks v) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(log n). Change a value at a specific key with access to the key itself, or do nothing if the key is missing.

adjustWithKey1 :: Ord k => (k -> v -> v) -> k -> DeepMap '[k] v -> DeepMap '[k] v

O(log n). Change a value at a specific key with access to the key itself, or do nothing if the key is missing.

adjustWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v

O(log n). Change a value at a specific key with access to the key itself, or do nothing if the key is missing.

adjustWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v

O(log n). Change a value at a specific key with access to the key itself, or do nothing if the key is missing.

adjustWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> v) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v

O(log n). Change a value at a specific key with access to the key itself, or do nothing if the key is missing.

adjustWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v

O(log n). Change a value at a specific key with access to the key itself, or do nothing if the key is missing.

update :: Ord k => (DeepMap ks v -> Maybe (DeepMap ks v)) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(log n). Change a DeepMap at a specific key. If the function evaluates to Nothing, the key and submap are removed. If the key is missing, do nothing.

update1 :: Ord k => (v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v

O(log n). Change a DeepMap at a specific key. If the function evaluates to Nothing, the key and submap are removed. If the key is missing, do nothing.

update2 :: (Ord k0, Ord k1) => (v -> Maybe v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v

O(log n). Change a DeepMap at a specific key. If the function evaluates to Nothing, the key and submap are removed. If the key is missing, do nothing.

update3 :: (Ord k0, Ord k1, Ord k2) => (v -> Maybe v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v

O(log n). Change a DeepMap at a specific key. If the function evaluates to Nothing, the key and submap are removed. If the key is missing, do nothing.

update4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v

O(log n). Change a DeepMap at a specific key. If the function evaluates to Nothing, the key and submap are removed. If the key is missing, do nothing.

update5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v

O(log n). Change a DeepMap at a specific key. If the function evaluates to Nothing, the key and submap are removed. If the key is missing, do nothing.

updateWithKey :: Ord k => (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(log n). Change a 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.

updateWithKey1 :: Ord k => (k -> v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v

O(log n). Change a value at a specific key with access to the key itself. If the function evaluates to Nothing, the key and value are removed. If the key is missing, do nothing.

updateWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> Maybe v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v

O(log n). Change a value at specific keys with access to the keys themselves. If the function evaluates to Nothing, the keys and value are removed. If the keys are missing, do nothing.

updateWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> Maybe v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v

O(log n). Change a value at specific keys with access to the keys themselves. If the function evaluates to Nothing, the keys and value are removed. If the keys are missing, do nothing.

updateWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v

O(log n). Change a value at specific keys with access to the keys themselves. If the function evaluates to Nothing, the keys and value are removed. If the keys are missing, do nothing.

updateWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v

O(log n). 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.

updateLookupWithKey :: Ord k => (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> k -> DeepMap (k ': ks) v -> (Maybe (DeepMap ks v), DeepMap (k ': ks) v)

O(log n). Combines change and retrieval.

'updateLookupWithKey' f k == 'lookup' k &&& 'updateWithKey' f k

updateLookupWithKey1 :: Ord k => (k -> v -> Maybe v) -> k -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v)

O(log n). Combines change and retrieval.

updateLookupWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> Maybe v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> (Maybe v, DeepMap '[k0, k1] v)

O(log n). Combines change and retrieval.

updateLookupWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> Maybe v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> (Maybe v, DeepMap '[k0, k1, k2] v)

O(log n). Combines change and retrieval.

updateLookupWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> (Maybe v, DeepMap '[k0, k1, k2, k3] v)

O(log n). Combines change and retrieval.

updateLookupWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> (Maybe v, DeepMap '[k0, k1, k2, k3, k4] v)

O(log n). Combines change and retrieval.

alter :: Ord k => (Maybe (DeepMap ks v) -> Maybe (DeepMap ks v)) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(log n). Can be used to insert, overwrite, delete, or update a value.

alter1 :: Ord k => (Maybe v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v

O(log n). Can be used to insert, overwrite, delete, or update a value.

alter2 :: (Ord k0, Ord k1) => (Maybe v -> Maybe v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v

O(log n). Can be used to insert, overwrite, delete, or update a value.

alter3 :: (Ord k0, Ord k1, Ord k2) => (Maybe v -> Maybe v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v

O(log n). Can be used to insert, overwrite, delete, or update a value.

alter4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (Maybe v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v

O(log n). Can be used to insert, overwrite, delete, or update a value.

alter5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (Maybe v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v

O(log n). Can be used to insert, overwrite, delete, or update a value.

alterF :: (Functor f, Ord k) => (Maybe (DeepMap ks v) -> f (Maybe (DeepMap ks v))) -> k -> DeepMap (k ': ks) v -> f (DeepMap (k ': ks) v)

alterF1 :: (Functor f, Ord k) => (Maybe v -> f (Maybe v)) -> k -> DeepMap '[k] v -> f (DeepMap '[k] v)

alterF2 :: (Functor f, Ord k0, Ord k1) => (Maybe v -> f (Maybe v)) -> k0 -> k1 -> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] v)

alterF3 :: (Functor f, Ord k0, Ord k1, Ord k2) => (Maybe v -> f (Maybe v)) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] v)

alterF4 :: (Functor f, Ord k0, Ord k1, Ord k2, Ord k3) => (Maybe v -> f (Maybe v)) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] v)

alterF5 :: (Functor f, Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (Maybe v -> f (Maybe v)) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> f (DeepMap '[k0, k1, k2, k3, k4] v)

Query

Lookup

lookup :: Ord k => k -> DeepMap (k ': ks) v -> Maybe (DeepMap ks v)

O(log n). Lookup the value at a key.

(@?) :: Ord k => DeepMap (k ': ks) v -> k -> Maybe (DeepMap ks v)

O(log n). A flipped, infix variant of lookup.

(@?|) :: Ord k => DeepMap '[k] v -> k -> Maybe v

O(log n). A flipped, infix variant of lookup1.

(@??) :: Ord k => Maybe (DeepMap (k ': ks) v) -> k -> Maybe (DeepMap ks v)

O(log n). Facilitates chaining of lookups. For m :: DeepMap '[k0, k1, k2] v,

>>> m @? k0 @?? k1 @??| k2 == (m @? k0) >>= (@? k1) >>= (@?| k2)

(@??|) :: Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v

O(log n). Facilitates chaining of lookups. For m :: DeepMap '[k0, k1, k2] v,

>>> m @? k0 @?? k1 @??| k2 == (m @? k0) >>= (@? k1) >>= (@?| k2)

(@!) :: (Ord k, Monoid (DeepMap ks v)) => DeepMap (k ': ks) v -> k -> DeepMap ks v

O(log n). A version of (@?) that returns mempty when the element cannot be found.

(@!|) :: (Ord k, Monoid v) => DeepMap '[k] v -> k -> v

O(log n). A version of (@?|) that returns mempty when the element cannot be found.

findWithDefault :: Ord k => DeepMap ks v -> k -> DeepMap (k ': ks) v -> DeepMap ks v

O(log n). Lookup the DeepMap at a key, with a default if the key is missing.

findWithDefault1 :: Ord k => v -> k -> DeepMap '[k] v -> v

O(log n). Lookup the value at a key, with a default if the key is missing.

findWithDefault2 :: (Ord k0, Ord k1) => v -> k0 -> k1 -> DeepMap '[k0, k1] v -> v

O(log n). Lookup the value at a key, with a default if the key is missing.

findWithDefault3 :: (Ord k0, Ord k1, Ord k2) => v -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> v

O(log n). Lookup the value at a key, with a default if the key is missing.

findWithDefault4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => v -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> v

O(log n). Lookup the value at a key, with a default if the key is missing.

findWithDefault5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => v -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> v

O(log n). Lookup the value at a key, with a default if the key is missing.

member :: Ord k => k -> DeepMap (k ': ks) v -> Bool

O(log n). Is the key a member of the map? See also notMember.

notMember :: Ord k => k -> DeepMap (k ': ks) v -> Bool

O(log n). Is the key missing from the map? See also member.

lookupLT :: Ord k => k -> DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)

Find the next smallest key to the given one, and return its key/value pair.

lookupGT :: Ord k => k -> DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)

Find the next largest key to the given one, and return its key/value pair.

lookupLE :: Ord k => k -> DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)

Find the largest key up to the given one, and return its key/value pair.

lookupGE :: Ord k => k -> DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)

Find the smallest key down to the given one, and return its key/value pair.

Size

null :: DeepMap (k ': ks) v -> Bool

O(1). Is the DeepMap empty?

size :: DeepMap (k ': ks) v -> Int

O(1). The number of outermost keys in the DeepMap.

Combine

Union

union :: (Ord k, Semigroup (DeepMap ks v)) => DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(m log(n / m + 1)), m <= n. Join two DeepMaps together using (<>) to combine the values of duplicate keys.

To retain Map's left-biased functionality, use unionWith const.

unionWith :: Ord k => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(m log(n / m + 1)), m <= n. Join two DeepMaps with a combining function.

unionWith1 :: Ord k => (v -> v -> v) -> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v

O(m log(n / m + 1)), m <= n. Join two DeepMaps with a combining function.

unionWith2 :: (Ord k0, Ord k1) => (v -> v -> v) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v

O(m log(n / m + 1)), m <= n. Join two DeepMaps with a combining function.

unionWith3 :: (Ord k0, Ord k1, Ord k2) => (v -> v -> v) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v

O(m log(n / m + 1)), m <= n. Join two DeepMaps with a combining function.

unionWith4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (v -> v -> v) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v

O(m log(n / m + 1)), m <= n. Join two DeepMaps with a combining function.

unionWith5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (v -> v -> v) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v

O(m log(n / m + 1)), m <= n. Join two DeepMaps with a combining function.

unionWithKey :: Ord k => (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(m log(n / m + 1)), m <= n. Join two maps with a combining function with access to the keys.

unionWithKey1 :: Ord k => (k -> v -> v -> v) -> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v

O(m log(n / m + 1)), m <= n. Join two DeepMaps with a combining function with access to the keys.

unionWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v -> v) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v

O(m log(n / m + 1)), m <= n. Join two DeepMaps with a combining function with access to the keys.

unionWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> v -> v) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v

O(m log(n / m + 1)), m <= n. Join two DeepMaps with a combining function with access to the keys.

unionWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> v -> v) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v

O(m log(n / m + 1)), m <= n. Join two DeepMaps with a combining function with access to the keys.

unionWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v

O(m log(n / m + 1)), m <= n. Join two DeepMaps with a combining function with access to the keys.

unions :: (Foldable t, Ord k, Semigroup (DeepMap ks v)) => t (DeepMap (k ': ks) v) -> DeepMap (k ': ks) v

A synonym for fold. To retain Map's functionality, use unionsWith const.

unionsWith :: (Foldable t, Ord k) => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> t (DeepMap (k ': ks) v) -> DeepMap (k ': ks) v

The union of a list of DeepMaps, combining with a specified operation.

unionsWith1 :: (Foldable t, Ord k) => (v -> v -> v) -> t (DeepMap '[k] v) -> DeepMap '[k] v

The union of a list of DeepMaps, combining with a specified operation.

Difference

difference :: Ord k => DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v

O(m log(n / m + 1)), m <= n. The set-difference of the keys in a DeepMap, keeping the values of the left-hand map.

(\\) :: Ord k => DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v

Infix synonym for difference.

differenceWith :: Ord k => (DeepMap ks v -> DeepMap ls w -> Maybe (DeepMap ks v)) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v

O(n + m). Difference with a combining function. Deletes keys if the value is Nothing.

differenceWith1 :: Ord k => (v -> w -> Maybe v) -> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] v

O(n + m). Difference with a combining function. Deletes keys if the value is Nothing.

differenceWithKey :: Ord k => (k -> DeepMap ks v -> DeepMap ls w -> Maybe (DeepMap ks v)) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v

O(n + m). Difference with a combining function. Deletes keys if the value is Nothing.

differenceWithKey1 :: Ord k => (k -> v -> w -> Maybe v) -> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] v

O(n + m). Difference with a combining function. Deletes keys if the value is Nothing.

Intersection

intersection :: Ord k => DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v

O(m log(n / m + 1)), m <= n. The set-intersection of the keys in a map, keeping the values of the left-hand map.

intersectionWith :: Ord k => (DeepMap ks v -> DeepMap ls w -> DeepMap ms x) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ms) x

O(m log(n / m + 1)), m <= n. Intersection with a combining function.

intersectionWith1 :: Ord k => (v -> w -> x) -> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] x

O(m log(n / m + 1)), m <= n. Intersection with a combining function.

intersectionWithKey :: Ord k => (k -> DeepMap ks v -> DeepMap ls w -> DeepMap ms x) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ms) x

O(m log(n / m + 1)), m <= n. Intersection with a combining function.

intersectionWithKey1 :: Ord k => (k -> v -> w -> x) -> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] x

O(m log(n / m + 1)), m <= n. Intersection with a combining function.

intersectionWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> w -> x) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] w -> DeepMap '[k0, k1] x

O(m log(n / m + 1)), m <= n. Intersection with a combining function.

intersectionWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> w -> x) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] w -> DeepMap '[k0, k1, k2] x

O(m log(n / m + 1)), m <= n. Intersection with a combining function.

intersectionWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> w -> x) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] w -> DeepMap '[k0, k1, k2, k3] x

O(m log(n / m + 1)), m <= n. Intersection with a combining function.

intersectionWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> w -> x) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] w -> DeepMap '[k0, k1, k2, k3, k4] x

O(m log(n / m + 1)), m <= n. Intersection with a combining function.

Traversal

Map

mapShallow :: (DeepMap ks v -> DeepMap ls w) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w

O(n). Strictly more general than fmap in that it may change the types of the inner keys.

mapShallowWithKey :: (k -> DeepMap ks v -> DeepMap ls w) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w

O(n). Like mapShallow but the function has access to the outer keys.

mapWithKey1 :: (k -> v -> w) -> DeepMap '[k] v -> DeepMap '[k] w

O(n). Like fmap but the function has access to the outer keys.

mapWithKey2 :: (k0 -> k1 -> v -> w) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] w

O(n). Like fmap but the function has access to the outer keys.

mapWithKey3 :: (k0 -> k1 -> k2 -> v -> w) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] w

O(n). Like fmap but the function has access to the outer keys.

mapWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> w) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] w

O(n). Like fmap but the function has access to the outer keys.

mapWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> w) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] w

O(n). Like fmap but the function has access to the outer keys.

traverseShallow :: Applicative f => (DeepMap ks v -> f (DeepMap ls w)) -> DeepMap (k ': ks) v -> f (DeepMap (k ': ls) w)

O(n). Strictly more general than traverse in that it may change the types of the inner keys.

traverseShallowWithKey :: Applicative f => (k -> DeepMap ks v -> f (DeepMap ls w)) -> DeepMap (k ': ks) v -> f (DeepMap (k ': ls) w)

O(n). Like traverseShallow but the function has access to the keys.

traverseWithKey1 :: Applicative f => (k -> v -> f w) -> DeepMap '[k] v -> f (DeepMap '[k] w)

O(n). Like traverse but the function has access to the keys.

traverseWithKey2 :: Applicative f => (k0 -> k1 -> v -> f w) -> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] w)

O(n). Like traverse but the function has access to the keys.

traverseWithKey3 :: Applicative f => (k0 -> k1 -> k2 -> v -> f w) -> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] w)

O(n). Like traverse but the function has access to the keys.

traverseWithKey4 :: Applicative f => (k0 -> k1 -> k2 -> k3 -> v -> f w) -> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] w)

O(n). Like traverse but the function has access to the keys.

traverseWithKey5 :: Applicative f => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> f w) -> DeepMap '[k0, k1, k2, k3, k4] v -> f (DeepMap '[k0, k1, k2, k3, k4] w)

O(n). Like traverse but the function has access to the keys.

traverseMaybeWithKey :: Applicative f => (k -> DeepMap ks v -> f (Maybe (DeepMap ls w))) -> DeepMap (k ': ks) v -> f (DeepMap (k ': ls) w)

O(n). Traverse keys/submaps and collect the Just results.

traverseMaybeWithKey1 :: Applicative f => (k -> v -> f (Maybe w)) -> DeepMap '[k] v -> f (DeepMap '[k] w)

O(n). Traverse keys/values and collect the Just results.

traverseMaybeWithKey2 :: Applicative f => (k0 -> k1 -> v -> f (Maybe w)) -> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] w)

O(n). Traverse keys/values and collect the Just results.

traverseMaybeWithKey3 :: Applicative f => (k0 -> k1 -> k2 -> v -> f (Maybe w)) -> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] w)

O(n). Traverse keys/values and collect the Just results.

traverseMaybeWithKey4 :: Applicative f => (k0 -> k1 -> k2 -> k3 -> v -> f (Maybe w)) -> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] w)

O(n). Traverse keys/values and collect the Just results.

traverseMaybeWithKey5 :: Applicative f => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> f (Maybe w)) -> DeepMap '[k0, k1, k2, k3, k4] v -> f (DeepMap '[k0, k1, k2, k3, k4] w)

O(n). Traverse keys/values and collect the Just results.

mapAccum :: (acc -> DeepMap ks v -> (acc, DeepMap ls w)) -> acc -> DeepMap (k ': ks) v -> (acc, DeepMap (k ': ls) w)

O(n). Thread an accumulating argument through the DeepMap in ascending order of keys.

mapAccum1 :: (acc -> v -> (acc, w)) -> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)

O(n). Thread an accumulating argument through the DeepMap in ascending order of keys.

mapAccumR :: (acc -> DeepMap ks v -> (acc, DeepMap ls w)) -> acc -> DeepMap (k ': ks) v -> (acc, DeepMap (k ': ls) w)

O(n). Thread an accumulating argument through the DeepMap in descending order of keys.

mapAccumR1 :: (acc -> v -> (acc, w)) -> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)

O(n). Thread an accumulating argument through the DeepMap in descending order of keys.

mapAccumWithKey :: (acc -> k -> DeepMap ks v -> (acc, DeepMap ls w)) -> acc -> DeepMap (k ': ks) v -> (acc, DeepMap (k ': ls) w)

O(n). Like mapAccum but the function has access to the keys.

mapAccumWithKey1 :: (acc -> k -> v -> (acc, w)) -> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)

O(n). Like mapAccum but the function has access to the keys.

mapAccumWithKey2 :: (acc -> k0 -> k1 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1] v -> (acc, DeepMap '[k0, k1] w)

O(n). Like mapAccum but the function has access to the keys.

mapAccumWithKey3 :: (acc -> k0 -> k1 -> k2 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2] v -> (acc, DeepMap '[k0, k1, k2] w)

O(n). Like mapAccum but the function has access to the keys.

mapAccumWithKey4 :: (acc -> k0 -> k1 -> k2 -> k3 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2, k3] v -> (acc, DeepMap '[k0, k1, k2, k3] w)

O(n). Like mapAccum but the function has access to the keys.

mapAccumWithKey5 :: (acc -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2, k3, k4] v -> (acc, DeepMap '[k0, k1, k2, k3, k4] w)

O(n). Like mapAccum but the function has access to the keys.

mapAccumRWithKey :: (acc -> k -> DeepMap ks v -> (acc, DeepMap ls w)) -> acc -> DeepMap (k ': ks) v -> (acc, DeepMap (k ': ls) w)

O(n). Like mapAccumR but the function has access to the keys.

mapAccumRWithKey1 :: (acc -> k -> v -> (acc, w)) -> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)

O(n). Like mapAccumR but the function has access to the keys.

mapAccumRWithKey2 :: (acc -> k0 -> k1 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1] v -> (acc, DeepMap '[k0, k1] w)

O(n). Like mapAccumR but the function has access to the keys.

mapAccumRWithKey3 :: (acc -> k0 -> k1 -> k2 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2] v -> (acc, DeepMap '[k0, k1, k2] w)

O(n). Like mapAccumR but the function has access to the keys.

mapAccumRWithKey4 :: (acc -> k0 -> k1 -> k2 -> k3 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2, k3] v -> (acc, DeepMap '[k0, k1, k2, k3] w)

O(n). Like mapAccumR but the function has access to the keys.

mapAccumRWithKey5 :: (acc -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2, k3, k4] v -> (acc, DeepMap '[k0, k1, k2, k3, k4] w)

O(n). Like mapAccumR but the function has access to the keys.

mapKeys :: (Ord k, Semigroup (DeepMap ks v)) => (j -> k) -> DeepMap (j ': ks) v -> DeepMap (k ': ks) v

O(n log n). Map a function over the outer keys of a DeepMap. If the function maps two or more j-keys to the same k-key, the values of the j-keys are combined with (<>).

To retain Map's greatest-biased functionality, use mapKeysWith const.

mapKeys1 :: (Ord k, Semigroup v) => (j -> k) -> DeepMap '[j] v -> DeepMap '[k] v

O(n log n). Map a function over the keys of a DeepMap.

mapKeys2 :: (Ord k0, Ord k1, Semigroup (DeepMap ks v)) => (j0 -> k0) -> (j1 -> k1) -> DeepMap (j0 ': (j1 ': ks)) v -> DeepMap (k0 ': (k1 ': ks)) v

O(n log n). Map a function over the keys of a DeepMap.

mapKeys3 :: (Ord k0, Ord k1, Ord k2, Semigroup (DeepMap ks v)) => (j0 -> k0) -> (j1 -> k1) -> (j2 -> k2) -> DeepMap (j0 ': (j1 ': (j2 ': ks))) v -> DeepMap (k0 ': (k1 ': (k2 ': ks))) v

O(n log n). Map a function over the keys of a DeepMap.

mapKeys4 :: (Ord k0, Ord k1, Ord k2, Ord k3, Semigroup (DeepMap ks v)) => (j0 -> k0) -> (j1 -> k1) -> (j2 -> k2) -> (j3 -> k3) -> DeepMap (j0 ': (j1 ': (j2 ': (j3 ': ks)))) v -> DeepMap (k0 ': (k1 ': (k2 ': (k3 ': ks)))) v

O(n log n). Map a function over the keys of a DeepMap.

mapKeys5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4, Semigroup (DeepMap ks v)) => (j0 -> k0) -> (j1 -> k1) -> (j2 -> k2) -> (j3 -> k3) -> (j4 -> k4) -> DeepMap (j0 ': (j1 ': (j2 ': (j3 ': (j4 ': ks))))) v -> DeepMap (k0 ': (k1 ': (k2 ': (k3 ': (k4 ': ks))))) v

O(n log n). Map a function over the keys of a DeepMap.

mapKeysWith :: Ord k => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> (j -> k) -> DeepMap (j ': ks) v -> DeepMap (k ': ks) v

O(n log n). Map a function over the outer keys of a DeepMap with a combining function.

mapKeysWith1 :: Ord k => (v -> v -> v) -> (j -> k) -> DeepMap '[j] v -> DeepMap '[k] v

O(n log n). Map a function over the keys of a DeepMap with a value-combining function.

mapKeysWith2 :: (Ord k0, Ord k1) => (v -> v -> v) -> (j0 -> k0) -> (j1 -> k1) -> DeepMap '[j0, j1] v -> DeepMap '[k0, k1] v

O(n log n). Map a function over the keys of a DeepMap with a value-combining function.

mapKeysWith3 :: (Ord k0, Ord k1, Ord k2) => (v -> v -> v) -> (j0 -> k0) -> (j1 -> k1) -> (j2 -> k2) -> DeepMap '[j0, j1, j2] v -> DeepMap '[k0, k1, k2] v

O(n log n). Map a function over the keys of a DeepMap with a value-combining function.

mapKeysWith4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (v -> v -> v) -> (j0 -> k0) -> (j1 -> k1) -> (j2 -> k2) -> (j3 -> k3) -> DeepMap '[j0, j1, j2, j3] v -> DeepMap '[k0, k1, k2, k3] v

O(n log n). Map a function over the keys of a DeepMap with a value-combining function.

mapKeysWith5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (v -> v -> v) -> (j0 -> k0) -> (j1 -> k1) -> (j2 -> k2) -> (j3 -> k3) -> (j4 -> k4) -> DeepMap '[j0, j1, j2, j3, j4] v -> DeepMap '[k0, k1, k2, k3, k4] v

O(n log n). Map a function over the keys of a DeepMap with a value-combining function.

traverseKeys :: (Applicative f, Ord k, Semigroup (DeepMap ks v)) => (j -> f k) -> DeepMap (j ': ks) v -> f (DeepMap (k ': ks) v)

O(n log n). Map an applicative function over the outer keys and collect the results.

traverseKeysWith :: (Applicative f, Ord k) => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> (j -> f k) -> DeepMap (j ': ks) v -> f (DeepMap (k ': ks) v)

O(n log n). Map an applicative function over the outer keys of the map and collect the results using the specified combining function.

mapKeysM :: (Monad m, Ord k, Semigroup (DeepMap ks v)) => (j -> m k) -> DeepMap (j ': ks) v -> m (DeepMap (k ': ks) v)

O(n log n). Map a monadic function over the keys of a DeepMap and collect the results.

mapKeysM1 :: (Monad m, Ord k, Semigroup (DeepMap ks v)) => (j -> m k) -> DeepMap (j ': ks) v -> m (DeepMap (k ': ks) v)

O(n log n). Map a monadic function over the keys of a DeepMap and collect the results.

mapKeysM2 :: (Monad m, Ord k0, Ord k1, Semigroup (DeepMap ks v)) => (j0 -> m k0) -> (j1 -> m k1) -> DeepMap (j0 ': (j1 ': ks)) v -> m (DeepMap (k0 ': (k1 ': ks)) v)

O(n log n). Map a monadic function over the keys of a DeepMap and collect the results.

Sadly traverseKeys2 can't have this type signature because we'd end up with a twice-wrapped Applicative and no way out.

mapKeysM3 :: (Monad m, Ord k0, Ord k1, Ord k2, Semigroup (DeepMap ks v)) => (j0 -> m k0) -> (j1 -> m k1) -> (j2 -> m k2) -> DeepMap (j0 ': (j1 ': (j2 ': ks))) v -> m (DeepMap (k0 ': (k1 ': (k2 ': ks))) v)

O(n log n). Map a monadic function over the keys of a DeepMap and collect the results.

mapKeysM4 :: (Monad m, Ord k0, Ord k1, Ord k2, Ord k3, Semigroup (DeepMap ks v)) => (j0 -> m k0) -> (j1 -> m k1) -> (j2 -> m k2) -> (j3 -> m k3) -> DeepMap (j0 ': (j1 ': (j2 ': (j3 ': ks)))) v -> m (DeepMap (k0 ': (k1 ': (k2 ': (k3 ': ks)))) v)

O(n log n). Map a monadic function over the keys of a DeepMap and collect the results.

mapKeysM5 :: (Monad m, Ord k0, Ord k1, Ord k2, Ord k3, Ord k4, Semigroup (DeepMap ks v)) => (j0 -> m k0) -> (j1 -> m k1) -> (j2 -> m k2) -> (j3 -> m k3) -> (j4 -> m k4) -> DeepMap (j0 ': (j1 ': (j2 ': (j3 ': (j4 ': ks))))) v -> m (DeepMap (k0 ': (k1 ': (k2 ': (k3 ': (k4 ': ks))))) v)

O(n log n). Map a monadic function over the keys of a DeepMap and collect the results.

mapKeysMWith :: (Monad m, Ord k) => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> (j -> m k) -> DeepMap (j ': ks) v -> m (DeepMap (k ': ks) v)

O(n log n). Map a monadic function over the outer keys of a DeepMap with a submap-combining function.

mapKeysMWith1 :: (Monad m, Ord k) => (v -> v -> v) -> (j -> m k) -> DeepMap '[j] v -> m (DeepMap '[k] v)

O(n log n). Map a monadic function over the keys of a DeepMap with a value-combining function.

mapKeysMWith2 :: (Monad m, Ord k0, Ord k1) => (v -> v -> v) -> (j0 -> m k0) -> (j1 -> m k1) -> DeepMap '[j0, j1] v -> m (DeepMap '[k0, k1] v)

O(n log n). Map a monadic function over the keys of a DeepMap with a value-combining function.

mapKeysMWith3 :: (Monad m, Ord k0, Ord k1, Ord k2) => (v -> v -> v) -> (j0 -> m k0) -> (j1 -> m k1) -> (j2 -> m k2) -> DeepMap '[j0, j1, j2] v -> m (DeepMap '[k0, k1, k2] v)

O(n log n). Map a monadic function over the keys of a DeepMap with a value-combining function.

mapKeysMWith4 :: (Monad m, Ord k0, Ord k1, Ord k2, Ord k3) => (v -> v -> v) -> (j0 -> m k0) -> (j1 -> m k1) -> (j2 -> m k2) -> (j3 -> m k3) -> DeepMap '[j0, j1, j2, j3] v -> m (DeepMap '[k0, k1, k2, k3] v)

O(n log n). Map a monadic function over the keys of a DeepMap with a value-combining function.

mapKeysMWith5 :: (Monad m, Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (v -> v -> v) -> (j0 -> m k0) -> (j1 -> m k1) -> (j2 -> m k2) -> (j3 -> m k3) -> (j4 -> m k4) -> DeepMap '[j0, j1, j2, j3, j4] v -> m (DeepMap '[k0, k1, k2, k3, k4] v)

O(n log n). Map a monadic function over the keys of a DeepMap with a value-combining function.

Folds

foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b

Right-associative fold of a structure.

In the case of lists, foldr, when applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left:

foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)

Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, foldr can produce a terminating expression from an infinite list.

For a general Foldable structure this should be semantically identical to,

foldr f z = foldr f z . toList

foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b

Left-associative fold of a structure.

In the case of lists, foldl, when applied to a binary operator, a starting value (typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right:

foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn

Note that to produce the outermost application of the operator the entire input list must be traversed. This means that foldl' will diverge if given an infinite list.

Also note that if you want an efficient left-fold, you probably want to use foldl' instead of foldl. The reason for this is that latter does not force the "inner" results (e.g. z `f` x1 in the above example) before applying them to the operator (e.g. to (`f` x2)). This results in a thunk chain \(\mathcal{O}(n)\) elements long, which then must be evaluated from the outside-in.

For a general Foldable structure this should be semantically identical to,

foldl f z = foldl f z . toList

foldShallow :: Monoid (DeepMap ks v) => DeepMap (k ': ks) v -> DeepMap ks v

foldrWithKey :: (k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k ': ks) v -> b

O(n). Fold the keys and submaps in the DeepMap using the given right-associative binary operator.

foldrWithKey1 :: (k -> v -> b -> b) -> b -> DeepMap '[k] v -> b

O(n). Fold the keys and values using the given right-associative binary operator.

foldrWithKey2 :: (k0 -> k1 -> v -> b -> b) -> b -> DeepMap '[k0, k1] v -> b

O(n). Fold the keys and values using the given right-associative binary operator.

foldrWithKey3 :: (k0 -> k1 -> k2 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2] v -> b

O(n). Fold the keys and values using the given right-associative binary operator.

foldrWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2, k3] v -> b

O(n). Fold the keys and values using the given right-associative binary operator.

foldrWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k3 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2, k3, k3] v -> b

O(n). Fold the keys and values using the given right-associative binary operator.

foldlWithKey :: (b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k ': ks) v -> b

O(n). Fold the keys and submaps in the DeepMap using the given left-associative binary operator.

foldlWithKey1 :: (b -> k -> v -> b) -> b -> DeepMap '[k] v -> b

O(n). Fold the keys and values in the DeepMap using the given left-associative binary operator.

foldlWithKey2 :: (b -> k0 -> k1 -> v -> b) -> b -> DeepMap '[k0, k1] v -> b

O(n). Fold the keys and values in the DeepMap using the given left-associative binary operator.

foldlWithKey3 :: (b -> k0 -> k1 -> k2 -> v -> b) -> b -> DeepMap '[k0, k1, k2] v -> b

O(n). Fold the keys and values in the DeepMap using the given left-associative binary operator.

foldlWithKey4 :: (b -> k0 -> k1 -> k2 -> k3 -> v -> b) -> b -> DeepMap '[k0, k1, k2, k3] v -> b

O(n). Fold the keys and values in the DeepMap using the given left-associative binary operator.

foldlWithKey5 :: (b -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> b) -> b -> DeepMap '[k0, k1, k2, k3, k4] v -> b

O(n). Strictly fold the keys and values in the DeepMap using the given left-associative binary operator.

foldMapWithKey :: Monoid m => (k -> DeepMap ks v -> m) -> DeepMap (k ': ks) v -> m

O(n). Fold the keys and submaps using the given monoid.

foldMapWithKey1 :: Monoid m => (k -> v -> m) -> DeepMap '[k] v -> m

O(n). Fold the keys and values in the map using the given monoid.

foldMapWithKey2 :: Monoid m => (k0 -> k1 -> v -> m) -> DeepMap '[k0, k1] v -> m

O(n). Fold the keys and values in the map using the given monoid.

foldMapWithKey3 :: Monoid m => (k0 -> k1 -> k2 -> v -> m) -> DeepMap '[k0, k1, k2] v -> m

O(n). Fold the keys and values in the map using the given monoid.

foldMapWithKey4 :: Monoid m => (k0 -> k1 -> k2 -> k3 -> v -> m) -> DeepMap '[k0, k1, k2, k3] v -> m

O(n). Fold the keys and values in the map using the given monoid.

foldMapWithKey5 :: Monoid m => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> m) -> DeepMap '[k0, k1, k2, k3, k4] v -> m

O(n). Fold the keys and values in the map using the given monoid.

Strict folds

foldr' :: Foldable t => (a -> b -> b) -> b -> t a -> b

Right-associative fold of a structure, but with strict application of the operator.

Since: base-4.6.0.0

foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b

Left-associative fold of a structure but with strict application of the operator.

This ensures that each step of the fold is forced to weak head normal form before being applied, avoiding the collection of thunks that would otherwise occur. This is often what you want to strictly reduce a finite list to a single, monolithic result (e.g. length).

For a general Foldable structure this should be semantically identical to,

foldl' f z = foldl' f z . toList

Since: base-4.6.0.0

foldrWithKey' :: (k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k ': ks) v -> b

O(n). Strictly fold the keys and submaps in the DeepMap using the given right-associative binary operator.

foldrWithKey1' :: (k -> v -> b -> b) -> b -> DeepMap '[k] v -> b

O(n). Strictly fold the keys and values using the given right-associative binary operator.

foldrWithKey2' :: (k0 -> k1 -> v -> b -> b) -> b -> DeepMap '[k0, k1] v -> b

O(n). Strictly fold the keys and values using the given right-associative binary operator.

foldrWithKey3' :: (k0 -> k1 -> k2 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2] v -> b

O(n). Strictly fold the keys and values using the given right-associative binary operator.

foldrWithKey4' :: (k0 -> k1 -> k2 -> k3 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2, k3] v -> b

O(n). Strictly fold the keys and values using the given right-associative binary operator.

foldrWithKey5' :: (k0 -> k1 -> k2 -> k3 -> k3 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2, k3, k3] v -> b

O(n). Strictly fold the keys and values using the given right-associative binary operator.

foldlWithKey' :: (b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k ': ks) v -> b

O(n). Strictly fold the keys and submaps in the DeepMap using the given left-associative binary operator.

foldlWithKey1' :: (b -> k -> v -> b) -> b -> DeepMap '[k] v -> b

O(n). Strictly fold the keys and values in the DeepMap using the given left-associative binary operator.

foldlWithKey2' :: (b -> k0 -> k1 -> v -> b) -> b -> DeepMap '[k0, k1] v -> b

O(n). Strictly fold the keys and values in the DeepMap using the given left-associative binary operator.

foldlWithKey3' :: (b -> k0 -> k1 -> k2 -> v -> b) -> b -> DeepMap '[k0, k1, k2] v -> b

O(n). Strictly fold the keys and values in the DeepMap using the given left-associative binary operator.

foldlWithKey4' :: (b -> k0 -> k1 -> k2 -> k3 -> v -> b) -> b -> DeepMap '[k0, k1, k2, k3] v -> b

O(n). Strictly fold the keys and values in the DeepMap using the given left-associative binary operator.

foldlWithKey5' :: (b -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> b) -> b -> DeepMap '[k0, k1, k2, k3, k4] v -> b

O(n). Fold the keys and values in the DeepMap using the given left-associative binary operator.

foldMapWithKey' :: Monoid m => (k -> DeepMap ks v -> m) -> DeepMap (k ': ks) v -> m

O(n). Fold the keys and submaps using the given monoid.

foldMapWithKey1' :: Monoid m => (k -> v -> m) -> DeepMap '[k] v -> m

O(n). Fold the keys and values in the map using the given monoid.

foldMapWithKey2' :: Monoid m => (k0 -> k1 -> v -> m) -> DeepMap '[k0, k1] v -> m

O(n). Fold the keys and values in the map using the given monoid.

foldMapWithKey3' :: Monoid m => (k0 -> k1 -> k2 -> v -> m) -> DeepMap '[k0, k1, k2] v -> m

O(n). Fold the keys and values in the map using the given monoid.

foldMapWithKey4' :: Monoid m => (k0 -> k1 -> k2 -> k3 -> v -> m) -> DeepMap '[k0, k1, k2, k3] v -> m

O(n). Fold the keys and values in the map using the given monoid.

foldMapWithKey5' :: Monoid m => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> m) -> DeepMap '[k0, k1, k2, k3, k4] v -> m

O(n). Fold the keys and values in the map using the given monoid.

Conversion

elems :: DeepMap (k ': ks) v -> [DeepMap ks v]

O(n). Return all submaps of the map in ascending order of its keys. Subject to list fusion.

elems1 :: DeepMap '[k] v -> [v]

O(n). Return all values of the singly-nested map in ascending order of its keys. Subject to list fusion.

keys :: DeepMap (k ': ks) v -> [k]

O(n). Return all keys of the map in ascending order. Subject to list fusion.

assocs :: DeepMap (k ': ks) v -> [(k, DeepMap ks v)]

O(n). Return all pairs of the map in ascending key order. Subject to list fusion.

assocs1 :: DeepMap '[k] v -> [(k, v)]

O(n). Return all pairs of the singly-nested map in ascending key order. Subject to list fusion.

keysSet :: DeepMap (k ': ks) v -> Set k

O(n). The set of all keys of the map.

invertKeys :: (Ord j, Ord k, Semigroup (DeepMap ks v)) => DeepMap (j ': (k ': ks)) v -> DeepMap (k ': (j ': ks)) v

Transpose a DeepMap, by swapping the outer two "dimensions".

Lists

toList :: Foldable t => t a -> [a]

List of elements of a structure, from left to right.

Since: base-4.8.0.0

Ordered lists

toAscList :: DeepMap (k ': ks) v -> [(k, DeepMap ks v)]

O(n). Convert the map to a list of key/submap pairs where the keys are in ascending order. Subject to list fusion.

toDescList :: DeepMap (k ': ks) v -> [(k, DeepMap ks v)]

O(n). Convert the map to a list of key/submap pairs where the keys are in descending order. Subject to list fusion.

Filter

filter :: (DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(n). Filter all submaps that satisfy the predicate.

filter1 :: (v -> Bool) -> DeepMap '[k] v -> DeepMap '[k] v

O(n). Filter all values that satisfy the predicate.

filter2 :: (v -> Bool) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v

O(n). Filter all values that satisfy the predicate.

filter3 :: (v -> Bool) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v

O(n). Filter all values that satisfy the predicate.

filter4 :: (v -> Bool) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v

O(n). Filter all values that satisfy the predicate.

filter5 :: (v -> Bool) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v

O(n). Filter all values that satisfy the predicate.

filterWithKey :: (k -> DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(n). Filter all key/submap pairs that satisfy the predicate.

filterWithKey1 :: (k -> v -> Bool) -> DeepMap '[k] v -> DeepMap '[k] v

O(n). Filter all key/value pairs that satisfy the predicate.

filterWithKey2 :: (k0 -> k1 -> v -> Bool) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v

O(n). Filter all key-chain/value pairs that satisfy the predicate.

filterWithKey3 :: (k0 -> k1 -> k2 -> v -> Bool) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v

O(n). Filter all key-chain/value pairs that satisfy the predicate.

filterWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> Bool) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v

O(n). Filter all key-chain/value pairs that satisfy the predicate.

filterWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Bool) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v

O(n). Filter all key-chain/value pairs that satisfy the predicate.

restrictKeys :: Ord k => DeepMap (k ': ks) v -> Set k -> DeepMap (k ': ks) v

O(m log(n / m + 1)), m <= n. Restrict a Map to only the keys in a given Set.

restrictKeys2 :: (Ord k0, Ord k1) => DeepMap (k0 ': (k1 ': ks)) v -> Set (k0, k1) -> DeepMap (k0 ': (k1 ': ks)) v

O(m log(n / m + 1)), m <= n. Restrict a Map to only the keys in a given Set.

restrictKeys3 :: (Ord k0, Ord k1, Ord k2) => DeepMap (k0 ': (k1 ': (k2 ': ks))) v -> Set (k0, k1, k2) -> DeepMap (k0 ': (k1 ': (k2 ': ks))) v

O(m log(n / m + 1)), m <= n. Restrict a Map to only the keys in a given Set.

restrictKeys4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => DeepMap (k0 ': (k1 ': (k2 ': (k3 ': ks)))) v -> Set (k0, k1, k2, k3) -> DeepMap (k0 ': (k1 ': (k2 ': (k3 ': ks)))) v

O(m log(n / m + 1)), m <= n. Restrict a Map to only the keys in a given Set.

restrictKeys5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => DeepMap (k0 ': (k1 ': (k2 ': (k3 ': (k4 ': ks))))) v -> Set (k0, k1, k2, k3, k4) -> DeepMap (k0 ': (k1 ': (k2 ': (k3 ': (k4 ': ks))))) v

O(m log(n / m + 1)), m <= n. Restrict a Map to only the keys in a given Set.

withoutKeys :: Ord k => DeepMap (k ': ks) v -> Set k -> DeepMap (k ': ks) v

O(m log(n / m + 1)), m <= n. Remove all the keys in a Set from a Map.

withoutKeys2 :: (Ord k0, Ord k1) => DeepMap (k0 ': (k1 ': ks)) v -> Set (k0, k1) -> DeepMap (k0 ': (k1 ': ks)) v

O(m log(n / m + 1)), m <= n. Remove all the keys in a Set from a Map.

withoutKeys3 :: (Ord k0, Ord k1, Ord k2) => DeepMap (k0 ': (k1 ': (k2 ': ks))) v -> Set (k0, k1, k2) -> DeepMap (k0 ': (k1 ': (k2 ': ks))) v

O(m log(n / m + 1)), m <= n. Remove all the keys in a Set from a Map.

withoutKeys4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => DeepMap (k0 ': (k1 ': (k2 ': (k3 ': ks)))) v -> Set (k0, k1, k2, k3) -> DeepMap (k0 ': (k1 ': (k2 ': (k3 ': ks)))) v

O(m log(n / m + 1)), m <= n. Remove all the keys in a Set from a Map.

withoutKeys5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => DeepMap (k0 ': (k1 ': (k2 ': (k3 ': (k4 ': ks))))) v -> Set (k0, k1, k2, k3, k4) -> DeepMap (k0 ': (k1 ': (k2 ': (k3 ': (k4 ': ks))))) v

O(m log(n / m + 1)), m <= n. Remove all the keys in a Set from a Map.

partition :: (DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)

O(n). Partition the map according to a predicate (satisfied, failed).

partition1 :: (v -> Bool) -> DeepMap '[k] v -> (DeepMap '[k] v, DeepMap '[k] v)

O(n). Partition the map according to a predicate (satisfied, failed).

partition2 :: (v -> Bool) -> DeepMap '[k0, k1] v -> (DeepMap '[k0, k1] v, DeepMap '[k0, k1] v)

O(n). Partition the map according to a predicate (satisfied, failed).

partition3 :: (v -> Bool) -> DeepMap '[k0, k1, k2] v -> (DeepMap '[k0, k1, k2] v, DeepMap '[k0, k1, k2] v)

O(n). Partition the map according to a predicate (satisfied, failed).

partition4 :: (v -> Bool) -> DeepMap '[k0, k1, k2, k3] v -> (DeepMap '[k0, k1, k2, k3] v, DeepMap '[k0, k1, k2, k3] v)

O(n). Partition the map according to a predicate (satisfied, failed).

partition5 :: (v -> Bool) -> DeepMap '[k0, k1, k2, k3, k4] v -> (DeepMap '[k0, k1, k2, k3, k4] v, DeepMap '[k0, k1, k2, k3, k4] v)

O(n). Partition the map according to a predicate (satisfied, failed).

partitionWithKey :: (k -> DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)

O(n). Partition the map according to a predicate (satisfied, failed).

partitionWithKey1 :: (k -> v -> Bool) -> DeepMap '[k] v -> (DeepMap '[k] v, DeepMap '[k] v)

O(n). Partition the map according to a predicate (satisfied, failed).

partitionWithKey2 :: (k0 -> k1 -> v -> Bool) -> DeepMap '[k0, k1] v -> (DeepMap '[k0, k1] v, DeepMap '[k0, k1] v)

O(n). Partition the map according to a predicate (satisfied, failed).

partitionWithKey3 :: (k0 -> k1 -> k2 -> v -> Bool) -> DeepMap '[k0, k1, k2] v -> (DeepMap '[k0, k1, k2] v, DeepMap '[k0, k1, k2] v)

O(n). Partition the map according to a predicate (satisfied, failed).

partitionWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> Bool) -> DeepMap '[k0, k1, k2, k3] v -> (DeepMap '[k0, k1, k2, k3] v, DeepMap '[k0, k1, k2, k3] v)

O(n). Partition the map according to a predicate (satisfied, failed).

partitionWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Bool) -> DeepMap '[k0, k1, k2, k3, k4] v -> (DeepMap '[k0, k1, k2, k3, k4] v, DeepMap '[k0, k1, k2, k3, k4] v)

O(n). Partition the map according to a predicate (satisfied, failed).

takeWhileAntitone :: (k -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(n). Take while a predicate on the keys holds. See the note at spanAntitone.

dropWhileAntitone :: (k -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(n). Drop while a predicate on the keys holds. See the note at spanAntitone.

spanAntitone :: (k -> Bool) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)

O(n). Take while a predicate on the keys holds.

NOTE: if p is not actually antitone, then spanAntitone will split the map at some unspecified point where the predicate switches from holding to not holding (where the predicate is seen to hold before the first key and to fail after the last key).

mapMaybe :: (v -> Maybe w) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) w

O(n). Map values and collect the Just results.

mapShallowMaybe :: (DeepMap ks v -> Maybe (DeepMap ls w)) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w

O(n). Map values and collect the Just results. Strictly more general than mapMaybe in that the types of the inner keys can change.

mapShallowMaybeWithKey :: (k -> DeepMap ks v -> Maybe (DeepMap ls w)) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w

O(n). Map values and collect the Just results.

mapMaybeWithKey1 :: (k -> v -> Maybe w) -> DeepMap '[k] v -> DeepMap '[k] w

O(n). Map values and collect the Just results.

mapMaybeWithKey2 :: (k0 -> k1 -> v -> Maybe w) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] w

O(n). Map values and collect the Just results.

mapMaybeWithKey3 :: (k0 -> k1 -> k2 -> v -> Maybe w) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] w

O(n). Map values and collect the Just results.

mapMaybeWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> Maybe w) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] w

O(n). Map values and collect the Just results.

mapMaybeWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Maybe w) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] w

O(n). Map values and collect the Just results.

mapEither :: (v -> Either w x) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) w, DeepMap (k ': ks) x)

O(n). Map values and collect the Left and Right results separately.

mapShallowEither :: (DeepMap ks v -> Either (DeepMap ls w) (DeepMap ms x)) -> DeepMap (k ': ks) v -> (DeepMap (k ': ls) w, DeepMap (k ': ms) x)

O(n). Map values and collect the Left and Right results separately.

mapShallowEitherWithKey :: (k -> DeepMap ks v -> Either (DeepMap ls w) (DeepMap ms x)) -> DeepMap (k ': ks) v -> (DeepMap (k ': ls) w, DeepMap (k ': ms) x)

O(n). Map values and collect the Left and Right results separately.

mapEitherWithKey1 :: (k -> v -> Either w x) -> DeepMap '[k] v -> (DeepMap '[k] w, DeepMap '[k] x)

O(n). Map values and collect the Left and Right results separately.

mapEitherWithKey2 :: (k0 -> k1 -> v -> Either w x) -> DeepMap '[k0, k1] v -> (DeepMap '[k0, k1] w, DeepMap '[k0, k1] x)

O(n). Map values and collect the Left and Right results separately.

mapEitherWithKey3 :: (k0 -> k1 -> k2 -> v -> Either w x) -> DeepMap '[k0, k1, k2] v -> (DeepMap '[k0, k1, k2] w, DeepMap '[k0, k1, k2] x)

O(n). Map values and collect the Left and Right results separately.

mapEitherWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> Either w x) -> DeepMap '[k0, k1, k2, k3] v -> (DeepMap '[k0, k1, k2, k3] w, DeepMap '[k0, k1, k2, k3] x)

O(n). Map values and collect the Left and Right results separately.

mapEitherWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Either w x) -> DeepMap '[k0, k1, k2, k3, k4] v -> (DeepMap '[k0, k1, k2, k3, k4] w, DeepMap '[k0, k1, k2, k3, k4] x)

O(n). Map values and collect the Left and Right results separately.

split :: Ord k => k -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)

O(log n). Partition the map by comparing keys ((smaller, larger) than given).

splitLookup :: Ord k => k -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, Maybe (DeepMap ks v), DeepMap (k ': ks) v)

O(log n). Like split but the middle coordinate lookups the value at the key.

splitRoot :: DeepMap (k ': ks) v -> [DeepMap (k ': ks) v]

O(1). Decompose a map into pieces based on the structure of the underlying tree.

Submap

isSubmapOf :: (Ord k, Eq (DeepMap ks v)) => DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool

O(m log(n / m + 1)), m <= n. Returns True if all the keys in the left map exist in the right, and their values all agree.

isSubmapOfBy :: Ord k => (DeepMap ks v -> DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool

O(m log(n / m + 1)), m <= n. Returns True if all the keys in the left map exist in the right, and the function returns True when applied to respective values.

isProperSubmapOf :: (Ord k, Eq (DeepMap ks v)) => DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool

O(m log(n / m + 1)), m <= n. Returns True if all the keys in the left map exist in the right, and their values all agree, and the maps are not equal.

isProperSubmapOfBy :: Ord k => (DeepMap ks v -> DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool

O(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.

Indexed

lookupIndex :: Ord k => k -> DeepMap (k ': ks) v -> Maybe Int

O(log n). Lookup the index of a key, which is its zero-based index in the ordered sequence of keys.

'lookupIndex' k m == 'Data.List.findIndex' k ('keys' m)

findIndex :: Ord k => k -> DeepMap (k ': ks) v -> Int

O(log n). Lookup the index of a key, which is its zero-based index in the ordered sequence of keys. Calls error when the key is not in the map.

elemAt :: Ord k => Int -> DeepMap (k ': ks) v -> (k, DeepMap ks v)

O(log n). Retrieve an element by its index. Calls error if i is outside the range 0 <= i < size m.

updateAt :: Ord k => (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(log n). Update 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

O(log n). Delete the element by its index. Calls error if i is outside the range 0 <= i < size m.

take :: Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

Take the smallest n keys.

drop :: Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

Drop the smallest n keys.

splitAt :: Int -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)

O(n). Split a map at a particular index.

Min/Max

lookupMin :: DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)

O(log n). The minimal key of the map, or Nothing if the map is empty.

lookupMax :: DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)

O(log n). The maximal key of the map, or Nothing if the map is empty.

findMin :: DeepMap (k ': ks) v -> (k, DeepMap ks v)

O(log n). The minimal key of the map, or error if the map is empty.

findMax :: DeepMap (k ': ks) v -> (k, DeepMap ks v)

O(log n). The maximal key of the map, or error if the map is empty.

deleteMin :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(log n). Delete the minimal key.

deleteMax :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(log n). Delete the maximal key.

deleteFindMin :: DeepMap (k ': ks) v -> ((k, DeepMap ks v), DeepMap (k ': ks) v)

O(log n). Delete and return the minimal key of the map, or error if the map is empty.

deleteFindMax :: DeepMap (k ': ks) v -> ((k, DeepMap ks v), DeepMap (k ': ks) v)

O(log n). Delete and return the maximal key of the map, or error if the map is empty.

updateMin :: (DeepMap ks v -> Maybe (DeepMap ks v)) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(log n). Update the value at the minimal key.

updateMax :: (DeepMap ks v -> Maybe (DeepMap ks v)) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(log n). Update the value at the maximal key.

updateMinWithKey :: (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(log n). Update the value at the minimal key.

updateMaxWithKey :: (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v

O(log n). Update the value at the maximal key.

minView :: DeepMap (k ': ks) v -> Maybe (DeepMap ks v, DeepMap (k ': ks) v)

O(log n). Retrieve the value associated with the minimal key of the map, and the map stripped of that element, or Nothing if passed an empty map.

maxView :: DeepMap (k ': ks) v -> Maybe (DeepMap ks v, DeepMap (k ': ks) v)

O(log n). Retrieve the value associated with the maximal key of the map, and the map stripped of that element, or Nothing if passed an empty map.

minViewWithKey :: DeepMap (k ': ks) v -> Maybe ((k, DeepMap ks v), DeepMap (k ': ks) v)

O(log n). Retrieve the minimal key/value pair of the map, and the map stripped of that element, or Nothing if passed an empty map.

maxViewWithKey :: DeepMap (k ': ks) v -> Maybe ((k, DeepMap ks v), DeepMap (k ': ks) v)

O(log n). Retrieve the maximal key/value pair of the map, and the map stripped of that element, or Nothing if passed an empty map.