module Hix.Class.Map where

import qualified Data.Map.Merge.Strict as Map
import Data.Map.Merge.Strict (
  SimpleWhenMatched,
  SimpleWhenMissing,
  WhenMatched,
  WhenMissing,
  dropMissing,
  mapMissing,
  preserveMissing,
  zipWithMatched,
  )
import qualified Data.Map.Strict as Map
import Distribution.Pretty (Pretty (pretty))
import Exon (exon)
import qualified Text.PrettyPrint as PrettyPrint
import Text.PrettyPrint (Doc, comma, hang, punctuate, sep, vcat, (<+>))

import Hix.Data.Monad (M)
import Hix.Monad (noteFatal)

data LookupMonoid
data LookupMaybe
data LookupFatal

type NMap :: Type -> Type -> Type -> Type -> Constraint
class (Ord k, Coercible map (Map k v)) => NMap map k v sort | map -> k v sort where
  nGet :: map -> Map k v
  nGet = map -> Map k v
forall a b. Coercible a b => a -> b
coerce

lookupError ::
  ∀ k v .
  Show k =>
  Text ->
  k ->
  Maybe v ->
  M v
lookupError :: forall k v. Show k => Text -> k -> Maybe v -> M v
lookupError Text
thing k
k =
  Text -> Maybe v -> M v
forall a. Text -> Maybe a -> M a
noteFatal [exon|No such #{thing}: #{show k}|]

nFatal ::
  ∀ map k v sort .
  Show k =>
  NMap map k v sort =>
  Text ->
  k ->
  map ->
  M v
nFatal :: forall map k v sort.
(Show k, NMap map k v sort) =>
Text -> k -> map -> M v
nFatal Text
thing k
k map
m =
  Text -> k -> Maybe v -> M v
forall k v. Show k => Text -> k -> Maybe v -> M v
lookupError Text
thing k
k (map -> Map k v
forall map k v sort. NMap map k v sort => map -> Map k v
nGet map
m Map k v -> k -> Maybe v
forall k a. Ord k => Map k a -> k -> Maybe a
Map.!? k
k)

type NLookup :: Type -> Type -> Type -> Type -> Constraint
class NLookup sort k v l | sort v -> l where
  nLookup :: k -> Maybe v -> l

instance Monoid v => NLookup LookupMonoid k v v where
  nLookup :: k -> Maybe v -> v
nLookup k
_ = Maybe v -> v
forall m. Monoid m => Maybe m -> m
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold

instance NLookup LookupMaybe k v (Maybe v) where
  nLookup :: k -> Maybe v -> Maybe v
nLookup k
_ = Maybe v -> Maybe v
forall a. a -> a
id

instance Show k => NLookup LookupFatal k v (Text -> M v) where
  nLookup :: k -> Maybe v -> Text -> M v
nLookup k
k Maybe v
v Text
thing = Text -> k -> Maybe v -> M v
forall k v. Show k => Text -> k -> Maybe v -> M v
lookupError Text
thing k
k Maybe v
v

(!?) ::
  ∀ map k v sort .
  NMap map k v sort =>
  map ->
  k ->
  Maybe v
!? :: forall map k v sort. NMap map k v sort => map -> k -> Maybe v
(!?) map
m k
k = map -> Map k v
forall map k v sort. NMap map k v sort => map -> Map k v
nGet map
m Map k v -> k -> Maybe v
forall k a. Ord k => Map k a -> k -> Maybe a
Map.!? k
k

infixl !?

(!!) ::
  ∀ map k v sort l .
  NMap map k v sort =>
  NLookup sort k v l =>
  map ->
  k ->
  l
!! :: forall map k v sort l.
(NMap map k v sort, NLookup sort k v l) =>
map -> k -> l
(!!) map
m k
k = forall sort k v l. NLookup sort k v l => k -> Maybe v -> l
nLookup @sort @k @v @l k
k (map
m map -> k -> Maybe v
forall map k v sort. NMap map k v sort => map -> k -> Maybe v
!? k
k)

infixl !!

nInsert ::
  ∀ map k v sort .
  NMap map k v sort =>
  k ->
  v ->
  map ->
  map
nInsert :: forall map k v sort. NMap map k v sort => k -> v -> map -> map
nInsert k
k v
v map
m =
  Map k v -> map
forall a b. Coercible a b => a -> b
coerce (k -> v -> Map k v -> Map k v
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert k
k v
v (map -> Map k v
forall map k v sort. NMap map k v sort => map -> Map k v
nGet map
m))

nUpdate ::
  ∀ map k v sort l .
  NMap map k v sort =>
  NLookup sort k v l =>
  k ->
  map ->
  (l -> v) ->
  map
nUpdate :: forall map k v sort l.
(NMap map k v sort, NLookup sort k v l) =>
k -> map -> (l -> v) -> map
nUpdate k
k map
m l -> v
f =
  k -> v -> map -> map
forall map k v sort. NMap map k v sort => k -> v -> map -> map
nInsert k
k (l -> v
f (map
m map -> k -> l
forall map k v sort l.
(NMap map k v sort, NLookup sort k v l) =>
map -> k -> l
!! k
k)) map
m

nUpdateWith ::
  ∀ map k v sort l .
  NMap map k v sort =>
  NLookup sort k v l =>
  k ->
  (l -> v) ->
  map ->
  map
nUpdateWith :: forall map k v sort l.
(NMap map k v sort, NLookup sort k v l) =>
k -> (l -> v) -> map -> map
nUpdateWith k
k =
  (map -> (l -> v) -> map) -> (l -> v) -> map -> map
forall a b c. (a -> b -> c) -> b -> a -> c
flip (k -> map -> (l -> v) -> map
forall map k v sort l.
(NMap map k v sort, NLookup sort k v l) =>
k -> map -> (l -> v) -> map
nUpdate k
k)

nAdjust ::
  ∀ map k v sort .
  NMap map k v sort =>
  k ->
  map ->
  (v -> v) ->
  map
nAdjust :: forall map k v sort.
NMap map k v sort =>
k -> map -> (v -> v) -> map
nAdjust k
k map
m v -> v
f =
  (Map k v -> Map k v) -> map -> map
forall map1 k1 v1 s1 map2 k2 v2 s2.
(NMap map1 k1 v1 s1, NMap map2 k2 v2 s2) =>
(Map k1 v1 -> Map k2 v2) -> map1 -> map2
nVia ((v -> v) -> k -> Map k v -> Map k v
forall k a. Ord k => (a -> a) -> k -> Map k a -> Map k a
Map.adjust v -> v
f k
k) map
m

nVia ::
  NMap map1 k1 v1 s1 =>
  NMap map2 k2 v2 s2 =>
  (Map k1 v1 -> Map k2 v2) ->
  map1 ->
  map2
nVia :: forall map1 k1 v1 s1 map2 k2 v2 s2.
(NMap map1 k1 v1 s1, NMap map2 k2 v2 s2) =>
(Map k1 v1 -> Map k2 v2) -> map1 -> map2
nVia =
  (Map k1 v1 -> Map k2 v2) -> map1 -> map2
forall a b. Coercible a b => a -> b
coerce

nViaA ::
  Applicative m =>
  NMap map1 k1 v1 s1 =>
  NMap map2 k2 v2 s2 =>
  (Map k1 v1 -> m (Map k2 v2)) ->
  map1 ->
  m map2
nViaA :: forall (m :: * -> *) map1 k1 v1 s1 map2 k2 v2 s2.
(Applicative m, NMap map1 k1 v1 s1, NMap map2 k2 v2 s2) =>
(Map k1 v1 -> m (Map k2 v2)) -> map1 -> m map2
nViaA Map k1 v1 -> m (Map k2 v2)
f map1
m =
  Map k2 v2 -> map2
forall a b. Coercible a b => a -> b
coerce (Map k2 v2 -> map2) -> m (Map k2 v2) -> m map2
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map k1 v1 -> m (Map k2 v2)
f (map1 -> Map k1 v1
forall a b. Coercible a b => a -> b
coerce map1
m)

nMapKeys ::
  NMap map1 k1 v sort1 =>
  NMap map2 k2 v sort2 =>
  (k1 -> k2) ->
  map1 ->
  map2
nMapKeys :: forall map1 k1 v sort1 map2 k2 sort2.
(NMap map1 k1 v sort1, NMap map2 k2 v sort2) =>
(k1 -> k2) -> map1 -> map2
nMapKeys k1 -> k2
f =
  (Map k1 v -> Map k2 v) -> map1 -> map2
forall map1 k1 v1 s1 map2 k2 v2 s2.
(NMap map1 k1 v1 s1, NMap map2 k2 v2 s2) =>
(Map k1 v1 -> Map k2 v2) -> map1 -> map2
nVia ((k1 -> k2) -> Map k1 v -> Map k2 v
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys k1 -> k2
f)

nMap ::
  NMap map1 k v1 sort1 =>
  NMap map2 k v2 sort2 =>
  (v1 -> v2) ->
  map1 ->
  map2
nMap :: forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(v1 -> v2) -> map1 -> map2
nMap v1 -> v2
f =
  Map k v2 -> map2
forall a b. Coercible a b => a -> b
coerce (Map k v2 -> map2) -> (map1 -> Map k v2) -> map1 -> map2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v1 -> v2) -> Map k v1 -> Map k v2
forall a b. (a -> b) -> Map k a -> Map k b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap v1 -> v2
f (Map k v1 -> Map k v2) -> (map1 -> Map k v1) -> map1 -> Map k v2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. map1 -> Map k v1
forall map k v sort. NMap map k v sort => map -> Map k v
nGet

nMap1 ::
  ∀ map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2' .
  NMap map1 k map1' s1 =>
  NMap map2 k map2' s2 =>
  NMap map1' k' v1 s1' =>
  NMap map2' k' v2 s2' =>
  (v1 -> v2) ->
  map1 ->
  map2
nMap1 :: forall map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2'.
(NMap map1 k map1' s1, NMap map2 k map2' s2, NMap map1' k' v1 s1',
 NMap map2' k' v2 s2') =>
(v1 -> v2) -> map1 -> map2
nMap1 =
  (map1' -> map2') -> map1 -> map2
forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(v1 -> v2) -> map1 -> map2
nMap ((map1' -> map2') -> map1 -> map2)
-> ((v1 -> v2) -> map1' -> map2') -> (v1 -> v2) -> map1 -> map2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v1 -> v2) -> map1' -> map2'
forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(v1 -> v2) -> map1 -> map2
nMap

nMapWithKey ::
  NMap map1 k v1 sort1 =>
  NMap map2 k v2 sort2 =>
  (k -> v1 -> v2) ->
  map1 ->
  map2
nMapWithKey :: forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(k -> v1 -> v2) -> map1 -> map2
nMapWithKey k -> v1 -> v2
f =
  Map k v2 -> map2
forall a b. Coercible a b => a -> b
coerce (Map k v2 -> map2) -> (map1 -> Map k v2) -> map1 -> map2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k -> v1 -> v2) -> Map k v1 -> Map k v2
forall k a b. (k -> a -> b) -> Map k a -> Map k b
Map.mapWithKey k -> v1 -> v2
f (Map k v1 -> Map k v2) -> (map1 -> Map k v1) -> map1 -> Map k v2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. map1 -> Map k v1
forall map k v sort. NMap map k v sort => map -> Map k v
nGet

nMapWithKey1 ::
  ∀ map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2' .
  NMap map1 k map1' s1 =>
  NMap map2 k map2' s2 =>
  NMap map1' k' v1 s1' =>
  NMap map2' k' v2 s2' =>
  (k -> k' -> v1 -> v2) ->
  map1 ->
  map2
nMapWithKey1 :: forall map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2'.
(NMap map1 k map1' s1, NMap map2 k map2' s2, NMap map1' k' v1 s1',
 NMap map2' k' v2 s2') =>
(k -> k' -> v1 -> v2) -> map1 -> map2
nMapWithKey1 k -> k' -> v1 -> v2
f =
  (k -> map1' -> map2') -> map1 -> map2
forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(k -> v1 -> v2) -> map1 -> map2
nMapWithKey \ k
k -> (k' -> v1 -> v2) -> map1' -> map2'
forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(k -> v1 -> v2) -> map1 -> map2
nMapWithKey (k -> k' -> v1 -> v2
f k
k)

nTransform ::
  NMap map1 k1 v1 sort1 =>
  NMap map2 k2 v2 sort2 =>
  (k1 -> v1 -> (k2, v2)) ->
  map1 ->
  map2
nTransform :: forall map1 k1 v1 sort1 map2 k2 v2 sort2.
(NMap map1 k1 v1 sort1, NMap map2 k2 v2 sort2) =>
(k1 -> v1 -> (k2, v2)) -> map1 -> map2
nTransform k1 -> v1 -> (k2, v2)
f =
  Map k2 v2 -> map2
forall a b. Coercible a b => a -> b
coerce (Map k2 v2 -> map2) -> (map1 -> Map k2 v2) -> map1 -> map2
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  [(k2, v2)] -> Map k2 v2
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(k2, v2)] -> Map k2 v2)
-> (map1 -> [(k2, v2)]) -> map1 -> Map k2 v2
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  ((k1, v1) -> (k2, v2)) -> [(k1, v1)] -> [(k2, v2)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((k1 -> v1 -> (k2, v2)) -> (k1, v1) -> (k2, v2)
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry k1 -> v1 -> (k2, v2)
f) ([(k1, v1)] -> [(k2, v2)])
-> (map1 -> [(k1, v1)]) -> map1 -> [(k2, v2)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Map k1 v1 -> [(k1, v1)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map k1 v1 -> [(k1, v1)])
-> (map1 -> Map k1 v1) -> map1 -> [(k1, v1)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  map1 -> Map k1 v1
forall map k v sort. NMap map k v sort => map -> Map k v
nGet

nTransformMaybe ::
  NMap map1 k1 v1 sort1 =>
  NMap map2 k2 v2 sort2 =>
  (k1 -> v1 -> Maybe (k2, v2)) ->
  map1 ->
  map2
nTransformMaybe :: forall map1 k1 v1 sort1 map2 k2 v2 sort2.
(NMap map1 k1 v1 sort1, NMap map2 k2 v2 sort2) =>
(k1 -> v1 -> Maybe (k2, v2)) -> map1 -> map2
nTransformMaybe k1 -> v1 -> Maybe (k2, v2)
f =
  Map k2 v2 -> map2
forall a b. Coercible a b => a -> b
coerce (Map k2 v2 -> map2) -> (map1 -> Map k2 v2) -> map1 -> map2
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  [(k2, v2)] -> Map k2 v2
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(k2, v2)] -> Map k2 v2)
-> (map1 -> [(k2, v2)]) -> map1 -> Map k2 v2
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  ((k1, v1) -> Maybe (k2, v2)) -> [(k1, v1)] -> [(k2, v2)]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe ((k1 -> v1 -> Maybe (k2, v2)) -> (k1, v1) -> Maybe (k2, v2)
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry k1 -> v1 -> Maybe (k2, v2)
f) ([(k1, v1)] -> [(k2, v2)])
-> (map1 -> [(k1, v1)]) -> map1 -> [(k2, v2)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Map k1 v1 -> [(k1, v1)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map k1 v1 -> [(k1, v1)])
-> (map1 -> Map k1 v1) -> map1 -> [(k1, v1)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  map1 -> Map k1 v1
forall map k v sort. NMap map k v sort => map -> Map k v
nGet

nMapMaybe ::
  NMap map1 k v1 sort1 =>
  NMap map2 k v2 sort2 =>
  (v1 -> Maybe v2) ->
  map1 ->
  map2
nMapMaybe :: forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(v1 -> Maybe v2) -> map1 -> map2
nMapMaybe v1 -> Maybe v2
f =
  Map k v2 -> map2
forall a b. Coercible a b => a -> b
coerce (Map k v2 -> map2) -> (map1 -> Map k v2) -> map1 -> map2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k -> v1 -> Maybe v2) -> Map k v1 -> Map k v2
forall k a b. (k -> a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybeWithKey ((v1 -> Maybe v2) -> k -> v1 -> Maybe v2
forall a b. a -> b -> a
const v1 -> Maybe v2
f) (Map k v1 -> Map k v2) -> (map1 -> Map k v1) -> map1 -> Map k v2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. map1 -> Map k v1
forall map k v sort. NMap map k v sort => map -> Map k v
nGet

nMapMaybe1 ::
  ∀ map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2' .
  NMap map1 k map1' s1 =>
  NMap map2 k map2' s2 =>
  NMap map1' k' v1 s1' =>
  NMap map2' k' v2 s2' =>
  (v1 -> Maybe v2) ->
  map1 ->
  map2
nMapMaybe1 :: forall map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2'.
(NMap map1 k map1' s1, NMap map2 k map2' s2, NMap map1' k' v1 s1',
 NMap map2' k' v2 s2') =>
(v1 -> Maybe v2) -> map1 -> map2
nMapMaybe1 =
  (map1' -> map2') -> map1 -> map2
forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(v1 -> v2) -> map1 -> map2
nMap ((map1' -> map2') -> map1 -> map2)
-> ((v1 -> Maybe v2) -> map1' -> map2')
-> (v1 -> Maybe v2)
-> map1
-> map2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v1 -> Maybe v2) -> map1' -> map2'
forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(v1 -> Maybe v2) -> map1 -> map2
nMapMaybe

nMapMaybeWithKey ::
  NMap map1 k v1 sort1 =>
  NMap map2 k v2 sort2 =>
  (k -> v1 -> Maybe v2) ->
  map1 ->
  map2
nMapMaybeWithKey :: forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(k -> v1 -> Maybe v2) -> map1 -> map2
nMapMaybeWithKey k -> v1 -> Maybe v2
f =
  Map k v2 -> map2
forall a b. Coercible a b => a -> b
coerce (Map k v2 -> map2) -> (map1 -> Map k v2) -> map1 -> map2
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  (k -> v1 -> Maybe v2) -> Map k v1 -> Map k v2
forall k a b. (k -> a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybeWithKey k -> v1 -> Maybe v2
f (Map k v1 -> Map k v2) -> (map1 -> Map k v1) -> map1 -> Map k v2
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  map1 -> Map k v1
forall map k v sort. NMap map k v sort => map -> Map k v
nGet

nMapMaybeWithKey1 ::
  ∀ map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2' .
  NMap map1 k map1' s1 =>
  NMap map2 k map2' s2 =>
  NMap map1' k' v1 s1' =>
  NMap map2' k' v2 s2' =>
  (k' -> v1 -> Maybe v2) ->
  map1 ->
  map2
nMapMaybeWithKey1 :: forall map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2'.
(NMap map1 k map1' s1, NMap map2 k map2' s2, NMap map1' k' v1 s1',
 NMap map2' k' v2 s2') =>
(k' -> v1 -> Maybe v2) -> map1 -> map2
nMapMaybeWithKey1 =
  (map1' -> map2') -> map1 -> map2
forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(v1 -> v2) -> map1 -> map2
nMap ((map1' -> map2') -> map1 -> map2)
-> ((k' -> v1 -> Maybe v2) -> map1' -> map2')
-> (k' -> v1 -> Maybe v2)
-> map1
-> map2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k' -> v1 -> Maybe v2) -> map1' -> map2'
forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(k -> v1 -> Maybe v2) -> map1 -> map2
nMapMaybeWithKey

nCatMaybes ::
  NMap map1 k (Maybe v) sort1 =>
  NMap map2 k v sort2 =>
  map1 ->
  map2
nCatMaybes :: forall map1 k v sort1 map2 sort2.
(NMap map1 k (Maybe v) sort1, NMap map2 k v sort2) =>
map1 -> map2
nCatMaybes =
  (Maybe v -> Maybe v) -> map1 -> map2
forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(v1 -> Maybe v2) -> map1 -> map2
nMapMaybe Maybe v -> Maybe v
forall a. a -> a
id

nFilter ::
  ∀ map k v sort .
  NMap map k v sort =>
  (v -> Bool) ->
  map ->
  map
nFilter :: forall map k v sort. NMap map k v sort => (v -> Bool) -> map -> map
nFilter =
  (Map k v -> Map k v) -> map -> map
forall map1 k1 v1 s1 map2 k2 v2 s2.
(NMap map1 k1 v1 s1, NMap map2 k2 v2 s2) =>
(Map k1 v1 -> Map k2 v2) -> map1 -> map2
nVia ((Map k v -> Map k v) -> map -> map)
-> ((v -> Bool) -> Map k v -> Map k v) -> (v -> Bool) -> map -> map
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v -> Bool) -> Map k v -> Map k v
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter

nFilter1 ::
  ∀ map map' k k' v s s' .
  NMap map k map' s =>
  NMap map' k' v s' =>
  (v -> Bool) ->
  map ->
  map
nFilter1 :: forall map map' k k' v s s'.
(NMap map k map' s, NMap map' k' v s') =>
(v -> Bool) -> map -> map
nFilter1 =
  (map' -> map') -> map -> map
forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(v1 -> v2) -> map1 -> map2
nMap ((map' -> map') -> map -> map)
-> ((v -> Bool) -> map' -> map') -> (v -> Bool) -> map -> map
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v -> Bool) -> map' -> map'
forall map k v sort. NMap map k v sort => (v -> Bool) -> map -> map
nFilter

nPrettyWith ::
  Pretty k =>
  NMap map k v sort =>
  (v -> Doc) ->
  map ->
  Doc
nPrettyWith :: forall k map v sort.
(Pretty k, NMap map k v sort) =>
(v -> Doc) -> map -> Doc
nPrettyWith v -> Doc
prettyV (map -> Map k v
forall map k v sort. NMap map k v sort => map -> Map k v
nGet -> Map k v
m) =
  [Doc] -> Doc
sep (Doc -> [Doc] -> [Doc]
punctuate Doc
comma ((k, v) -> Doc
assoc ((k, v) -> Doc) -> [(k, v)] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map k v -> [(k, v)]
forall k a. Map k a -> [(k, a)]
Map.toList Map k v
m))
  where
    assoc :: (k, v) -> Doc
assoc (k
k, v
v) = k -> Doc
forall a. Pretty a => a -> Doc
pretty k
k Doc -> Doc -> Doc
<+> Doc
"->" Doc -> Doc -> Doc
<+> v -> Doc
prettyV v
v

nPretty ::
  Pretty k =>
  Pretty v =>
  NMap map k v sort =>
  map ->
  Doc
nPretty :: forall k v map sort.
(Pretty k, Pretty v, NMap map k v sort) =>
map -> Doc
nPretty =
  (v -> Doc) -> map -> Doc
forall k map v sort.
(Pretty k, NMap map k v sort) =>
(v -> Doc) -> map -> Doc
nPrettyWith v -> Doc
forall a. Pretty a => a -> Doc
pretty

nPretty1 ::
  Pretty k =>
  Pretty v =>
  NMap map k v sort =>
  map ->
  Doc
nPretty1 :: forall k v map sort.
(Pretty k, Pretty v, NMap map k v sort) =>
map -> Doc
nPretty1 (map -> Map k v
forall map k v sort. NMap map k v sort => map -> Map k v
nGet -> Map k v
m) =
  [Doc] -> Doc
vcat ((k, v) -> Doc
forall {a} {a}. (Pretty a, Pretty a) => (a, a) -> Doc
assoc ((k, v) -> Doc) -> [(k, v)] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map k v -> [(k, v)]
forall k a. Map k a -> [(k, a)]
Map.toList Map k v
m)
  where
    assoc :: (a, a) -> Doc
assoc (a
k, a
v) = Doc -> Int -> Doc -> Doc
hang (a -> Doc
forall a. Pretty a => a -> Doc
pretty a
k Doc -> Doc -> Doc
PrettyPrint.<> Doc
":") Int
2 (a -> Doc
forall a. Pretty a => a -> Doc
pretty a
v)

nMergeA ::
  ∀ map1 map2 map3 k v1 v2 v3 s1 s2 s3 m .
  Applicative m =>
  NMap map1 k v1 s1 =>
  NMap map2 k v2 s2 =>
  NMap map3 k v3 s3 =>
  WhenMissing m k v1 v3 ->
  WhenMissing m k v2 v3 ->
  WhenMatched m k v1 v2 v3 ->
  map1 ->
  map2 ->
  m map3
nMergeA :: forall map1 map2 map3 k v1 v2 v3 s1 s2 s3 (m :: * -> *).
(Applicative m, NMap map1 k v1 s1, NMap map2 k v2 s2,
 NMap map3 k v3 s3) =>
WhenMissing m k v1 v3
-> WhenMissing m k v2 v3
-> WhenMatched m k v1 v2 v3
-> map1
-> map2
-> m map3
nMergeA WhenMissing m k v1 v3
missing1 WhenMissing m k v2 v3
missing2 WhenMatched m k v1 v2 v3
matched map1
map1 map2
map2 =
  (Map k v2 -> m (Map k v3)) -> map2 -> m map3
forall (m :: * -> *) map1 k1 v1 s1 map2 k2 v2 s2.
(Applicative m, NMap map1 k1 v1 s1, NMap map2 k2 v2 s2) =>
(Map k1 v1 -> m (Map k2 v2)) -> map1 -> m map2
nViaA (WhenMissing m k v1 v3
-> WhenMissing m k v2 v3
-> WhenMatched m k v1 v2 v3
-> Map k v1
-> Map k v2
-> m (Map k v3)
forall (f :: * -> *) k a c b.
(Applicative f, Ord k) =>
WhenMissing f k a c
-> WhenMissing f k b c
-> WhenMatched f k a b c
-> Map k a
-> Map k b
-> f (Map k c)
Map.mergeA WhenMissing m k v1 v3
missing1 WhenMissing m k v2 v3
missing2 WhenMatched m k v1 v2 v3
matched (map1 -> Map k v1
forall map k v sort. NMap map k v sort => map -> Map k v
nGet map1
map1)) map2
map2

nMerge ::
  ∀ map1 map2 map3 k v1 v2 v3 s1 s2 s3 .
  NMap map1 k v1 s1 =>
  NMap map2 k v2 s2 =>
  NMap map3 k v3 s3 =>
  SimpleWhenMissing k v1 v3 ->
  SimpleWhenMissing k v2 v3 ->
  SimpleWhenMatched k v1 v2 v3 ->
  map1 ->
  map2 ->
  map3
nMerge :: forall map1 map2 map3 k v1 v2 v3 s1 s2 s3.
(NMap map1 k v1 s1, NMap map2 k v2 s2, NMap map3 k v3 s3) =>
SimpleWhenMissing k v1 v3
-> SimpleWhenMissing k v2 v3
-> SimpleWhenMatched k v1 v2 v3
-> map1
-> map2
-> map3
nMerge SimpleWhenMissing k v1 v3
missing1 SimpleWhenMissing k v2 v3
missing2 SimpleWhenMatched k v1 v2 v3
matched map1
map1 map2
map2 =
  (Map k v2 -> Map k v3) -> map2 -> map3
forall map1 k1 v1 s1 map2 k2 v2 s2.
(NMap map1 k1 v1 s1, NMap map2 k2 v2 s2) =>
(Map k1 v1 -> Map k2 v2) -> map1 -> map2
nVia (SimpleWhenMissing k v1 v3
-> SimpleWhenMissing k v2 v3
-> SimpleWhenMatched k v1 v2 v3
-> Map k v1
-> Map k v2
-> Map k v3
forall k a c b.
Ord k =>
SimpleWhenMissing k a c
-> SimpleWhenMissing k b c
-> SimpleWhenMatched k a b c
-> Map k a
-> Map k b
-> Map k c
Map.merge SimpleWhenMissing k v1 v3
missing1 SimpleWhenMissing k v2 v3
missing2 SimpleWhenMatched k v1 v2 v3
matched (map1 -> Map k v1
forall map k v sort. NMap map k v sort => map -> Map k v
nGet map1
map1)) map2
map2

nAmendWithKey ::
  ∀ map1 map2 k v1 v2 s1 s2 .
  NMap map1 k v1 s1 =>
  NMap map2 k v2 s2 =>
  (k -> v1 -> v2 -> v2) ->
  map1 ->
  map2 ->
  map2
nAmendWithKey :: forall map1 map2 k v1 v2 s1 s2.
(NMap map1 k v1 s1, NMap map2 k v2 s2) =>
(k -> v1 -> v2 -> v2) -> map1 -> map2 -> map2
nAmendWithKey k -> v1 -> v2 -> v2
matched =
  SimpleWhenMissing k v1 v2
-> SimpleWhenMissing k v2 v2
-> SimpleWhenMatched k v1 v2 v2
-> map1
-> map2
-> map2
forall map1 map2 map3 k v1 v2 v3 s1 s2 s3.
(NMap map1 k v1 s1, NMap map2 k v2 s2, NMap map3 k v3 s3) =>
SimpleWhenMissing k v1 v3
-> SimpleWhenMissing k v2 v3
-> SimpleWhenMatched k v1 v2 v3
-> map1
-> map2
-> map3
nMerge SimpleWhenMissing k v1 v2
forall (f :: * -> *) k x y. Applicative f => WhenMissing f k x y
dropMissing SimpleWhenMissing k v2 v2
forall (f :: * -> *) k x. Applicative f => WhenMissing f k x x
preserveMissing ((k -> v1 -> v2 -> v2) -> SimpleWhenMatched k v1 v2 v2
forall (f :: * -> *) k x y z.
Applicative f =>
(k -> x -> y -> z) -> WhenMatched f k x y z
zipWithMatched k -> v1 -> v2 -> v2
matched)

-- | For each key that is present in both maps, replace the value by the result of the combining function.
-- For everything else, leave @map2@ unchanged.
nAmend ::
  ∀ map1 map2 k v1 v2 s1 s2 .
  NMap map1 k v1 s1 =>
  NMap map2 k v2 s2 =>
  (v1 -> v2 -> v2) ->
  map1 ->
  map2 ->
  map2
nAmend :: forall map1 map2 k v1 v2 s1 s2.
(NMap map1 k v1 s1, NMap map2 k v2 s2) =>
(v1 -> v2 -> v2) -> map1 -> map2 -> map2
nAmend v1 -> v2 -> v2
matched =
  (k -> v1 -> v2 -> v2) -> map1 -> map2 -> map2
forall map1 map2 k v1 v2 s1 s2.
(NMap map1 k v1 s1, NMap map2 k v2 s2) =>
(k -> v1 -> v2 -> v2) -> map1 -> map2 -> map2
nAmendWithKey ((v1 -> v2 -> v2) -> k -> v1 -> v2 -> v2
forall a b. a -> b -> a
const v1 -> v2 -> v2
matched)

-- | For each key path that is present in both submaps, replace the value by the result of the combining function.
-- For everything else, leave @map2@ unchanged.
nAmend1 ::
  ∀ map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2' .
  NMap map1 k map1' s1 =>
  NMap map2 k map2' s2 =>
  NMap map1' k' v1 s1' =>
  NMap map2' k' v2 s2' =>
  (v1 -> v2 -> v2) ->
  map1 ->
  map2 ->
  map2
nAmend1 :: forall map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2'.
(NMap map1 k map1' s1, NMap map2 k map2' s2, NMap map1' k' v1 s1',
 NMap map2' k' v2 s2') =>
(v1 -> v2 -> v2) -> map1 -> map2 -> map2
nAmend1 v1 -> v2 -> v2
matched =
  SimpleWhenMissing k map1' map2'
-> SimpleWhenMissing k map2' map2'
-> SimpleWhenMatched k map1' map2' map2'
-> map1
-> map2
-> map2
forall map1 map2 map3 k v1 v2 v3 s1 s2 s3.
(NMap map1 k v1 s1, NMap map2 k v2 s2, NMap map3 k v3 s3) =>
SimpleWhenMissing k v1 v3
-> SimpleWhenMissing k v2 v3
-> SimpleWhenMatched k v1 v2 v3
-> map1
-> map2
-> map3
nMerge SimpleWhenMissing k map1' map2'
forall (f :: * -> *) k x y. Applicative f => WhenMissing f k x y
dropMissing SimpleWhenMissing k map2' map2'
forall (f :: * -> *) k x. Applicative f => WhenMissing f k x x
preserveMissing ((k -> map1' -> map2' -> map2')
-> SimpleWhenMatched k map1' map2' map2'
forall (f :: * -> *) k x y z.
Applicative f =>
(k -> x -> y -> z) -> WhenMatched f k x y z
zipWithMatched k -> map1' -> map2' -> map2'
matched1)
  where
    matched1 :: k -> map1' -> map2' -> map2'
matched1 k
_ map1'
map1' map2'
map2' = (v1 -> v2 -> v2) -> map1' -> map2' -> map2'
forall map1 map2 k v1 v2 s1 s2.
(NMap map1 k v1 s1, NMap map2 k v2 s2) =>
(v1 -> v2 -> v2) -> map1 -> map2 -> map2
nAmend v1 -> v2 -> v2
matched map1'
map1' map2'
map2'

-- | For each key that is present in both maps, replace the value by the result of the combining function.
-- For each key that is present in @map1@, insert the result of the conversion function.
-- Keep keys only present in @map2@.
nPad ::
  ∀ map1 map2 k v1 v2 s1 s2 .
  NMap map1 k v1 s1 =>
  NMap map2 k v2 s2 =>
  (v1 -> v2 -> v2) ->
  (v1 -> v2) ->
  map1 ->
  map2 ->
  map2
nPad :: forall map1 map2 k v1 v2 s1 s2.
(NMap map1 k v1 s1, NMap map2 k v2 s2) =>
(v1 -> v2 -> v2) -> (v1 -> v2) -> map1 -> map2 -> map2
nPad v1 -> v2 -> v2
matched v1 -> v2
conv =
  SimpleWhenMissing k v1 v2
-> SimpleWhenMissing k v2 v2
-> SimpleWhenMatched k v1 v2 v2
-> map1
-> map2
-> map2
forall map1 map2 map3 k v1 v2 v3 s1 s2 s3.
(NMap map1 k v1 s1, NMap map2 k v2 s2, NMap map3 k v3 s3) =>
SimpleWhenMissing k v1 v3
-> SimpleWhenMissing k v2 v3
-> SimpleWhenMatched k v1 v2 v3
-> map1
-> map2
-> map3
nMerge ((k -> v1 -> v2) -> SimpleWhenMissing k v1 v2
forall (f :: * -> *) k x y.
Applicative f =>
(k -> x -> y) -> WhenMissing f k x y
mapMissing ((v1 -> v2) -> k -> v1 -> v2
forall a b. a -> b -> a
const v1 -> v2
conv)) SimpleWhenMissing k v2 v2
forall (f :: * -> *) k x. Applicative f => WhenMissing f k x x
preserveMissing ((k -> v1 -> v2 -> v2) -> SimpleWhenMatched k v1 v2 v2
forall (f :: * -> *) k x y z.
Applicative f =>
(k -> x -> y -> z) -> WhenMatched f k x y z
zipWithMatched ((v1 -> v2 -> v2) -> k -> v1 -> v2 -> v2
forall a b. a -> b -> a
const v1 -> v2 -> v2
matched))

-- | For each key path that is present in both submaps, replace the value by the result of the combining function.
-- For each key and key path that is present only in @map1@ and each submap, insert the result of the conversion
-- function.
-- Keep keys only present in @map2@ and each submap.
nPad1 ::
  ∀ map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2' .
  NMap map1 k map1' s1 =>
  NMap map2 k map2' s2 =>
  NMap map1' k' v1 s1' =>
  NMap map2' k' v2 s2' =>
  (v1 -> v2 -> v2) ->
  (v1 -> v2) ->
  map1 ->
  map2 ->
  map2
nPad1 :: forall map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2'.
(NMap map1 k map1' s1, NMap map2 k map2' s2, NMap map1' k' v1 s1',
 NMap map2' k' v2 s2') =>
(v1 -> v2 -> v2) -> (v1 -> v2) -> map1 -> map2 -> map2
nPad1 v1 -> v2 -> v2
matched v1 -> v2
conv =
  SimpleWhenMissing k map1' map2'
-> SimpleWhenMissing k map2' map2'
-> SimpleWhenMatched k map1' map2' map2'
-> map1
-> map2
-> map2
forall map1 map2 map3 k v1 v2 v3 s1 s2 s3.
(NMap map1 k v1 s1, NMap map2 k v2 s2, NMap map3 k v3 s3) =>
SimpleWhenMissing k v1 v3
-> SimpleWhenMissing k v2 v3
-> SimpleWhenMatched k v1 v2 v3
-> map1
-> map2
-> map3
nMerge ((k -> map1' -> map2') -> SimpleWhenMissing k map1' map2'
forall (f :: * -> *) k x y.
Applicative f =>
(k -> x -> y) -> WhenMissing f k x y
mapMissing k -> map1' -> map2'
missing) SimpleWhenMissing k map2' map2'
forall (f :: * -> *) k x. Applicative f => WhenMissing f k x x
preserveMissing ((k -> map1' -> map2' -> map2')
-> SimpleWhenMatched k map1' map2' map2'
forall (f :: * -> *) k x y z.
Applicative f =>
(k -> x -> y -> z) -> WhenMatched f k x y z
zipWithMatched k -> map1' -> map2' -> map2'
matched1)
  where
    missing :: k -> map1' -> map2'
missing k
_ = (v1 -> v2) -> map1' -> map2'
forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(v1 -> v2) -> map1 -> map2
nMap v1 -> v2
conv
    matched1 :: k -> map1' -> map2' -> map2'
matched1 k
_ = (v1 -> v2 -> v2) -> (v1 -> v2) -> map1' -> map2' -> map2'
forall map1 map2 k v1 v2 s1 s2.
(NMap map1 k v1 s1, NMap map2 k v2 s2) =>
(v1 -> v2 -> v2) -> (v1 -> v2) -> map1 -> map2 -> map2
nPad v1 -> v2 -> v2
matched v1 -> v2
conv

-- | For each key that is present only in @map1@, insert the result of the conversion function.
-- For everything else, leave @map2@ unchanged.
nPadKeep ::
  ∀ map1 map2 k v1 v2 s1 s2 .
  NMap map1 k v1 s1 =>
  NMap map2 k v2 s2 =>
  (v1 -> v2) ->
  map1 ->
  map2 ->
  map2
nPadKeep :: forall map1 map2 k v1 v2 s1 s2.
(NMap map1 k v1 s1, NMap map2 k v2 s2) =>
(v1 -> v2) -> map1 -> map2 -> map2
nPadKeep =
  (v1 -> v2 -> v2) -> (v1 -> v2) -> map1 -> map2 -> map2
forall map1 map2 k v1 v2 s1 s2.
(NMap map1 k v1 s1, NMap map2 k v2 s2) =>
(v1 -> v2 -> v2) -> (v1 -> v2) -> map1 -> map2 -> map2
nPad \ v1
_ v2
v2 -> v2
v2

-- | For each key and key path that is present only in @map1@ and each submap, insert the result of the conversion
-- function.
-- For everything else, leave @map2@ and its submaps unchanged.
nPadKeep1 ::
  ∀ map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2' .
  NMap map1 k map1' s1 =>
  NMap map2 k map2' s2 =>
  NMap map1' k' v1 s1' =>
  NMap map2' k' v2 s2' =>
  (v1 -> v2) ->
  map1 ->
  map2 ->
  map2
nPadKeep1 :: forall map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2'.
(NMap map1 k map1' s1, NMap map2 k map2' s2, NMap map1' k' v1 s1',
 NMap map2' k' v2 s2') =>
(v1 -> v2) -> map1 -> map2 -> map2
nPadKeep1 =
  (v1 -> v2 -> v2) -> (v1 -> v2) -> map1 -> map2 -> map2
forall map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2'.
(NMap map1 k map1' s1, NMap map2 k map2' s2, NMap map1' k' v1 s1',
 NMap map2' k' v2 s2') =>
(v1 -> v2 -> v2) -> (v1 -> v2) -> map1 -> map2 -> map2
nPad1 \ v1
_ v2
v2 -> v2
v2

nZipWithKeyR ::
  ∀ map1 map2 map3 k v1 v2 v3 s1 s2 s3 .
  NMap map1 k v1 s1 =>
  NMap map2 k v2 s2 =>
  NMap map3 k v3 s3 =>
  (k -> Maybe v1 -> v2 -> v3) ->
  map1 ->
  map2 ->
  map3
nZipWithKeyR :: forall map1 map2 map3 k v1 v2 v3 s1 s2 s3.
(NMap map1 k v1 s1, NMap map2 k v2 s2, NMap map3 k v3 s3) =>
(k -> Maybe v1 -> v2 -> v3) -> map1 -> map2 -> map3
nZipWithKeyR k -> Maybe v1 -> v2 -> v3
f =
  SimpleWhenMissing k v1 v3
-> SimpleWhenMissing k v2 v3
-> SimpleWhenMatched k v1 v2 v3
-> map1
-> map2
-> map3
forall map1 map2 map3 k v1 v2 v3 s1 s2 s3.
(NMap map1 k v1 s1, NMap map2 k v2 s2, NMap map3 k v3 s3) =>
SimpleWhenMissing k v1 v3
-> SimpleWhenMissing k v2 v3
-> SimpleWhenMatched k v1 v2 v3
-> map1
-> map2
-> map3
nMerge SimpleWhenMissing k v1 v3
forall (f :: * -> *) k x y. Applicative f => WhenMissing f k x y
dropMissing ((k -> v2 -> v3) -> SimpleWhenMissing k v2 v3
forall (f :: * -> *) k x y.
Applicative f =>
(k -> x -> y) -> WhenMissing f k x y
mapMissing k -> v2 -> v3
missing) ((k -> v1 -> v2 -> v3) -> SimpleWhenMatched k v1 v2 v3
forall (f :: * -> *) k x y z.
Applicative f =>
(k -> x -> y -> z) -> WhenMatched f k x y z
zipWithMatched k -> v1 -> v2 -> v3
matched)
  where
    missing :: k -> v2 -> v3
missing k
k = k -> Maybe v1 -> v2 -> v3
f k
k Maybe v1
forall a. Maybe a
Nothing
    matched :: k -> v1 -> v2 -> v3
matched k
k v1
v = k -> Maybe v1 -> v2 -> v3
f k
k (v1 -> Maybe v1
forall a. a -> Maybe a
Just v1
v)

nZipR ::
  ∀ map1 map2 map3 k v1 v2 v3 s1 s2 s3 .
  NMap map1 k v1 s1 =>
  NMap map2 k v2 s2 =>
  NMap map3 k v3 s3 =>
  (Maybe v1 -> v2 -> v3) ->
  map1 ->
  map2 ->
  map3
nZipR :: forall map1 map2 map3 k v1 v2 v3 s1 s2 s3.
(NMap map1 k v1 s1, NMap map2 k v2 s2, NMap map3 k v3 s3) =>
(Maybe v1 -> v2 -> v3) -> map1 -> map2 -> map3
nZipR Maybe v1 -> v2 -> v3
f = (k -> Maybe v1 -> v2 -> v3) -> map1 -> map2 -> map3
forall map1 map2 map3 k v1 v2 v3 s1 s2 s3.
(NMap map1 k v1 s1, NMap map2 k v2 s2, NMap map3 k v3 s3) =>
(k -> Maybe v1 -> v2 -> v3) -> map1 -> map2 -> map3
nZipWithKeyR ((Maybe v1 -> v2 -> v3) -> k -> Maybe v1 -> v2 -> v3
forall a b. a -> b -> a
const Maybe v1 -> v2 -> v3
f)

nZipWithKey ::
  ∀ map1 map2 map3 k v1 v2 v3 s1 s2 s3 .
  NMap map1 k v1 s1 =>
  NMap map2 k v2 s2 =>
  NMap map3 k v3 s3 =>
  (k -> v1 -> v2 -> v3) ->
  map1 ->
  map2 ->
  map3
nZipWithKey :: forall map1 map2 map3 k v1 v2 v3 s1 s2 s3.
(NMap map1 k v1 s1, NMap map2 k v2 s2, NMap map3 k v3 s3) =>
(k -> v1 -> v2 -> v3) -> map1 -> map2 -> map3
nZipWithKey k -> v1 -> v2 -> v3
f =
  SimpleWhenMissing k v1 v3
-> SimpleWhenMissing k v2 v3
-> SimpleWhenMatched k v1 v2 v3
-> map1
-> map2
-> map3
forall map1 map2 map3 k v1 v2 v3 s1 s2 s3.
(NMap map1 k v1 s1, NMap map2 k v2 s2, NMap map3 k v3 s3) =>
SimpleWhenMissing k v1 v3
-> SimpleWhenMissing k v2 v3
-> SimpleWhenMatched k v1 v2 v3
-> map1
-> map2
-> map3
nMerge SimpleWhenMissing k v1 v3
forall (f :: * -> *) k x y. Applicative f => WhenMissing f k x y
dropMissing SimpleWhenMissing k v2 v3
forall (f :: * -> *) k x y. Applicative f => WhenMissing f k x y
dropMissing ((k -> v1 -> v2 -> v3) -> SimpleWhenMatched k v1 v2 v3
forall (f :: * -> *) k x y z.
Applicative f =>
(k -> x -> y -> z) -> WhenMatched f k x y z
zipWithMatched k -> v1 -> v2 -> v3
f)

nZip ::
  ∀ map1 map2 map3 k v1 v2 v3 s1 s2 s3 .
  NMap map1 k v1 s1 =>
  NMap map2 k v2 s2 =>
  NMap map3 k v3 s3 =>
  (v1 -> v2 -> v3) ->
  map1 ->
  map2 ->
  map3
nZip :: forall map1 map2 map3 k v1 v2 v3 s1 s2 s3.
(NMap map1 k v1 s1, NMap map2 k v2 s2, NMap map3 k v3 s3) =>
(v1 -> v2 -> v3) -> map1 -> map2 -> map3
nZip v1 -> v2 -> v3
f = (k -> v1 -> v2 -> v3) -> map1 -> map2 -> map3
forall map1 map2 map3 k v1 v2 v3 s1 s2 s3.
(NMap map1 k v1 s1, NMap map2 k v2 s2, NMap map3 k v3 s3) =>
(k -> v1 -> v2 -> v3) -> map1 -> map2 -> map3
nZipWithKey ((v1 -> v2 -> v3) -> k -> v1 -> v2 -> v3
forall a b. a -> b -> a
const v1 -> v2 -> v3
f)

nFromList ::
  NMap map k v sort =>
  [(k, v)] ->
  map
nFromList :: forall map k v sort. NMap map k v sort => [(k, v)] -> map
nFromList =
  Map k v -> map
forall a b. Coercible a b => a -> b
coerce (Map k v -> map) -> ([(k, v)] -> Map k v) -> [(k, v)] -> map
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(k, v)] -> Map k v
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList

nList ::
  NMap map k v sort =>
  map ->
  [(k, v)]
nList :: forall map k v sort. NMap map k v sort => map -> [(k, v)]
nList =
  Map k v -> [(k, v)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map k v -> [(k, v)]) -> (map -> Map k v) -> map -> [(k, v)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. map -> Map k v
forall a b. Coercible a b => a -> b
coerce

nTo ::
  NMap map k v sort =>
  map ->
  (k -> v -> a) ->
  [a]
nTo :: forall map k v sort a.
NMap map k v sort =>
map -> (k -> v -> a) -> [a]
nTo map
m k -> v -> a
f =
  ((k, v) -> a) -> [(k, v)] -> [a]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((k -> v -> a) -> (k, v) -> a
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry k -> v -> a
f) (map -> [(k, v)]
forall map k v sort. NMap map k v sort => map -> [(k, v)]
nList map
m)

nToWith ::
  NMap map k v sort =>
  (k -> v -> a) ->
  map ->
  [a]
nToWith :: forall map k v sort a.
NMap map k v sort =>
(k -> v -> a) -> map -> [a]
nToWith = (map -> (k -> v -> a) -> [a]) -> (k -> v -> a) -> map -> [a]
forall a b c. (a -> b -> c) -> b -> a -> c
flip map -> (k -> v -> a) -> [a]
forall map k v sort a.
NMap map k v sort =>
map -> (k -> v -> a) -> [a]
nTo

nConcat ::
  Monoid a =>
  NMap map k v sort =>
  map ->
  (k -> v -> a) ->
  a
nConcat :: forall a map k v sort.
(Monoid a, NMap map k v sort) =>
map -> (k -> v -> a) -> a
nConcat map
m k -> v -> a
f =
  [a] -> a
forall a. Monoid a => [a] -> a
mconcat ((k -> v -> a) -> (k, v) -> a
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry k -> v -> a
f ((k, v) -> a) -> [(k, v)] -> [a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> map -> [(k, v)]
forall map k v sort. NMap map k v sort => map -> [(k, v)]
nList map
m)

nConcatWith ::
  Monoid a =>
  NMap map k v sort =>
  (k -> v -> a) ->
  map ->
  a
nConcatWith :: forall a map k v sort.
(Monoid a, NMap map k v sort) =>
(k -> v -> a) -> map -> a
nConcatWith =
  (map -> (k -> v -> a) -> a) -> (k -> v -> a) -> map -> a
forall a b c. (a -> b -> c) -> b -> a -> c
flip map -> (k -> v -> a) -> a
forall a map k v sort.
(Monoid a, NMap map k v sort) =>
map -> (k -> v -> a) -> a
nConcat

nToMaybe ::
  NMap map k v sort =>
  map ->
  (k -> v -> Maybe a) ->
  [a]
nToMaybe :: forall map k v sort a.
NMap map k v sort =>
map -> (k -> v -> Maybe a) -> [a]
nToMaybe map
m k -> v -> Maybe a
f =
  ((k, v) -> Maybe a) -> [(k, v)] -> [a]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe ((k -> v -> Maybe a) -> (k, v) -> Maybe a
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry k -> v -> Maybe a
f) (map -> [(k, v)]
forall map k v sort. NMap map k v sort => map -> [(k, v)]
nList map
m)

nTo1 ::
  ∀ map1 map2 k1 k2 v s1 s2 a .
  NMap map1 k1 map2 s1 =>
  NMap map2 k2 v s2 =>
  map1 ->
  (k1 -> k2 -> v -> a) ->
  [a]
nTo1 :: forall map1 map2 k1 k2 v s1 s2 a.
(NMap map1 k1 map2 s1, NMap map2 k2 v s2) =>
map1 -> (k1 -> k2 -> v -> a) -> [a]
nTo1 map1
m1 k1 -> k2 -> v -> a
f =
  map1 -> (k1 -> map2 -> [a]) -> [a]
forall a map k v sort.
(Monoid a, NMap map k v sort) =>
map -> (k -> v -> a) -> a
nConcat map1
m1 ((k2 -> v -> a) -> map2 -> [a]
forall map k v sort a.
NMap map k v sort =>
(k -> v -> a) -> map -> [a]
nToWith ((k2 -> v -> a) -> map2 -> [a])
-> (k1 -> k2 -> v -> a) -> k1 -> map2 -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k1 -> k2 -> v -> a
f)

nToWith1 ::
  ∀ map1 map2 k1 k2 v s1 s2 a .
  NMap map1 k1 map2 s1 =>
  NMap map2 k2 v s2 =>
  (k1 -> k2 -> v -> a) ->
  map1 ->
  [a]
nToWith1 :: forall map1 map2 k1 k2 v s1 s2 a.
(NMap map1 k1 map2 s1, NMap map2 k2 v s2) =>
(k1 -> k2 -> v -> a) -> map1 -> [a]
nToWith1 k1 -> k2 -> v -> a
f =
  (k1 -> map2 -> [a]) -> map1 -> [a]
forall a map k v sort.
(Monoid a, NMap map k v sort) =>
(k -> v -> a) -> map -> a
nConcatWith ((k2 -> v -> a) -> map2 -> [a]
forall map k v sort a.
NMap map k v sort =>
(k -> v -> a) -> map -> [a]
nToWith ((k2 -> v -> a) -> map2 -> [a])
-> (k1 -> k2 -> v -> a) -> k1 -> map2 -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k1 -> k2 -> v -> a
f)

nFromKeys ::
  Foldable t =>
  NMap map k v sort =>
  t k ->
  (k -> v) ->
  map
nFromKeys :: forall (t :: * -> *) map k v sort.
(Foldable t, NMap map k v sort) =>
t k -> (k -> v) -> map
nFromKeys t k
keys k -> v
f =
  [(k, v)] -> map
forall map k v sort. NMap map k v sort => [(k, v)] -> map
nFromList (t k -> [k]
forall a. t a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList t k
keys [k] -> (k -> (k, v)) -> [(k, v)]
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \ k
k -> (k
k, k -> v
f k
k))

nFromKeysMaybe ::
  Foldable t =>
  NMap map k v sort =>
  t k ->
  (k -> Maybe v) ->
  map
nFromKeysMaybe :: forall (t :: * -> *) map k v sort.
(Foldable t, NMap map k v sort) =>
t k -> (k -> Maybe v) -> map
nFromKeysMaybe t k
keys k -> Maybe v
f =
  [(k, v)] -> map
forall map k v sort. NMap map k v sort => [(k, v)] -> map
nFromList (((k -> Maybe (k, v)) -> [k] -> [(k, v)])
-> [k] -> (k -> Maybe (k, v)) -> [(k, v)]
forall a b c. (a -> b -> c) -> b -> a -> c
flip (k -> Maybe (k, v)) -> [k] -> [(k, v)]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (t k -> [k]
forall a. t a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList t k
keys) \ k
k -> (k
k,) (v -> (k, v)) -> Maybe v -> Maybe (k, v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> k -> Maybe v
f k
k)

nBy ::
  Foldable t =>
  NMap map k v sort =>
  t v ->
  (v -> k) ->
  map
nBy :: forall (t :: * -> *) map k v sort.
(Foldable t, NMap map k v sort) =>
t v -> (v -> k) -> map
nBy t v
values v -> k
f =
  [(k, v)] -> map
forall map k v sort. NMap map k v sort => [(k, v)] -> map
nFromList (t v -> [v]
forall a. t a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList t v
values [v] -> (v -> (k, v)) -> [(k, v)]
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \ v
v -> (v -> k
f v
v, v
v))

nGen ::
  Foldable t =>
  NMap map k v sort =>
  t a ->
  (a -> (k, v)) ->
  map
nGen :: forall (t :: * -> *) map k v sort a.
(Foldable t, NMap map k v sort) =>
t a -> (a -> (k, v)) -> map
nGen t a
values a -> (k, v)
f =
  [(k, v)] -> map
forall map k v sort. NMap map k v sort => [(k, v)] -> map
nFromList (a -> (k, v)
f (a -> (k, v)) -> [a] -> [(k, v)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> t a -> [a]
forall a. t a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList t a
values)

nGenWith ::
  Foldable t =>
  NMap map k v sort =>
  (a -> (k, v)) ->
  t a ->
  map
nGenWith :: forall (t :: * -> *) map k v sort a.
(Foldable t, NMap map k v sort) =>
(a -> (k, v)) -> t a -> map
nGenWith =
  (t a -> (a -> (k, v)) -> map) -> (a -> (k, v)) -> t a -> map
forall a b c. (a -> b -> c) -> b -> a -> c
flip t a -> (a -> (k, v)) -> map
forall (t :: * -> *) map k v sort a.
(Foldable t, NMap map k v sort) =>
t a -> (a -> (k, v)) -> map
nGen

nGenMaybe ::
  Foldable t =>
  NMap map k v sort =>
  t a ->
  (a -> Maybe (k, v)) ->
  map
nGenMaybe :: forall (t :: * -> *) map k v sort a.
(Foldable t, NMap map k v sort) =>
t a -> (a -> Maybe (k, v)) -> map
nGenMaybe t a
values a -> Maybe (k, v)
f =
  [(k, v)] -> map
forall map k v sort. NMap map k v sort => [(k, v)] -> map
nFromList ((a -> Maybe (k, v)) -> [a] -> [(k, v)]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe a -> Maybe (k, v)
f (t a -> [a]
forall a. t a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList t a
values))

nForKeys ::
  Applicative m =>
  NMap map k v sort =>
  [k] ->
  (k -> m v) ->
  m map
nForKeys :: forall (m :: * -> *) map k v sort.
(Applicative m, NMap map k v sort) =>
[k] -> (k -> m v) -> m map
nForKeys [k]
keys k -> m v
f =
  [(k, v)] -> map
forall map k v sort. NMap map k v sort => [(k, v)] -> map
nFromList ([(k, v)] -> map) -> m [(k, v)] -> m map
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [k] -> (k -> m (k, v)) -> m [(k, v)]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for [k]
keys \ k
k -> (k
k,) (v -> (k, v)) -> m v -> m (k, v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> k -> m v
f k
k

nFor ::
  Applicative m =>
  NMap map k v sort =>
  [v] ->
  (v -> m k) ->
  m map
nFor :: forall (m :: * -> *) map k v sort.
(Applicative m, NMap map k v sort) =>
[v] -> (v -> m k) -> m map
nFor [v]
values v -> m k
f =
  [(k, v)] -> map
forall map k v sort. NMap map k v sort => [(k, v)] -> map
nFromList ([(k, v)] -> map) -> m [(k, v)] -> m map
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [v] -> (v -> m (k, v)) -> m [(k, v)]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for [v]
values \ v
v -> (,v
v) (k -> (k, v)) -> m k -> m (k, v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> v -> m k
f v
v

nElems ::
  ∀ map k v s .
  NMap map k v s =>
  map ->
  [v]
nElems :: forall map k v s. NMap map k v s => map -> [v]
nElems =
  Map k v -> [v]
forall k a. Map k a -> [a]
Map.elems (Map k v -> [v]) -> (map -> Map k v) -> map -> [v]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. map -> Map k v
forall map k v sort. NMap map k v sort => map -> Map k v
nGet

nElems1 ::
  ∀ map1 map2 k1 k2 v s1 s2 .
  NMap map1 k1 map2 s1 =>
  NMap map2 k2 v s2 =>
  map1 ->
  [v]
nElems1 :: forall map1 map2 k1 k2 v s1 s2.
(NMap map1 k1 map2 s1, NMap map2 k2 v s2) =>
map1 -> [v]
nElems1 =
  map2 -> [v]
forall map k v s. NMap map k v s => map -> [v]
nElems (map2 -> [v]) -> (map1 -> [map2]) -> map1 -> [v]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< map1 -> [map2]
forall map k v s. NMap map k v s => map -> [v]
nElems

nFlatten ::
  ∀ map1 map2 map3 k1 k2 v1 v2 s1 s2 .
  Monoid map2 =>
  NMap map1 k1 map2 LookupMonoid =>
  NMap map2 k2 v1 s1 =>
  NMap map3 k2 v2 s2 =>
  (v1 -> v2) ->
  map1 ->
  map3
nFlatten :: forall map1 map2 map3 k1 k2 v1 v2 s1 s2.
(Monoid map2, NMap map1 k1 map2 LookupMonoid, NMap map2 k2 v1 s1,
 NMap map3 k2 v2 s2) =>
(v1 -> v2) -> map1 -> map3
nFlatten v1 -> v2
f =
  (v1 -> v2) -> map2 -> map3
forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(v1 -> v2) -> map1 -> map2
nMap v1 -> v2
f (map2 -> map3) -> (map1 -> map2) -> map1 -> map3
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [map2] -> map2
forall a. Monoid a => [a] -> a
mconcat ([map2] -> map2) -> (map1 -> [map2]) -> map1 -> map2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. map1 -> [map2]
forall map k v s. NMap map k v s => map -> [v]
nElems

nKeys ::
  NMap map k v sort =>
  map ->
  [k]
nKeys :: forall map k v sort. NMap map k v sort => map -> [k]
nKeys =
  Map k v -> [k]
forall k a. Map k a -> [k]
Map.keys (Map k v -> [k]) -> (map -> Map k v) -> map -> [k]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. map -> Map k v
forall map k v sort. NMap map k v sort => map -> Map k v
nGet

nKeysSet ::
  NMap map k v sort =>
  map ->
  Set k
nKeysSet :: forall map k v sort. NMap map k v sort => map -> Set k
nKeysSet =
  Map k v -> Set k
forall k a. Map k a -> Set k
Map.keysSet (Map k v -> Set k) -> (map -> Map k v) -> map -> Set k
forall b c a. (b -> c) -> (a -> b) -> a -> c
. map -> Map k v
forall map k v sort. NMap map k v sort => map -> Map k v
nGet

nRestrictKeys ::
  NMap map k v sort =>
  Set k ->
  map ->
  map
nRestrictKeys :: forall map k v sort. NMap map k v sort => Set k -> map -> map
nRestrictKeys Set k
keys =
  (Map k v -> Map k v) -> map -> map
forall map1 k1 v1 s1 map2 k2 v2 s2.
(NMap map1 k1 v1 s1, NMap map2 k2 v2 s2) =>
(Map k1 v1 -> Map k2 v2) -> map1 -> map2
nVia (Map k v -> Set k -> Map k v
forall k a. Ord k => Map k a -> Set k -> Map k a
`Map.restrictKeys` Set k
keys)

nWithoutKeys ::
  NMap map k v sort =>
  Set k ->
  map ->
  map
nWithoutKeys :: forall map k v sort. NMap map k v sort => Set k -> map -> map
nWithoutKeys Set k
keys =
  (Map k v -> Map k v) -> map -> map
forall map1 k1 v1 s1 map2 k2 v2 s2.
(NMap map1 k1 v1 s1, NMap map2 k2 v2 s2) =>
(Map k1 v1 -> Map k2 v2) -> map1 -> map2
nVia (Map k v -> Set k -> Map k v
forall k a. Ord k => Map k a -> Set k -> Map k a
`Map.withoutKeys` Set k
keys)

nMember ::
  NMap map k v sort =>
  k ->
  map ->
  Bool
nMember :: forall map k v sort. NMap map k v sort => k -> map -> Bool
nMember k
k =
  k -> Map k v -> Bool
forall k a. Ord k => k -> Map k a -> Bool
Map.member k
k (Map k v -> Bool) -> (map -> Map k v) -> map -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. map -> Map k v
forall map k v sort. NMap map k v sort => map -> Map k v
nGet