Copyright | (c) Melanie Brown 2021 |
---|---|
License | BSD3 (see the file LICENSE) |
Maintainer | brown.m@pm.me |
Safe Haskell | None |
Language | Haskell2010 |
Data.Map.Deep
Description
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.
Synopsis
- data DeepMap (ks :: [Type]) (v :: Type) :: Type where
- onBare2 :: (v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] 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
- empty :: DeepMap (k ': ks) v
- singleton :: k -> v -> DeepMap '[k] v
- (@>) :: k -> DeepMap ks v -> DeepMap (k ': ks) v
- (@|) :: k -> v -> DeepMap '[k] v
- fromList :: (Ord k, Semigroup (DeepMap ks v)) => [(k, DeepMap ks v)] -> DeepMap (k ': ks) v
- fromList1 :: (Ord k, Semigroup v) => [(k, v)] -> DeepMap '[k] v
- fromList2 :: (Ord k0, Ord k1, Semigroup v) => [(k0, k1, v)] -> DeepMap '[k0, k1] v
- fromList3 :: (Ord k0, Ord k1, Ord k2, Semigroup v) => [(k0, k1, k2, v)] -> DeepMap '[k0, k1, k2] v
- fromList4 :: (Ord k0, Ord k1, Ord k2, Ord k3, Semigroup v) => [(k0, k1, k2, k3, v)] -> DeepMap '[k0, k1, k2, k3] v
- 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
- fromListWith :: Ord k => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> [(k, DeepMap ks v)] -> DeepMap (k ': ks) v
- fromListWith1 :: Ord k => (v -> v -> v) -> [(k, v)] -> DeepMap '[k] v
- fromListWithKey :: Ord k => (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> [(k, DeepMap ks v)] -> DeepMap (k ': ks) v
- fromListWithKey1 :: Ord k => (k -> v -> v -> v) -> [(k, v)] -> DeepMap '[k] v
- fromListWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v -> v) -> [(k0, k1, v)] -> DeepMap '[k0, k1] v
- fromListWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> v -> v) -> [(k0, k1, k2, v)] -> DeepMap '[k0, k1, k2] v
- 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
- 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
- toMap :: DeepMap (k ': '[]) v -> Map k v
- fromMap :: Map k v -> DeepMap '[k] v
- insert :: (Ord k, Semigroup (DeepMap ks v)) => k -> DeepMap ks v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- insert1 :: (Ord k, Semigroup v) => k -> v -> DeepMap '[k] v -> DeepMap '[k] v
- insert2 :: (Ord k0, Ord k1, Semigroup v) => k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
- insert3 :: (Ord k0, Ord k1, Ord k2, Semigroup v) => k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
- 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
- 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
- insertWith :: Ord k => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> k -> DeepMap ks v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- insertWith1 :: Ord k => (v -> v -> v) -> k -> v -> DeepMap '[k] v -> DeepMap '[k] v
- insertWith2 :: (Ord k0, Ord k1) => (v -> v -> v) -> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
- insertWith3 :: (Ord k0, Ord k1, Ord k2) => (v -> v -> v) -> k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
- 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
- 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
- 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
- insertWithKey1 :: Ord k => (k -> v -> v -> v) -> k -> v -> DeepMap '[k] v -> DeepMap '[k] v
- insertWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v -> v) -> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
- 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
- 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
- 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
- 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)
- insertLookupWithKey1 :: Ord k => (k -> v -> v -> v) -> k -> v -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v)
- insertLookupWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v -> v) -> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> (Maybe v, DeepMap '[k0, k1] v)
- 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)
- 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)
- 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)
- overwrite :: Ord k => k -> DeepMap ks v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- overwrite1 :: Ord k => k -> v -> DeepMap '[k] v -> DeepMap '[k] v
- overwrite2 :: (Ord k0, Ord k1) => k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
- overwrite3 :: (Ord k0, Ord k1, Ord k2) => k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
- 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
- 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
- overwriteLookup :: Ord k => k -> DeepMap ks v -> DeepMap (k ': ks) v -> (Maybe (DeepMap ks v), DeepMap (k ': ks) v)
- overwriteLookup1 :: Ord k => k -> v -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v)
- overwriteLookup2 :: (Ord k0, Ord k1) => k0 -> k1 -> v -> DeepMap '[k0, k1] v -> (Maybe v, DeepMap '[k0, k1] v)
- overwriteLookup3 :: (Ord k0, Ord k1, Ord k2) => k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> (Maybe v, DeepMap '[k0, k1, k2] v)
- 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)
- 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)
- delete :: Ord k => k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- delete1 :: Ord k => k -> DeepMap '[k] v -> DeepMap '[k] v
- delete2 :: (Ord k0, Ord k1) => k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
- delete3 :: (Ord k0, Ord k1, Ord k2) => k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
- 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
- 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
- adjust :: Ord k => (DeepMap ks v -> DeepMap ks v) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- adjust1 :: Ord k => (v -> v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
- adjust2 :: (Ord k0, Ord k1) => (v -> v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
- adjust3 :: (Ord k0, Ord k1, Ord k2) => (v -> v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
- 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
- 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
- adjustWithKey :: Ord k => (k -> DeepMap ks v -> DeepMap ks v) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- adjustWithKey1 :: Ord k => (k -> v -> v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
- adjustWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
- 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
- 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
- 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
- update :: Ord k => (DeepMap ks v -> Maybe (DeepMap ks v)) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- update1 :: Ord k => (v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
- update2 :: (Ord k0, Ord k1) => (v -> Maybe v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
- update3 :: (Ord k0, Ord k1, Ord k2) => (v -> Maybe v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
- 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
- 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
- updateWithKey :: Ord k => (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- updateWithKey1 :: Ord k => (k -> v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
- updateWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> Maybe v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
- 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
- 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
- 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
- updateLookupWithKey :: Ord k => (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> k -> DeepMap (k ': ks) v -> (Maybe (DeepMap ks v), DeepMap (k ': ks) v)
- updateLookupWithKey1 :: Ord k => (k -> v -> Maybe v) -> k -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v)
- updateLookupWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> Maybe v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> (Maybe v, DeepMap '[k0, k1] v)
- 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)
- 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)
- 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)
- alter :: Ord k => (Maybe (DeepMap ks v) -> Maybe (DeepMap ks v)) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- alter1 :: Ord k => (Maybe v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
- alter2 :: (Ord k0, Ord k1) => (Maybe v -> Maybe v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
- alter3 :: (Ord k0, Ord k1, Ord k2) => (Maybe v -> Maybe v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
- 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
- alter5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (Maybe v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
- alterF :: (Functor f, Ord k) => (Maybe (DeepMap ks v) -> f (Maybe (DeepMap ks v))) -> k -> DeepMap (k ': ks) v -> f (DeepMap (k ': ks) v)
- 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)
- lookup :: Ord k => k -> DeepMap (k ': ks) v -> Maybe (DeepMap ks v)
- (@?) :: Ord k => DeepMap (k ': ks) v -> k -> Maybe (DeepMap ks v)
- (@?|) :: Ord k => DeepMap '[k] v -> k -> Maybe v
- (@??) :: Ord k => Maybe (DeepMap (k ': ks) v) -> k -> Maybe (DeepMap ks v)
- (@??|) :: Ord k => Maybe (DeepMap '[k] v) -> k -> Maybe v
- (@!) :: (Ord k, Monoid (DeepMap ks v)) => DeepMap (k ': ks) v -> k -> DeepMap ks v
- (@!|) :: (Ord k, Monoid v) => DeepMap '[k] v -> k -> v
- findWithDefault :: Ord k => DeepMap ks v -> k -> DeepMap (k ': ks) v -> DeepMap ks v
- findWithDefault1 :: Ord k => v -> k -> DeepMap '[k] v -> v
- findWithDefault2 :: (Ord k0, Ord k1) => v -> k0 -> k1 -> DeepMap '[k0, k1] v -> v
- findWithDefault3 :: (Ord k0, Ord k1, Ord k2) => v -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> v
- findWithDefault4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => v -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> v
- 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
- member :: Ord k => k -> DeepMap (k ': ks) v -> Bool
- notMember :: Ord k => k -> DeepMap (k ': ks) v -> Bool
- lookupLT :: Ord k => k -> DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)
- lookupGT :: Ord k => k -> DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)
- lookupLE :: Ord k => k -> DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)
- lookupGE :: Ord k => k -> DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)
- null :: DeepMap (k ': ks) v -> Bool
- size :: DeepMap (k ': ks) v -> Int
- union :: (Ord k, Semigroup (DeepMap ks v)) => DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- unionWith :: Ord k => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- unionWith1 :: Ord k => (v -> v -> v) -> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
- unionWith2 :: (Ord k0, Ord k1) => (v -> v -> v) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
- 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
- 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
- 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
- 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
- unionWithKey1 :: Ord k => (k -> v -> v -> v) -> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
- unionWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v -> v) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
- 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
- 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
- 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
- unions :: (Foldable t, Ord k, Semigroup (DeepMap ks v)) => t (DeepMap (k ': ks) v) -> DeepMap (k ': ks) v
- unionsWith :: (Foldable t, Ord k) => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> t (DeepMap (k ': ks) v) -> DeepMap (k ': ks) v
- unionsWith1 :: (Foldable t, Ord k) => (v -> v -> v) -> t (DeepMap '[k] v) -> DeepMap '[k] v
- difference :: Ord k => DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v
- (\\) :: Ord k => DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v
- 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
- differenceWith1 :: Ord k => (v -> w -> Maybe v) -> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] v
- 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
- differenceWithKey1 :: Ord k => (k -> v -> w -> Maybe v) -> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] v
- intersection :: Ord k => DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v
- intersectionWith :: Ord k => (DeepMap ks v -> DeepMap ls w -> DeepMap ms x) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ms) x
- intersectionWith1 :: Ord k => (v -> w -> x) -> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] x
- 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
- intersectionWithKey1 :: Ord k => (k -> v -> w -> x) -> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] x
- intersectionWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> w -> x) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] w -> DeepMap '[k0, k1] x
- 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
- 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
- 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
- mapShallow :: (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
- mapWithKey1 :: (k -> v -> w) -> DeepMap '[k] v -> DeepMap '[k] w
- mapWithKey2 :: (k0 -> k1 -> v -> w) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] w
- mapWithKey3 :: (k0 -> k1 -> k2 -> v -> w) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] w
- mapWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> w) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] w
- mapWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> w) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] w
- traverseShallow :: Applicative f => (DeepMap ks v -> f (DeepMap ls w)) -> DeepMap (k ': ks) v -> f (DeepMap (k ': ls) w)
- traverseShallowWithKey :: Applicative f => (k -> DeepMap ks v -> f (DeepMap ls w)) -> DeepMap (k ': ks) v -> f (DeepMap (k ': ls) w)
- traverseWithKey1 :: Applicative f => (k -> v -> f w) -> DeepMap '[k] v -> f (DeepMap '[k] w)
- traverseWithKey2 :: Applicative f => (k0 -> k1 -> v -> f w) -> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] w)
- traverseWithKey3 :: Applicative f => (k0 -> k1 -> k2 -> v -> f w) -> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] w)
- traverseWithKey4 :: Applicative f => (k0 -> k1 -> k2 -> k3 -> v -> f w) -> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] w)
- 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)
- traverseMaybeWithKey :: Applicative f => (k -> DeepMap ks v -> f (Maybe (DeepMap ls w))) -> DeepMap (k ': ks) v -> f (DeepMap (k ': ls) w)
- traverseMaybeWithKey1 :: Applicative f => (k -> v -> f (Maybe w)) -> DeepMap '[k] v -> f (DeepMap '[k] w)
- traverseMaybeWithKey2 :: Applicative f => (k0 -> k1 -> v -> f (Maybe w)) -> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] w)
- traverseMaybeWithKey3 :: Applicative f => (k0 -> k1 -> k2 -> v -> f (Maybe w)) -> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] w)
- traverseMaybeWithKey4 :: Applicative f => (k0 -> k1 -> k2 -> k3 -> v -> f (Maybe w)) -> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] w)
- 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)
- mapAccum :: (acc -> DeepMap ks v -> (acc, DeepMap ls w)) -> acc -> DeepMap (k ': ks) v -> (acc, DeepMap (k ': ls) w)
- mapAccum1 :: (acc -> v -> (acc, w)) -> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
- mapAccumR :: (acc -> DeepMap ks v -> (acc, DeepMap ls w)) -> acc -> DeepMap (k ': ks) v -> (acc, DeepMap (k ': ls) w)
- mapAccumR1 :: (acc -> v -> (acc, w)) -> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
- mapAccumWithKey :: (acc -> k -> DeepMap ks v -> (acc, DeepMap ls w)) -> acc -> DeepMap (k ': ks) v -> (acc, DeepMap (k ': ls) w)
- mapAccumWithKey1 :: (acc -> k -> v -> (acc, w)) -> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
- mapAccumWithKey2 :: (acc -> k0 -> k1 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1] v -> (acc, DeepMap '[k0, k1] w)
- mapAccumWithKey3 :: (acc -> k0 -> k1 -> k2 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2] v -> (acc, DeepMap '[k0, k1, k2] w)
- mapAccumWithKey4 :: (acc -> k0 -> k1 -> k2 -> k3 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2, k3] v -> (acc, DeepMap '[k0, k1, k2, k3] 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)
- mapAccumRWithKey :: (acc -> k -> DeepMap ks v -> (acc, DeepMap ls w)) -> acc -> DeepMap (k ': ks) v -> (acc, DeepMap (k ': ls) w)
- mapAccumRWithKey1 :: (acc -> k -> v -> (acc, w)) -> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
- mapAccumRWithKey2 :: (acc -> k0 -> k1 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1] v -> (acc, DeepMap '[k0, k1] w)
- mapAccumRWithKey3 :: (acc -> k0 -> k1 -> k2 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2] v -> (acc, DeepMap '[k0, k1, k2] w)
- mapAccumRWithKey4 :: (acc -> k0 -> k1 -> k2 -> k3 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2, k3] v -> (acc, DeepMap '[k0, k1, k2, k3] 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)
- mapKeys :: (Ord k, Semigroup (DeepMap ks v)) => (j -> k) -> DeepMap (j ': ks) v -> DeepMap (k ': ks) v
- mapKeys1 :: (Ord k, Semigroup v) => (j -> k) -> DeepMap '[j] v -> DeepMap '[k] v
- mapKeys2 :: (Ord k0, Ord k1, Semigroup (DeepMap ks v)) => (j0 -> k0) -> (j1 -> k1) -> DeepMap (j0 ': (j1 ': ks)) v -> DeepMap (k0 ': (k1 ': ks)) v
- 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
- 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
- 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
- mapKeysWith :: Ord k => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> (j -> k) -> DeepMap (j ': ks) v -> DeepMap (k ': ks) v
- mapKeysWith1 :: Ord k => (v -> v -> v) -> (j -> k) -> DeepMap '[j] v -> DeepMap '[k] v
- mapKeysWith2 :: (Ord k0, Ord k1) => (v -> v -> v) -> (j0 -> k0) -> (j1 -> k1) -> DeepMap '[j0, j1] v -> DeepMap '[k0, k1] v
- 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
- 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
- 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
- traverseKeys :: (Applicative f, Ord k, Semigroup (DeepMap ks v)) => (j -> f k) -> DeepMap (j ': ks) v -> f (DeepMap (k ': ks) v)
- 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)
- mapKeysM :: (Monad m, Ord k, Semigroup (DeepMap ks v)) => (j -> m k) -> DeepMap (j ': ks) v -> m (DeepMap (k ': ks) v)
- mapKeysM1 :: (Monad m, Ord k, Semigroup (DeepMap ks v)) => (j -> m k) -> DeepMap (j ': ks) v -> m (DeepMap (k ': ks) v)
- 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)
- 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)
- 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)
- 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)
- 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)
- mapKeysMWith1 :: (Monad m, Ord k) => (v -> v -> v) -> (j -> m k) -> DeepMap '[j] v -> m (DeepMap '[k] v)
- 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)
- 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)
- 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)
- 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)
- foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
- foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
- 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
- foldrWithKey1 :: (k -> v -> b -> b) -> b -> DeepMap '[k] v -> b
- foldrWithKey2 :: (k0 -> k1 -> v -> b -> b) -> b -> DeepMap '[k0, k1] v -> b
- foldrWithKey3 :: (k0 -> k1 -> k2 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2] v -> b
- foldrWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2, k3] v -> b
- foldrWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k3 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2, k3, k3] v -> b
- foldlWithKey :: (b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k ': ks) v -> b
- foldlWithKey1 :: (b -> k -> v -> b) -> b -> DeepMap '[k] v -> b
- foldlWithKey2 :: (b -> k0 -> k1 -> v -> b) -> b -> DeepMap '[k0, k1] v -> b
- foldlWithKey3 :: (b -> k0 -> k1 -> k2 -> v -> b) -> b -> DeepMap '[k0, k1, k2] v -> b
- foldlWithKey4 :: (b -> k0 -> k1 -> k2 -> k3 -> v -> b) -> b -> DeepMap '[k0, k1, k2, k3] v -> b
- foldlWithKey5 :: (b -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> b) -> b -> DeepMap '[k0, k1, k2, k3, k4] v -> b
- foldMapWithKey :: Monoid m => (k -> DeepMap ks v -> m) -> DeepMap (k ': ks) v -> m
- foldMapWithKey1 :: Monoid m => (k -> v -> m) -> DeepMap '[k] v -> m
- foldMapWithKey2 :: Monoid m => (k0 -> k1 -> v -> m) -> DeepMap '[k0, k1] v -> m
- foldMapWithKey3 :: Monoid m => (k0 -> k1 -> k2 -> v -> m) -> DeepMap '[k0, k1, k2] v -> m
- foldMapWithKey4 :: Monoid m => (k0 -> k1 -> k2 -> k3 -> v -> m) -> DeepMap '[k0, k1, k2, k3] v -> m
- foldMapWithKey5 :: Monoid m => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> m) -> DeepMap '[k0, k1, k2, k3, k4] v -> m
- foldr' :: Foldable t => (a -> b -> b) -> b -> t a -> b
- foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
- foldrWithKey' :: (k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k ': ks) v -> b
- foldrWithKey1' :: (k -> v -> b -> b) -> b -> DeepMap '[k] v -> b
- foldrWithKey2' :: (k0 -> k1 -> v -> b -> b) -> b -> DeepMap '[k0, k1] v -> b
- foldrWithKey3' :: (k0 -> k1 -> k2 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2] v -> b
- foldrWithKey4' :: (k0 -> k1 -> k2 -> k3 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2, k3] v -> b
- foldrWithKey5' :: (k0 -> k1 -> k2 -> k3 -> k3 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2, k3, k3] v -> b
- foldlWithKey' :: (b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k ': ks) v -> b
- foldlWithKey1' :: (b -> k -> v -> b) -> b -> DeepMap '[k] v -> b
- foldlWithKey2' :: (b -> k0 -> k1 -> v -> b) -> b -> DeepMap '[k0, k1] v -> b
- foldlWithKey3' :: (b -> k0 -> k1 -> k2 -> v -> b) -> b -> DeepMap '[k0, k1, k2] v -> b
- foldlWithKey4' :: (b -> k0 -> k1 -> k2 -> k3 -> v -> b) -> b -> DeepMap '[k0, k1, k2, k3] v -> b
- foldlWithKey5' :: (b -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> b) -> b -> DeepMap '[k0, k1, k2, k3, k4] v -> b
- elems :: DeepMap (k ': ks) v -> [DeepMap ks v]
- elems1 :: DeepMap '[k] v -> [v]
- keys :: DeepMap (k ': ks) v -> [k]
- assocs :: DeepMap (k ': ks) v -> [(k, DeepMap ks v)]
- assocs1 :: DeepMap '[k] v -> [(k, v)]
- keysSet :: DeepMap (k ': ks) v -> Set k
- invertKeys :: (Ord j, Ord k, Semigroup (DeepMap ks v)) => DeepMap (j ': (k ': ks)) v -> DeepMap (k ': (j ': ks)) v
- toList :: Foldable t => t a -> [a]
- toAscList :: DeepMap (k ': ks) v -> [(k, DeepMap ks v)]
- toDescList :: DeepMap (k ': ks) v -> [(k, DeepMap ks v)]
- filter :: (DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- filter1 :: (v -> Bool) -> DeepMap '[k] v -> DeepMap '[k] v
- filter2 :: (v -> Bool) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
- filter3 :: (v -> Bool) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
- filter4 :: (v -> Bool) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
- filter5 :: (v -> Bool) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
- filterWithKey :: (k -> DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- filterWithKey1 :: (k -> v -> Bool) -> DeepMap '[k] v -> DeepMap '[k] v
- filterWithKey2 :: (k0 -> k1 -> v -> Bool) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
- filterWithKey3 :: (k0 -> k1 -> k2 -> v -> Bool) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
- filterWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> Bool) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
- filterWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Bool) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
- restrictKeys :: Ord k => DeepMap (k ': ks) v -> Set k -> DeepMap (k ': ks) v
- restrictKeys2 :: (Ord k0, Ord k1) => DeepMap (k0 ': (k1 ': ks)) v -> Set (k0, k1) -> DeepMap (k0 ': (k1 ': ks)) v
- restrictKeys3 :: (Ord k0, Ord k1, Ord k2) => DeepMap (k0 ': (k1 ': (k2 ': ks))) v -> Set (k0, k1, k2) -> DeepMap (k0 ': (k1 ': (k2 ': ks))) v
- 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
- 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
- withoutKeys :: Ord k => DeepMap (k ': ks) v -> Set k -> DeepMap (k ': ks) v
- withoutKeys2 :: (Ord k0, Ord k1) => DeepMap (k0 ': (k1 ': ks)) v -> Set (k0, k1) -> DeepMap (k0 ': (k1 ': ks)) v
- withoutKeys3 :: (Ord k0, Ord k1, Ord k2) => DeepMap (k0 ': (k1 ': (k2 ': ks))) v -> Set (k0, k1, k2) -> DeepMap (k0 ': (k1 ': (k2 ': ks))) v
- 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
- 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
- partition :: (DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)
- partition1 :: (v -> Bool) -> DeepMap '[k] v -> (DeepMap '[k] v, DeepMap '[k] v)
- partition2 :: (v -> Bool) -> DeepMap '[k0, k1] v -> (DeepMap '[k0, k1] v, DeepMap '[k0, k1] v)
- partition3 :: (v -> Bool) -> DeepMap '[k0, k1, k2] v -> (DeepMap '[k0, k1, k2] v, DeepMap '[k0, k1, k2] v)
- partition4 :: (v -> Bool) -> DeepMap '[k0, k1, k2, k3] v -> (DeepMap '[k0, k1, k2, k3] v, DeepMap '[k0, k1, k2, k3] 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)
- partitionWithKey :: (k -> DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)
- partitionWithKey1 :: (k -> v -> Bool) -> DeepMap '[k] v -> (DeepMap '[k] v, DeepMap '[k] v)
- partitionWithKey2 :: (k0 -> k1 -> v -> Bool) -> DeepMap '[k0, k1] v -> (DeepMap '[k0, k1] v, DeepMap '[k0, k1] v)
- partitionWithKey3 :: (k0 -> k1 -> k2 -> v -> Bool) -> DeepMap '[k0, k1, k2] v -> (DeepMap '[k0, k1, k2] v, DeepMap '[k0, k1, k2] 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)
- 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)
- takeWhileAntitone :: (k -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- dropWhileAntitone :: (k -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- spanAntitone :: (k -> Bool) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)
- mapMaybe :: (v -> Maybe w) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) w
- mapShallowMaybe :: (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
- mapMaybeWithKey1 :: (k -> v -> Maybe w) -> DeepMap '[k] v -> DeepMap '[k] w
- mapMaybeWithKey2 :: (k0 -> k1 -> v -> Maybe w) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] w
- mapMaybeWithKey3 :: (k0 -> k1 -> k2 -> v -> Maybe w) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] w
- mapMaybeWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> Maybe w) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] w
- mapMaybeWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Maybe w) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] w
- mapEither :: (v -> Either w x) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) w, DeepMap (k ': ks) x)
- mapShallowEither :: (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)
- mapEitherWithKey1 :: (k -> v -> Either w x) -> DeepMap '[k] v -> (DeepMap '[k] w, DeepMap '[k] x)
- mapEitherWithKey2 :: (k0 -> k1 -> v -> Either w x) -> DeepMap '[k0, k1] v -> (DeepMap '[k0, k1] w, DeepMap '[k0, k1] x)
- mapEitherWithKey3 :: (k0 -> k1 -> k2 -> v -> Either w x) -> DeepMap '[k0, k1, k2] v -> (DeepMap '[k0, k1, k2] w, DeepMap '[k0, k1, k2] 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)
- 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)
- split :: Ord k => k -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)
- splitLookup :: Ord k => k -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, Maybe (DeepMap ks v), DeepMap (k ': ks) v)
- splitRoot :: DeepMap (k ': ks) v -> [DeepMap (k ': ks) v]
- isSubmapOf :: (Ord k, Eq (DeepMap ks v)) => DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool
- isSubmapOfBy :: Ord k => (DeepMap ks v -> DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool
- isProperSubmapOf :: (Ord k, Eq (DeepMap ks v)) => DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool
- isProperSubmapOfBy :: Ord k => (DeepMap ks v -> DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool
- lookupIndex :: Ord k => k -> DeepMap (k ': ks) v -> Maybe Int
- findIndex :: Ord k => k -> DeepMap (k ': ks) v -> Int
- elemAt :: Ord k => Int -> DeepMap (k ': ks) v -> (k, DeepMap ks v)
- updateAt :: Ord k => (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- deleteAt :: Ord k => (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- take :: Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- drop :: Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- splitAt :: Int -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)
- lookupMin :: DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)
- lookupMax :: DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)
- findMin :: DeepMap (k ': ks) v -> (k, DeepMap ks v)
- findMax :: DeepMap (k ': ks) v -> (k, DeepMap ks v)
- deleteMin :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- deleteMax :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v
- deleteFindMin :: 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)
- updateMin :: (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
- updateMinWithKey :: (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
- minView :: 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)
- minViewWithKey :: 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)
Map type
data DeepMap (ks :: [Type]) (v :: Type) :: Type where Source #
Instances
FunctorWithIndex () (DeepMap ('[] :: [Type])) Source # | |
Defined in Data.Map.Deep | |
FoldableWithIndex () (DeepMap ('[] :: [Type])) Source # | |
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 # | |
TraversableWithIndex () (DeepMap ('[] :: [Type])) Source # | |
Defined in Data.Map.Deep Methods itraverse :: Applicative f => (() -> a -> f b) -> DeepMap '[] a -> f (DeepMap '[] b) # | |
Functor (DeepMap ks) Source # | |
Foldable (DeepMap ks) Source # | |
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 # | |
Traversable (DeepMap ks) Source # | |
Defined in Data.Map.Deep | |
(Eq k, Eq (DeepMap ks v)) => Eq (DeepMap (k ': ks) v) Source # | |
Eq v => Eq (DeepMap ('[] :: [Type]) v) Source # | |
(Ord k, Data k, Typeable ks, Typeable v, Data (DeepMap ks v)) => Data (DeepMap (k ': ks) v) Source # | |
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) Source # | |
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) Source # | |
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) Source # | |
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 # | |
(Show k, Show (DeepMap ks v)) => Show (DeepMap (k ': ks) v) Source # | |
Show v => Show (DeepMap ('[] :: [Type]) v) Source # | |
(Ord k, Generic k, Generic (DeepMap ks v)) => Generic (DeepMap (k ': ks) v) Source # | |
Generic v => Generic (DeepMap ('[] :: [Type]) v) Source # | |
(Ord k, Semigroup (DeepMap ks v)) => Semigroup (DeepMap (k ': ks) v) Source # | |
Semigroup v => Semigroup (DeepMap ('[] :: [Type]) v) Source # | |
(Ord k, Semigroup (DeepMap ks v)) => Monoid (DeepMap (k ': ks) v) Source # | |
Monoid v => Monoid (DeepMap ('[] :: [Type]) v) Source # | |
TraversableWithIndex ki (DeepMap ks) => FunctorWithIndex (k, ki) (DeepMap (k ': ks)) Source # | |
Defined in Data.Map.Deep | |
TraversableWithIndex ki (DeepMap ks) => FoldableWithIndex (k, ki) (DeepMap (k ': ks)) Source # | |
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)) Source # | |
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) Source # | |
type Rep (DeepMap ('[] :: [Type]) v) Source # | |
onBare2 :: (v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x Source #
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 Source #
Construction
From Unordered Lists
fromList :: (Ord k, Semigroup (DeepMap ks v)) => [(k, DeepMap ks v)] -> DeepMap (k ': ks) v Source #
fromList3 :: (Ord k0, Ord k1, Ord k2, Semigroup v) => [(k0, k1, k2, v)] -> DeepMap '[k0, k1, k2] v Source #
fromList4 :: (Ord k0, Ord k1, Ord k2, Ord k3, Semigroup v) => [(k0, k1, k2, k3, v)] -> DeepMap '[k0, k1, k2, k3] v Source #
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 Source #
fromListWith :: Ord k => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> [(k, DeepMap ks v)] -> DeepMap (k ': ks) v Source #
fromListWith1 :: Ord k => (v -> v -> v) -> [(k, v)] -> DeepMap '[k] v Source #
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 Source #
fromListWithKey1 :: Ord k => (k -> v -> v -> v) -> [(k, v)] -> DeepMap '[k] v Source #
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 Source #
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 Source #
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 Source #
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 Source #
O(n log n). Build a depth-3 DeepMap
from a list of keys and values with a combining function.
Single-depth map isomorphisms
Insertion
insert :: (Ord k, Semigroup (DeepMap ks v)) => k -> DeepMap ks v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v Source #
insert1 :: (Ord k, Semigroup v) => k -> v -> DeepMap '[k] v -> DeepMap '[k] v Source #
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
.
The overwriting behaviour from <>
newcontainers
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 Source #
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
.
The overwriting behaviour from <>
newcontainers
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 Source #
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
.
so the overwriting behaviour from <>
newcontainers
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 Source #
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
.
so the overwriting behaviour from <>
newcontainers
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 Source #
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
.
so the overwriting behaviour from <>
newcontainers
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 Source #
O(log n). Insert with a function, combining new value and old value using the supplied function.
will insert insertWith
(~~) k new mnew
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 Source #
O(log n). Insert with a function, combining new value and old value using the supplied function.
will insert insertWith1
(~~) k new mnew
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
O(log n). Insert with a function, combining new value and old value using the supplied function.
will insert insertWithKey
f k new mnew
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
O(log n). Combines insertion and retrieval.
overwrite1 :: Ord k => k -> v -> DeepMap '[k] v -> DeepMap '[k] v Source #
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 Source #
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 Source #
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 Source #
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 Source #
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) Source #
O(log n). Combines replacement and retrieval.
overwriteLookup1 :: Ord k => k -> v -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v) Source #
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) Source #
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) Source #
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) Source #
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) Source #
O(log n). Combines replacement and retrieval at depth 5.
Deletion/Update
delete :: Ord k => k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
update2 :: (Ord k0, Ord k1) => (v -> Maybe v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v Source #
update3 :: (Ord k0, Ord k1, Ord k2) => (v -> Maybe v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v Source #
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 Source #
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 Source #
updateWithKey :: Ord k => (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v Source #
updateWithKey1 :: Ord k => (k -> v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v Source #
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 Source #
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 Source #
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 Source #
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 Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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 Source #
alter2 :: (Ord k0, Ord k1) => (Maybe v -> Maybe v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v Source #
alter3 :: (Ord k0, Ord k1, Ord k2) => (Maybe v -> Maybe v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v Source #
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 Source #
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 Source #
alterF :: (Functor f, Ord k) => (Maybe (DeepMap ks v) -> f (Maybe (DeepMap ks v))) -> k -> DeepMap (k ': ks) v -> f (DeepMap (k ': ks) v) Source #
alterF1 :: (Functor f, Ord k) => (Maybe v -> f (Maybe v)) -> k -> DeepMap '[k] v -> f (DeepMap '[k] v) Source #
alterF2 :: (Functor f, Ord k0, Ord k1) => (Maybe v -> f (Maybe v)) -> k0 -> k1 -> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] v) Source #
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) Source #
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) Source #
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) Source #
Query
Lookup
lookup :: Ord k => k -> DeepMap (k ': ks) v -> Maybe (DeepMap ks v) Source #
O(log n). Lookup the value at a key.
(@?) :: Ord k => DeepMap (k ': ks) v -> k -> Maybe (DeepMap ks v) Source #
O(log n). A flipped, infix variant of lookup
.
(@?|) :: Ord k => DeepMap '[k] v -> k -> Maybe v Source #
O(log n). A flipped, infix variant of lookup1
.
(@??) :: Ord k => Maybe (DeepMap (k ': ks) v) -> k -> Maybe (DeepMap ks v) Source #
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 Source #
O(log n). Facilitates chaining of lookups. For m :: DeepMap '[k0, k1, k2] v
,
>>>
m @? k0 @?? k1 @??| k2 == (m @? k0) >>= (@? k1) >>= (@?| k2)
findWithDefault :: Ord k => DeepMap ks v -> k -> DeepMap (k ': ks) v -> DeepMap ks v Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
O(log n). Is the key a member of the map? See also notMember
.
notMember :: Ord k => k -> DeepMap (k ': ks) v -> Bool Source #
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) Source #
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) Source #
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) Source #
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) Source #
Find the smallest key down to the given one, and return its key/value pair.
Size
Combine
Union
union :: (Ord k, Semigroup (DeepMap ks v)) => DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v Source #
unionWith :: Ord k => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
O(m log(n / m + 1)), m <= n. Join two DeepMap
s 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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
O(m log(n / m + 1)), m <= n. Join two DeepMap
s 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 Source #
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 Source #
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 Source #
The union of a list of DeepMap
s, combining with a specified operation.
Difference
difference :: Ord k => DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
O(n). Like mapShallow
but the function has access to the outer keys.
mapWithKey1 :: (k -> v -> w) -> DeepMap '[k] v -> DeepMap '[k] w Source #
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 Source #
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 Source #
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 Source #
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 Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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
foldrWithKey :: (k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k ': ks) v -> b Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
O(n). Fold the keys and submaps using the given monoid.
foldMapWithKey1 :: Monoid m => (k -> v -> m) -> DeepMap '[k] v -> m Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
O(n). Fold the keys and values in the DeepMap
using the given left-associative binary operator.
Conversion
elems :: DeepMap (k ': ks) v -> [DeepMap ks v] Source #
O(n). Return all submaps of the map in ascending order of its keys. Subject to list fusion.
elems1 :: DeepMap '[k] v -> [v] Source #
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] Source #
O(n). Return all keys of the map in ascending order. Subject to list fusion.
assocs :: DeepMap (k ': ks) v -> [(k, DeepMap ks v)] Source #
O(n). Return all pairs of the map in ascending key order. Subject to list fusion.
assocs1 :: DeepMap '[k] v -> [(k, v)] Source #
O(n). Return all pairs of the singly-nested map in ascending key order. Subject to list fusion.
invertKeys :: (Ord j, Ord k, Semigroup (DeepMap ks v)) => DeepMap (j ': (k ': ks)) v -> DeepMap (k ': (j ': ks)) v Source #
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)] Source #
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)] Source #
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 Source #
O(n). Filter all submaps that satisfy the predicate.
filter1 :: (v -> Bool) -> DeepMap '[k] v -> DeepMap '[k] v Source #
O(n). Filter all values that satisfy the predicate.
filter2 :: (v -> Bool) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v Source #
O(n). Filter all values that satisfy the predicate.
filter3 :: (v -> Bool) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v Source #
O(n). Filter all values that satisfy the predicate.
filter4 :: (v -> Bool) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v Source #
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 Source #
O(n). Filter all values that satisfy the predicate.
filterWithKey :: (k -> DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v Source #
O(n). Filter all key/submap pairs that satisfy the predicate.
filterWithKey1 :: (k -> v -> Bool) -> DeepMap '[k] v -> DeepMap '[k] v Source #
O(n). Filter all key/value pairs that satisfy the predicate.
filterWithKey2 :: (k0 -> k1 -> v -> Bool) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v Source #
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 Source #
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 Source #
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 Source #
O(n). Filter all key-chain/value pairs that satisfy the predicate.
restrictKeys2 :: (Ord k0, Ord k1) => DeepMap (k0 ': (k1 ': ks)) v -> Set (k0, k1) -> DeepMap (k0 ': (k1 ': ks)) v Source #
restrictKeys3 :: (Ord k0, Ord k1, Ord k2) => DeepMap (k0 ': (k1 ': (k2 ': ks))) v -> Set (k0, k1, k2) -> DeepMap (k0 ': (k1 ': (k2 ': ks))) v Source #
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 Source #
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 Source #
withoutKeys2 :: (Ord k0, Ord k1) => DeepMap (k0 ': (k1 ': ks)) v -> Set (k0, k1) -> DeepMap (k0 ': (k1 ': ks)) v Source #
withoutKeys3 :: (Ord k0, Ord k1, Ord k2) => DeepMap (k0 ': (k1 ': (k2 ': ks))) v -> Set (k0, k1, k2) -> DeepMap (k0 ': (k1 ': (k2 ': ks))) v Source #
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 Source #
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 Source #
partition :: (DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v) Source #
O(n). Partition the map according to a predicate (satisfied, failed).
partition1 :: (v -> Bool) -> DeepMap '[k] v -> (DeepMap '[k] v, DeepMap '[k] v) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
O(n). Partition the map according to a predicate (satisfied, failed).
partitionWithKey1 :: (k -> v -> Bool) -> DeepMap '[k] v -> (DeepMap '[k] v, DeepMap '[k] v) Source #
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) Source #
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) Source #
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) Source #
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) Source #
O(n). Partition the map according to a predicate (satisfied, failed).
takeWhileAntitone :: (k -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v Source #
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 Source #
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) Source #
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 Source #
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 Source #
mapShallowMaybeWithKey :: (k -> DeepMap ks v -> Maybe (DeepMap ls w)) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w Source #
O(n). Map values and collect the Just
results.
mapMaybeWithKey1 :: (k -> v -> Maybe w) -> DeepMap '[k] v -> DeepMap '[k] w Source #
O(n). Map values and collect the Just
results.
mapMaybeWithKey2 :: (k0 -> k1 -> v -> Maybe w) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] w Source #
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 Source #
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 Source #
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 Source #
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) Source #
mapShallowEither :: (DeepMap ks v -> Either (DeepMap ls w) (DeepMap ms x)) -> DeepMap (k ': ks) v -> (DeepMap (k ': ls) w, DeepMap (k ': ms) x) Source #
mapShallowEitherWithKey :: (k -> DeepMap ks v -> Either (DeepMap ls w) (DeepMap ms x)) -> DeepMap (k ': ks) v -> (DeepMap (k ': ls) w, DeepMap (k ': ms) x) Source #
mapEitherWithKey1 :: (k -> v -> Either w x) -> DeepMap '[k] v -> (DeepMap '[k] w, DeepMap '[k] x) Source #
mapEitherWithKey2 :: (k0 -> k1 -> v -> Either w x) -> DeepMap '[k0, k1] v -> (DeepMap '[k0, k1] w, DeepMap '[k0, k1] x) Source #
mapEitherWithKey3 :: (k0 -> k1 -> k2 -> v -> Either w x) -> DeepMap '[k0, k1, k2] v -> (DeepMap '[k0, k1, k2] w, DeepMap '[k0, k1, k2] x) Source #
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) Source #
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) Source #
split :: Ord k => k -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v) Source #
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) Source #
splitRoot :: DeepMap (k ': ks) v -> [DeepMap (k ': ks) v] Source #
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 Source #
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 Source #
isProperSubmapOf :: (Ord k, Eq (DeepMap ks v)) => DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool Source #
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 Source #
Indexed
lookupIndex :: Ord k => k -> DeepMap (k ': ks) v -> Maybe Int Source #
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 Source #
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.
updateAt :: Ord k => (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v Source #
deleteAt :: Ord k => (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v Source #
splitAt :: Int -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v) Source #
O(n). Split a map at a particular index.
Min/Max
lookupMin :: DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v) Source #
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) Source #
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) Source #
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) Source #
O(log n). The maximal key of the map, or error
if the map is empty.
deleteFindMin :: DeepMap (k ': ks) v -> ((k, DeepMap ks v), DeepMap (k ': ks) v) Source #
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) Source #
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 Source #
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 Source #
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 Source #
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 Source #
O(log n). Update the value at the maximal key.
minView :: DeepMap (k ': ks) v -> Maybe (DeepMap ks v, DeepMap (k ': ks) v) Source #
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) Source #
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.