{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE TemplateHaskellQuotes #-}
module Data.Aeson.KeyMap (
KeyMap,
null,
lookup,
size,
member,
empty,
singleton,
insert,
delete,
alterF,
difference,
union,
unionWith,
unionWithKey,
intersection,
intersectionWith,
intersectionWithKey,
alignWith,
alignWithKey,
fromList,
fromListWith,
toList,
toAscList,
fromHashMap,
toHashMap,
coercionToHashMap,
fromMap,
toMap,
coercionToMap,
fromHashMapText,
toHashMapText,
map,
mapKeyVal,
traverse,
traverseWithKey,
foldr,
foldr',
foldl,
foldl',
foldMapWithKey,
foldrWithKey,
keys,
filter,
filterWithKey,
mapMaybe,
mapMaybeWithKey,
) where
import Prelude (Eq(..), Ord((>)), Int, Bool(..), Maybe(..))
import Prelude ((.), ($))
import Prelude (Functor(fmap), Monad(..))
import Prelude (Show, showsPrec, showParen, shows, showString)
import Control.Applicative (Applicative)
import Control.DeepSeq (NFData(..))
import Data.Aeson.Key (Key)
import Data.Bifunctor (first)
import Data.Data (Data)
import Data.Hashable (Hashable(..))
import Data.HashMap.Strict (HashMap)
import Data.Map (Map)
import Data.Monoid (Monoid(mempty, mappend))
import Data.Semigroup (Semigroup((<>)))
import Data.Text (Text)
import Data.These (These (..))
import Data.Type.Coercion (Coercion (..))
import Data.Typeable (Typeable)
import Text.Read (Read (..), Lexeme(..), readListPrecDefault, prec, lexP, parens)
import qualified Data.Aeson.Key as Key
import qualified Data.Foldable as F
import qualified Data.Traversable as T
import qualified Data.HashMap.Strict as H
import qualified Data.List as L
import qualified Data.Map.Strict as M
import qualified Language.Haskell.TH.Syntax as TH
import qualified Data.Foldable.WithIndex as WI (FoldableWithIndex (..))
import qualified Data.Functor.WithIndex as WI (FunctorWithIndex (..))
import qualified Data.Traversable.WithIndex as WI (TraversableWithIndex (..))
import qualified Data.Semialign as SA
import qualified Data.Semialign.Indexed as SAI
import qualified Witherable as W
#ifdef USE_ORDEREDMAP
newtype KeyMap v = KeyMap { unKeyMap :: Map Key v }
deriving (Eq, Ord, Typeable, Data, Functor)
empty :: KeyMap v
empty = KeyMap M.empty
null :: KeyMap v -> Bool
null = M.null . unKeyMap
size :: KeyMap v -> Int
size = M.size . unKeyMap
singleton :: Key -> v -> KeyMap v
singleton k v = KeyMap (M.singleton k v)
member :: Key -> KeyMap a -> Bool
member t (KeyMap m) = M.member t m
delete :: Key -> KeyMap v -> KeyMap v
delete k (KeyMap m) = KeyMap (M.delete k m)
alterF :: Functor f => (Maybe v -> f (Maybe v)) -> Key -> KeyMap v -> f (KeyMap v)
#if MIN_VERSION_containers(0,5,8)
alterF f k = fmap KeyMap . M.alterF f k . unKeyMap
#else
alterF f k m = fmap g (f mv) where
g r = case r of
Nothing -> case mv of
Nothing -> m
Just _ -> delete k m
Just v' -> insert k v' m
mv = lookup k m
#endif
lookup :: Key -> KeyMap v -> Maybe v
lookup t tm = M.lookup t (unKeyMap tm)
insert :: Key -> v -> KeyMap v -> KeyMap v
insert k v tm = KeyMap (M.insert k v (unKeyMap tm))
map :: (a -> b) -> KeyMap a -> KeyMap b
map = fmap
mapWithKey :: (Key -> a -> b) -> KeyMap a -> KeyMap b
mapWithKey f (KeyMap m) = KeyMap (M.mapWithKey f m)
foldMapWithKey :: Monoid m => (Key -> a -> m) -> KeyMap a -> m
foldMapWithKey f (KeyMap m) = M.foldMapWithKey f m
foldr :: (a -> b -> b) -> b -> KeyMap a -> b
foldr f z (KeyMap m) = M.foldr f z m
foldr' :: (a -> b -> b) -> b -> KeyMap a -> b
foldr' f z (KeyMap m) = M.foldr' f z m
foldl :: (b -> a -> b) -> b -> KeyMap a -> b
foldl f z (KeyMap m) = M.foldl f z m
foldl' :: (b -> a -> b) -> b -> KeyMap a -> b
foldl' f z (KeyMap m) = M.foldl' f z m
foldrWithKey :: (Key -> v -> a -> a) -> a -> KeyMap v -> a
foldrWithKey f a = M.foldrWithKey f a . unKeyMap
traverse :: Applicative f => (v1 -> f v2) -> KeyMap v1 -> f (KeyMap v2)
traverse f = fmap KeyMap . T.traverse f . unKeyMap
traverseWithKey :: Applicative f => (Key -> v1 -> f v2) -> KeyMap v1 -> f (KeyMap v2)
traverseWithKey f = fmap KeyMap . M.traverseWithKey f . unKeyMap
fromListWith :: (v -> v -> v) -> [(Key, v)] -> KeyMap v
fromListWith op = KeyMap . M.fromListWith op
fromList :: [(Key, v)] -> KeyMap v
fromList = KeyMap . M.fromList
toList :: KeyMap v -> [(Key, v)]
toList = M.toList . unKeyMap
toAscList :: KeyMap v -> [(Key, v)]
toAscList = M.toAscList . unKeyMap
difference :: KeyMap v -> KeyMap v' -> KeyMap v
difference tm1 tm2 = KeyMap (M.difference (unKeyMap tm1) (unKeyMap tm2))
union :: KeyMap v -> KeyMap v -> KeyMap v
union (KeyMap x) (KeyMap y) = KeyMap (M.union x y)
unionWith :: (v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v
unionWith f (KeyMap x) (KeyMap y) = KeyMap (M.unionWith f x y)
unionWithKey :: (Key -> v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v
unionWithKey f (KeyMap x) (KeyMap y) = KeyMap (M.unionWithKey f x y)
intersection :: KeyMap a -> KeyMap b -> KeyMap a
intersection (KeyMap x) (KeyMap y) = KeyMap (M.intersection x y)
intersectionWith :: (a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
intersectionWith f (KeyMap x) (KeyMap y) = KeyMap (M.intersectionWith f x y)
intersectionWithKey :: (Key -> a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
intersectionWithKey f (KeyMap x) (KeyMap y) = KeyMap (M.intersectionWithKey f x y)
keys :: KeyMap v -> [Key]
keys = M.keys . unKeyMap
toHashMap :: KeyMap v -> HashMap Key v
toHashMap = H.fromList . toList
fromHashMap :: HashMap Key v -> KeyMap v
fromHashMap = fromList . H.toList
toMap :: KeyMap v -> Map Key v
toMap = unKeyMap
fromMap :: Map Key v -> KeyMap v
fromMap = KeyMap
coercionToHashMap :: Maybe (Coercion (HashMap Key v) (KeyMap v))
coercionToHashMap = Nothing
{-# INLINE coercionToHashMap #-}
coercionToMap :: Maybe (Coercion (Map Key v) (KeyMap v))
coercionToMap = Just Coercion
{-# INLINE coercionToMap #-}
mapKeyVal :: (Key -> Key) -> (v1 -> v2)
-> KeyMap v1 -> KeyMap v2
mapKeyVal fk kv = foldrWithKey (\k v -> insert (fk k) (kv v)) empty
{-# INLINE mapKeyVal #-}
filter :: (v -> Bool) -> KeyMap v -> KeyMap v
filter f (KeyMap m) = KeyMap (M.filter f m)
filterWithKey :: (Key -> v -> Bool) -> KeyMap v -> KeyMap v
filterWithKey f (KeyMap m) = KeyMap (M.filterWithKey f m)
mapMaybe :: (a -> Maybe b) -> KeyMap a -> KeyMap b
mapMaybe f (KeyMap m) = KeyMap (M.mapMaybe f m)
mapMaybeWithKey :: (Key -> v -> Maybe u) -> KeyMap v -> KeyMap u
mapMaybeWithKey f (KeyMap m) = KeyMap (M.mapMaybeWithKey f m)
#else
import Data.List (sortBy)
import Data.Ord (comparing)
import Prelude (fst)
newtype KeyMap v = KeyMap { KeyMap v -> HashMap Key v
unKeyMap :: HashMap Key v }
deriving (KeyMap v -> KeyMap v -> Bool
(KeyMap v -> KeyMap v -> Bool)
-> (KeyMap v -> KeyMap v -> Bool) -> Eq (KeyMap v)
forall v. Eq v => KeyMap v -> KeyMap v -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: KeyMap v -> KeyMap v -> Bool
$c/= :: forall v. Eq v => KeyMap v -> KeyMap v -> Bool
== :: KeyMap v -> KeyMap v -> Bool
$c== :: forall v. Eq v => KeyMap v -> KeyMap v -> Bool
Eq, Eq (KeyMap v)
Eq (KeyMap v)
-> (KeyMap v -> KeyMap v -> Ordering)
-> (KeyMap v -> KeyMap v -> Bool)
-> (KeyMap v -> KeyMap v -> Bool)
-> (KeyMap v -> KeyMap v -> Bool)
-> (KeyMap v -> KeyMap v -> Bool)
-> (KeyMap v -> KeyMap v -> KeyMap v)
-> (KeyMap v -> KeyMap v -> KeyMap v)
-> Ord (KeyMap v)
KeyMap v -> KeyMap v -> Bool
KeyMap v -> KeyMap v -> Ordering
KeyMap v -> KeyMap v -> KeyMap v
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall v. Ord v => Eq (KeyMap v)
forall v. Ord v => KeyMap v -> KeyMap v -> Bool
forall v. Ord v => KeyMap v -> KeyMap v -> Ordering
forall v. Ord v => KeyMap v -> KeyMap v -> KeyMap v
min :: KeyMap v -> KeyMap v -> KeyMap v
$cmin :: forall v. Ord v => KeyMap v -> KeyMap v -> KeyMap v
max :: KeyMap v -> KeyMap v -> KeyMap v
$cmax :: forall v. Ord v => KeyMap v -> KeyMap v -> KeyMap v
>= :: KeyMap v -> KeyMap v -> Bool
$c>= :: forall v. Ord v => KeyMap v -> KeyMap v -> Bool
> :: KeyMap v -> KeyMap v -> Bool
$c> :: forall v. Ord v => KeyMap v -> KeyMap v -> Bool
<= :: KeyMap v -> KeyMap v -> Bool
$c<= :: forall v. Ord v => KeyMap v -> KeyMap v -> Bool
< :: KeyMap v -> KeyMap v -> Bool
$c< :: forall v. Ord v => KeyMap v -> KeyMap v -> Bool
compare :: KeyMap v -> KeyMap v -> Ordering
$ccompare :: forall v. Ord v => KeyMap v -> KeyMap v -> Ordering
$cp1Ord :: forall v. Ord v => Eq (KeyMap v)
Ord, Typeable, Typeable (KeyMap v)
DataType
Constr
Typeable (KeyMap v)
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyMap v -> c (KeyMap v))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (KeyMap v))
-> (KeyMap v -> Constr)
-> (KeyMap v -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (KeyMap v)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (KeyMap v)))
-> ((forall b. Data b => b -> b) -> KeyMap v -> KeyMap v)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyMap v -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyMap v -> r)
-> (forall u. (forall d. Data d => d -> u) -> KeyMap v -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> KeyMap v -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KeyMap v -> m (KeyMap v))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyMap v -> m (KeyMap v))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyMap v -> m (KeyMap v))
-> Data (KeyMap v)
KeyMap v -> DataType
KeyMap v -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (KeyMap v))
(forall b. Data b => b -> b) -> KeyMap v -> KeyMap v
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyMap v -> c (KeyMap v)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (KeyMap v)
forall v. Data v => Typeable (KeyMap v)
forall v. Data v => KeyMap v -> DataType
forall v. Data v => KeyMap v -> Constr
forall v.
Data v =>
(forall b. Data b => b -> b) -> KeyMap v -> KeyMap v
forall v u.
Data v =>
Int -> (forall d. Data d => d -> u) -> KeyMap v -> u
forall v u.
Data v =>
(forall d. Data d => d -> u) -> KeyMap v -> [u]
forall v r r'.
Data v =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyMap v -> r
forall v r r'.
Data v =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyMap v -> r
forall v (m :: * -> *).
(Data v, Monad m) =>
(forall d. Data d => d -> m d) -> KeyMap v -> m (KeyMap v)
forall v (m :: * -> *).
(Data v, MonadPlus m) =>
(forall d. Data d => d -> m d) -> KeyMap v -> m (KeyMap v)
forall v (c :: * -> *).
Data v =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (KeyMap v)
forall v (c :: * -> *).
Data v =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyMap v -> c (KeyMap v)
forall v (t :: * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (KeyMap v))
forall v (t :: * -> * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (KeyMap v))
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> KeyMap v -> u
forall u. (forall d. Data d => d -> u) -> KeyMap v -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyMap v -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyMap v -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KeyMap v -> m (KeyMap v)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyMap v -> m (KeyMap v)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (KeyMap v)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyMap v -> c (KeyMap v)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (KeyMap v))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (KeyMap v))
$cKeyMap :: Constr
$tKeyMap :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> KeyMap v -> m (KeyMap v)
$cgmapMo :: forall v (m :: * -> *).
(Data v, MonadPlus m) =>
(forall d. Data d => d -> m d) -> KeyMap v -> m (KeyMap v)
gmapMp :: (forall d. Data d => d -> m d) -> KeyMap v -> m (KeyMap v)
$cgmapMp :: forall v (m :: * -> *).
(Data v, MonadPlus m) =>
(forall d. Data d => d -> m d) -> KeyMap v -> m (KeyMap v)
gmapM :: (forall d. Data d => d -> m d) -> KeyMap v -> m (KeyMap v)
$cgmapM :: forall v (m :: * -> *).
(Data v, Monad m) =>
(forall d. Data d => d -> m d) -> KeyMap v -> m (KeyMap v)
gmapQi :: Int -> (forall d. Data d => d -> u) -> KeyMap v -> u
$cgmapQi :: forall v u.
Data v =>
Int -> (forall d. Data d => d -> u) -> KeyMap v -> u
gmapQ :: (forall d. Data d => d -> u) -> KeyMap v -> [u]
$cgmapQ :: forall v u.
Data v =>
(forall d. Data d => d -> u) -> KeyMap v -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyMap v -> r
$cgmapQr :: forall v r r'.
Data v =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyMap v -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyMap v -> r
$cgmapQl :: forall v r r'.
Data v =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyMap v -> r
gmapT :: (forall b. Data b => b -> b) -> KeyMap v -> KeyMap v
$cgmapT :: forall v.
Data v =>
(forall b. Data b => b -> b) -> KeyMap v -> KeyMap v
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (KeyMap v))
$cdataCast2 :: forall v (t :: * -> * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (KeyMap v))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (KeyMap v))
$cdataCast1 :: forall v (t :: * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (KeyMap v))
dataTypeOf :: KeyMap v -> DataType
$cdataTypeOf :: forall v. Data v => KeyMap v -> DataType
toConstr :: KeyMap v -> Constr
$ctoConstr :: forall v. Data v => KeyMap v -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (KeyMap v)
$cgunfold :: forall v (c :: * -> *).
Data v =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (KeyMap v)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyMap v -> c (KeyMap v)
$cgfoldl :: forall v (c :: * -> *).
Data v =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyMap v -> c (KeyMap v)
$cp1Data :: forall v. Data v => Typeable (KeyMap v)
Data, a -> KeyMap b -> KeyMap a
(a -> b) -> KeyMap a -> KeyMap b
(forall a b. (a -> b) -> KeyMap a -> KeyMap b)
-> (forall a b. a -> KeyMap b -> KeyMap a) -> Functor KeyMap
forall a b. a -> KeyMap b -> KeyMap a
forall a b. (a -> b) -> KeyMap a -> KeyMap b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> KeyMap b -> KeyMap a
$c<$ :: forall a b. a -> KeyMap b -> KeyMap a
fmap :: (a -> b) -> KeyMap a -> KeyMap b
$cfmap :: forall a b. (a -> b) -> KeyMap a -> KeyMap b
Functor)
empty :: KeyMap v
empty :: KeyMap v
empty = HashMap Key v -> KeyMap v
forall v. HashMap Key v -> KeyMap v
KeyMap HashMap Key v
forall k v. HashMap k v
H.empty
null :: KeyMap v -> Bool
null :: KeyMap v -> Bool
null = HashMap Key v -> Bool
forall k v. HashMap k v -> Bool
H.null (HashMap Key v -> Bool)
-> (KeyMap v -> HashMap Key v) -> KeyMap v -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyMap v -> HashMap Key v
forall v. KeyMap v -> HashMap Key v
unKeyMap
size :: KeyMap v -> Int
size :: KeyMap v -> Int
size = HashMap Key v -> Int
forall k v. HashMap k v -> Int
H.size (HashMap Key v -> Int)
-> (KeyMap v -> HashMap Key v) -> KeyMap v -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyMap v -> HashMap Key v
forall v. KeyMap v -> HashMap Key v
unKeyMap
singleton :: Key -> v -> KeyMap v
singleton :: Key -> v -> KeyMap v
singleton Key
k v
v = HashMap Key v -> KeyMap v
forall v. HashMap Key v -> KeyMap v
KeyMap (Key -> v -> HashMap Key v
forall k v. Hashable k => k -> v -> HashMap k v
H.singleton Key
k v
v)
member :: Key -> KeyMap a -> Bool
member :: Key -> KeyMap a -> Bool
member Key
t (KeyMap HashMap Key a
m) = Key -> HashMap Key a -> Bool
forall k a. (Eq k, Hashable k) => k -> HashMap k a -> Bool
H.member Key
t HashMap Key a
m
delete :: Key -> KeyMap v -> KeyMap v
delete :: Key -> KeyMap v -> KeyMap v
delete Key
k (KeyMap HashMap Key v
m) = HashMap Key v -> KeyMap v
forall v. HashMap Key v -> KeyMap v
KeyMap (Key -> HashMap Key v -> HashMap Key v
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> HashMap k v
H.delete Key
k HashMap Key v
m)
alterF :: Functor f => (Maybe v -> f (Maybe v)) -> Key -> KeyMap v -> f (KeyMap v)
alterF :: (Maybe v -> f (Maybe v)) -> Key -> KeyMap v -> f (KeyMap v)
alterF Maybe v -> f (Maybe v)
f Key
k = (HashMap Key v -> KeyMap v) -> f (HashMap Key v) -> f (KeyMap v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap HashMap Key v -> KeyMap v
forall v. HashMap Key v -> KeyMap v
KeyMap (f (HashMap Key v) -> f (KeyMap v))
-> (KeyMap v -> f (HashMap Key v)) -> KeyMap v -> f (KeyMap v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe v -> f (Maybe v))
-> Key -> HashMap Key v -> f (HashMap Key v)
forall (f :: * -> *) k v.
(Functor f, Eq k, Hashable k) =>
(Maybe v -> f (Maybe v)) -> k -> HashMap k v -> f (HashMap k v)
H.alterF Maybe v -> f (Maybe v)
f Key
k (HashMap Key v -> f (HashMap Key v))
-> (KeyMap v -> HashMap Key v) -> KeyMap v -> f (HashMap Key v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyMap v -> HashMap Key v
forall v. KeyMap v -> HashMap Key v
unKeyMap
lookup :: Key -> KeyMap v -> Maybe v
lookup :: Key -> KeyMap v -> Maybe v
lookup Key
t KeyMap v
tm = Key -> HashMap Key v -> Maybe v
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
H.lookup Key
t (KeyMap v -> HashMap Key v
forall v. KeyMap v -> HashMap Key v
unKeyMap KeyMap v
tm)
insert :: Key -> v -> KeyMap v -> KeyMap v
insert :: Key -> v -> KeyMap v -> KeyMap v
insert Key
k v
v KeyMap v
tm = HashMap Key v -> KeyMap v
forall v. HashMap Key v -> KeyMap v
KeyMap (Key -> v -> HashMap Key v -> HashMap Key v
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
H.insert Key
k v
v (KeyMap v -> HashMap Key v
forall v. KeyMap v -> HashMap Key v
unKeyMap KeyMap v
tm))
map :: (a -> b) -> KeyMap a -> KeyMap b
map :: (a -> b) -> KeyMap a -> KeyMap b
map = (a -> b) -> KeyMap a -> KeyMap b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
mapWithKey :: (Key -> a -> b) -> KeyMap a -> KeyMap b
mapWithKey :: (Key -> a -> b) -> KeyMap a -> KeyMap b
mapWithKey Key -> a -> b
f (KeyMap HashMap Key a
m) = HashMap Key b -> KeyMap b
forall v. HashMap Key v -> KeyMap v
KeyMap ((Key -> a -> b) -> HashMap Key a -> HashMap Key b
forall k v1 v2. (k -> v1 -> v2) -> HashMap k v1 -> HashMap k v2
H.mapWithKey Key -> a -> b
f HashMap Key a
m)
foldMapWithKey :: Monoid m => (Key -> a -> m) -> KeyMap a -> m
foldMapWithKey :: (Key -> a -> m) -> KeyMap a -> m
foldMapWithKey Key -> a -> m
f (KeyMap HashMap Key a
m) = (Key -> a -> m) -> HashMap Key a -> m
forall m k v. Monoid m => (k -> v -> m) -> HashMap k v -> m
H.foldMapWithKey Key -> a -> m
f HashMap Key a
m
foldr :: (a -> b -> b) -> b -> KeyMap a -> b
foldr :: (a -> b -> b) -> b -> KeyMap a -> b
foldr a -> b -> b
f b
z (KeyMap HashMap Key a
m) = (a -> b -> b) -> b -> HashMap Key a -> b
forall v a k. (v -> a -> a) -> a -> HashMap k v -> a
H.foldr a -> b -> b
f b
z HashMap Key a
m
foldr' :: (a -> b -> b) -> b -> KeyMap a -> b
foldr' :: (a -> b -> b) -> b -> KeyMap a -> b
foldr' a -> b -> b
f b
z (KeyMap HashMap Key a
m) = (a -> b -> b) -> b -> HashMap Key a -> b
forall v a k. (v -> a -> a) -> a -> HashMap k v -> a
H.foldr' a -> b -> b
f b
z HashMap Key a
m
foldl :: (b -> a -> b) -> b -> KeyMap a -> b
foldl :: (b -> a -> b) -> b -> KeyMap a -> b
foldl b -> a -> b
f b
z (KeyMap HashMap Key a
m) = (b -> a -> b) -> b -> HashMap Key a -> b
forall a v k. (a -> v -> a) -> a -> HashMap k v -> a
H.foldl b -> a -> b
f b
z HashMap Key a
m
foldl' :: (b -> a -> b) -> b -> KeyMap a -> b
foldl' :: (b -> a -> b) -> b -> KeyMap a -> b
foldl' b -> a -> b
f b
z (KeyMap HashMap Key a
m) = (b -> a -> b) -> b -> HashMap Key a -> b
forall a v k. (a -> v -> a) -> a -> HashMap k v -> a
H.foldl' b -> a -> b
f b
z HashMap Key a
m
foldrWithKey :: (Key -> v -> a -> a) -> a -> KeyMap v -> a
foldrWithKey :: (Key -> v -> a -> a) -> a -> KeyMap v -> a
foldrWithKey Key -> v -> a -> a
f a
a = (Key -> v -> a -> a) -> a -> HashMap Key v -> a
forall k v a. (k -> v -> a -> a) -> a -> HashMap k v -> a
H.foldrWithKey Key -> v -> a -> a
f a
a (HashMap Key v -> a)
-> (KeyMap v -> HashMap Key v) -> KeyMap v -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyMap v -> HashMap Key v
forall v. KeyMap v -> HashMap Key v
unKeyMap
traverse :: Applicative f => (v1 -> f v2) -> KeyMap v1 -> f (KeyMap v2)
traverse :: (v1 -> f v2) -> KeyMap v1 -> f (KeyMap v2)
traverse v1 -> f v2
f = (HashMap Key v2 -> KeyMap v2)
-> f (HashMap Key v2) -> f (KeyMap v2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap HashMap Key v2 -> KeyMap v2
forall v. HashMap Key v -> KeyMap v
KeyMap (f (HashMap Key v2) -> f (KeyMap v2))
-> (KeyMap v1 -> f (HashMap Key v2)) -> KeyMap v1 -> f (KeyMap v2)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v1 -> f v2) -> HashMap Key v1 -> f (HashMap Key v2)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
T.traverse v1 -> f v2
f (HashMap Key v1 -> f (HashMap Key v2))
-> (KeyMap v1 -> HashMap Key v1) -> KeyMap v1 -> f (HashMap Key v2)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyMap v1 -> HashMap Key v1
forall v. KeyMap v -> HashMap Key v
unKeyMap
traverseWithKey :: Applicative f => (Key -> v1 -> f v2) -> KeyMap v1 -> f (KeyMap v2)
traverseWithKey :: (Key -> v1 -> f v2) -> KeyMap v1 -> f (KeyMap v2)
traverseWithKey Key -> v1 -> f v2
f = (HashMap Key v2 -> KeyMap v2)
-> f (HashMap Key v2) -> f (KeyMap v2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap HashMap Key v2 -> KeyMap v2
forall v. HashMap Key v -> KeyMap v
KeyMap (f (HashMap Key v2) -> f (KeyMap v2))
-> (KeyMap v1 -> f (HashMap Key v2)) -> KeyMap v1 -> f (KeyMap v2)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Key -> v1 -> f v2) -> HashMap Key v1 -> f (HashMap Key v2)
forall (f :: * -> *) k v1 v2.
Applicative f =>
(k -> v1 -> f v2) -> HashMap k v1 -> f (HashMap k v2)
H.traverseWithKey Key -> v1 -> f v2
f (HashMap Key v1 -> f (HashMap Key v2))
-> (KeyMap v1 -> HashMap Key v1) -> KeyMap v1 -> f (HashMap Key v2)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyMap v1 -> HashMap Key v1
forall v. KeyMap v -> HashMap Key v
unKeyMap
fromListWith :: (v -> v -> v) -> [(Key, v)] -> KeyMap v
fromListWith :: (v -> v -> v) -> [(Key, v)] -> KeyMap v
fromListWith v -> v -> v
op = HashMap Key v -> KeyMap v
forall v. HashMap Key v -> KeyMap v
KeyMap (HashMap Key v -> KeyMap v)
-> ([(Key, v)] -> HashMap Key v) -> [(Key, v)] -> KeyMap v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v -> v -> v) -> [(Key, v)] -> HashMap Key v
forall k v.
(Eq k, Hashable k) =>
(v -> v -> v) -> [(k, v)] -> HashMap k v
H.fromListWith v -> v -> v
op
fromList :: [(Key, v)] -> KeyMap v
fromList :: [(Key, v)] -> KeyMap v
fromList = HashMap Key v -> KeyMap v
forall v. HashMap Key v -> KeyMap v
KeyMap (HashMap Key v -> KeyMap v)
-> ([(Key, v)] -> HashMap Key v) -> [(Key, v)] -> KeyMap v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Key, v)] -> HashMap Key v
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
H.fromList
toList :: KeyMap v -> [(Key, v)]
toList :: KeyMap v -> [(Key, v)]
toList = HashMap Key v -> [(Key, v)]
forall k v. HashMap k v -> [(k, v)]
H.toList (HashMap Key v -> [(Key, v)])
-> (KeyMap v -> HashMap Key v) -> KeyMap v -> [(Key, v)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyMap v -> HashMap Key v
forall v. KeyMap v -> HashMap Key v
unKeyMap
toAscList :: KeyMap v -> [(Key, v)]
toAscList :: KeyMap v -> [(Key, v)]
toAscList = ((Key, v) -> (Key, v) -> Ordering) -> [(Key, v)] -> [(Key, v)]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy (((Key, v) -> Key) -> (Key, v) -> (Key, v) -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing (Key, v) -> Key
forall a b. (a, b) -> a
fst) ([(Key, v)] -> [(Key, v)])
-> (KeyMap v -> [(Key, v)]) -> KeyMap v -> [(Key, v)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyMap v -> [(Key, v)]
forall v. KeyMap v -> [(Key, v)]
toList
difference :: KeyMap v -> KeyMap v' -> KeyMap v
difference :: KeyMap v -> KeyMap v' -> KeyMap v
difference KeyMap v
tm1 KeyMap v'
tm2 = HashMap Key v -> KeyMap v
forall v. HashMap Key v -> KeyMap v
KeyMap (HashMap Key v -> HashMap Key v' -> HashMap Key v
forall k v w.
(Eq k, Hashable k) =>
HashMap k v -> HashMap k w -> HashMap k v
H.difference (KeyMap v -> HashMap Key v
forall v. KeyMap v -> HashMap Key v
unKeyMap KeyMap v
tm1) (KeyMap v' -> HashMap Key v'
forall v. KeyMap v -> HashMap Key v
unKeyMap KeyMap v'
tm2))
union :: KeyMap v -> KeyMap v -> KeyMap v
union :: KeyMap v -> KeyMap v -> KeyMap v
union (KeyMap HashMap Key v
x) (KeyMap HashMap Key v
y) = HashMap Key v -> KeyMap v
forall v. HashMap Key v -> KeyMap v
KeyMap (HashMap Key v -> HashMap Key v -> HashMap Key v
forall k v.
(Eq k, Hashable k) =>
HashMap k v -> HashMap k v -> HashMap k v
H.union HashMap Key v
x HashMap Key v
y)
unionWith :: (v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v
unionWith :: (v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v
unionWith v -> v -> v
f (KeyMap HashMap Key v
x) (KeyMap HashMap Key v
y) = HashMap Key v -> KeyMap v
forall v. HashMap Key v -> KeyMap v
KeyMap ((v -> v -> v) -> HashMap Key v -> HashMap Key v -> HashMap Key v
forall k v.
(Eq k, Hashable k) =>
(v -> v -> v) -> HashMap k v -> HashMap k v -> HashMap k v
H.unionWith v -> v -> v
f HashMap Key v
x HashMap Key v
y)
unionWithKey :: (Key -> v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v
unionWithKey :: (Key -> v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v
unionWithKey Key -> v -> v -> v
f (KeyMap HashMap Key v
x) (KeyMap HashMap Key v
y) = HashMap Key v -> KeyMap v
forall v. HashMap Key v -> KeyMap v
KeyMap ((Key -> v -> v -> v)
-> HashMap Key v -> HashMap Key v -> HashMap Key v
forall k v.
(Eq k, Hashable k) =>
(k -> v -> v -> v) -> HashMap k v -> HashMap k v -> HashMap k v
H.unionWithKey Key -> v -> v -> v
f HashMap Key v
x HashMap Key v
y)
intersection :: KeyMap a -> KeyMap b -> KeyMap a
intersection :: KeyMap a -> KeyMap b -> KeyMap a
intersection (KeyMap HashMap Key a
x) (KeyMap HashMap Key b
y) = HashMap Key a -> KeyMap a
forall v. HashMap Key v -> KeyMap v
KeyMap (HashMap Key a -> HashMap Key b -> HashMap Key a
forall k v w.
(Eq k, Hashable k) =>
HashMap k v -> HashMap k w -> HashMap k v
H.intersection HashMap Key a
x HashMap Key b
y)
intersectionWith :: (a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
intersectionWith :: (a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
intersectionWith a -> b -> c
f (KeyMap HashMap Key a
x) (KeyMap HashMap Key b
y) = HashMap Key c -> KeyMap c
forall v. HashMap Key v -> KeyMap v
KeyMap ((a -> b -> c) -> HashMap Key a -> HashMap Key b -> HashMap Key c
forall k v1 v2 v3.
(Eq k, Hashable k) =>
(v1 -> v2 -> v3) -> HashMap k v1 -> HashMap k v2 -> HashMap k v3
H.intersectionWith a -> b -> c
f HashMap Key a
x HashMap Key b
y)
intersectionWithKey :: (Key -> a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
intersectionWithKey :: (Key -> a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
intersectionWithKey Key -> a -> b -> c
f (KeyMap HashMap Key a
x) (KeyMap HashMap Key b
y) = HashMap Key c -> KeyMap c
forall v. HashMap Key v -> KeyMap v
KeyMap ((Key -> a -> b -> c)
-> HashMap Key a -> HashMap Key b -> HashMap Key c
forall k v1 v2 v3.
(Eq k, Hashable k) =>
(k -> v1 -> v2 -> v3)
-> HashMap k v1 -> HashMap k v2 -> HashMap k v3
H.intersectionWithKey Key -> a -> b -> c
f HashMap Key a
x HashMap Key b
y)
keys :: KeyMap v -> [Key]
keys :: KeyMap v -> [Key]
keys = HashMap Key v -> [Key]
forall k v. HashMap k v -> [k]
H.keys (HashMap Key v -> [Key])
-> (KeyMap v -> HashMap Key v) -> KeyMap v -> [Key]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyMap v -> HashMap Key v
forall v. KeyMap v -> HashMap Key v
unKeyMap
toHashMap :: KeyMap v -> HashMap Key v
toHashMap :: KeyMap v -> HashMap Key v
toHashMap = KeyMap v -> HashMap Key v
forall v. KeyMap v -> HashMap Key v
unKeyMap
fromHashMap :: HashMap Key v -> KeyMap v
fromHashMap :: HashMap Key v -> KeyMap v
fromHashMap = HashMap Key v -> KeyMap v
forall v. HashMap Key v -> KeyMap v
KeyMap
toMap :: KeyMap v -> Map Key v
toMap :: KeyMap v -> Map Key v
toMap = [(Key, v)] -> Map Key v
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([(Key, v)] -> Map Key v)
-> (KeyMap v -> [(Key, v)]) -> KeyMap v -> Map Key v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyMap v -> [(Key, v)]
forall v. KeyMap v -> [(Key, v)]
toList
fromMap :: Map Key v -> KeyMap v
fromMap :: Map Key v -> KeyMap v
fromMap = [(Key, v)] -> KeyMap v
forall v. [(Key, v)] -> KeyMap v
fromList ([(Key, v)] -> KeyMap v)
-> (Map Key v -> [(Key, v)]) -> Map Key v -> KeyMap v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map Key v -> [(Key, v)]
forall k a. Map k a -> [(k, a)]
M.toList
coercionToHashMap :: Maybe (Coercion (HashMap Key v) (KeyMap v))
coercionToHashMap :: Maybe (Coercion (HashMap Key v) (KeyMap v))
coercionToHashMap = Coercion (HashMap Key v) (KeyMap v)
-> Maybe (Coercion (HashMap Key v) (KeyMap v))
forall a. a -> Maybe a
Just Coercion (HashMap Key v) (KeyMap v)
forall k (a :: k) (b :: k). Coercible a b => Coercion a b
Coercion
{-# INLINE coercionToHashMap #-}
coercionToMap :: Maybe (Coercion (Map Key v) (KeyMap v))
coercionToMap :: Maybe (Coercion (Map Key v) (KeyMap v))
coercionToMap = Maybe (Coercion (Map Key v) (KeyMap v))
forall a. Maybe a
Nothing
{-# INLINE coercionToMap #-}
mapKeyVal :: (Key -> Key) -> (v1 -> v2)
-> KeyMap v1 -> KeyMap v2
mapKeyVal :: (Key -> Key) -> (v1 -> v2) -> KeyMap v1 -> KeyMap v2
mapKeyVal Key -> Key
fk v1 -> v2
kv = (Key -> v1 -> KeyMap v2 -> KeyMap v2)
-> KeyMap v2 -> KeyMap v1 -> KeyMap v2
forall v a. (Key -> v -> a -> a) -> a -> KeyMap v -> a
foldrWithKey (\Key
k v1
v -> Key -> v2 -> KeyMap v2 -> KeyMap v2
forall v. Key -> v -> KeyMap v -> KeyMap v
insert (Key -> Key
fk Key
k) (v1 -> v2
kv v1
v)) KeyMap v2
forall v. KeyMap v
empty
{-# INLINE mapKeyVal #-}
filter :: (v -> Bool) -> KeyMap v -> KeyMap v
filter :: (v -> Bool) -> KeyMap v -> KeyMap v
filter v -> Bool
f (KeyMap HashMap Key v
m) = HashMap Key v -> KeyMap v
forall v. HashMap Key v -> KeyMap v
KeyMap ((v -> Bool) -> HashMap Key v -> HashMap Key v
forall v k. (v -> Bool) -> HashMap k v -> HashMap k v
H.filter v -> Bool
f HashMap Key v
m)
filterWithKey :: (Key -> v -> Bool) -> KeyMap v -> KeyMap v
filterWithKey :: (Key -> v -> Bool) -> KeyMap v -> KeyMap v
filterWithKey Key -> v -> Bool
f (KeyMap HashMap Key v
m) = HashMap Key v -> KeyMap v
forall v. HashMap Key v -> KeyMap v
KeyMap ((Key -> v -> Bool) -> HashMap Key v -> HashMap Key v
forall k v. (k -> v -> Bool) -> HashMap k v -> HashMap k v
H.filterWithKey Key -> v -> Bool
f HashMap Key v
m)
mapMaybe :: (a -> Maybe b) -> KeyMap a -> KeyMap b
mapMaybe :: (a -> Maybe b) -> KeyMap a -> KeyMap b
mapMaybe a -> Maybe b
f (KeyMap HashMap Key a
m) = HashMap Key b -> KeyMap b
forall v. HashMap Key v -> KeyMap v
KeyMap ((a -> Maybe b) -> HashMap Key a -> HashMap Key b
forall v1 v2 k. (v1 -> Maybe v2) -> HashMap k v1 -> HashMap k v2
H.mapMaybe a -> Maybe b
f HashMap Key a
m)
mapMaybeWithKey :: (Key -> v -> Maybe u) -> KeyMap v -> KeyMap u
mapMaybeWithKey :: (Key -> v -> Maybe u) -> KeyMap v -> KeyMap u
mapMaybeWithKey Key -> v -> Maybe u
f (KeyMap HashMap Key v
m) = HashMap Key u -> KeyMap u
forall v. HashMap Key v -> KeyMap v
KeyMap ((Key -> v -> Maybe u) -> HashMap Key v -> HashMap Key u
forall k v1 v2.
(k -> v1 -> Maybe v2) -> HashMap k v1 -> HashMap k v2
H.mapMaybeWithKey Key -> v -> Maybe u
f HashMap Key v
m)
#endif
alignWith :: (These a b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
alignWith :: (These a b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
alignWith These a b -> c
f (KeyMap HashMap Key a
x) (KeyMap HashMap Key b
y) = HashMap Key c -> KeyMap c
forall v. HashMap Key v -> KeyMap v
KeyMap ((These a b -> c) -> HashMap Key a -> HashMap Key b -> HashMap Key c
forall (f :: * -> *) a b c.
Semialign f =>
(These a b -> c) -> f a -> f b -> f c
SA.alignWith These a b -> c
f HashMap Key a
x HashMap Key b
y)
alignWithKey :: (Key -> These a b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
alignWithKey :: (Key -> These a b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
alignWithKey Key -> These a b -> c
f (KeyMap HashMap Key a
x) (KeyMap HashMap Key b
y) = HashMap Key c -> KeyMap c
forall v. HashMap Key v -> KeyMap v
KeyMap ((Key -> These a b -> c)
-> HashMap Key a -> HashMap Key b -> HashMap Key c
forall i (f :: * -> *) a b c.
SemialignWithIndex i f =>
(i -> These a b -> c) -> f a -> f b -> f c
SAI.ialignWith Key -> These a b -> c
f HashMap Key a
x HashMap Key b
y)
toHashMapText :: KeyMap v -> HashMap Text v
toHashMapText :: KeyMap v -> HashMap Text v
toHashMapText = [(Text, v)] -> HashMap Text v
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
H.fromList ([(Text, v)] -> HashMap Text v)
-> (KeyMap v -> [(Text, v)]) -> KeyMap v -> HashMap Text v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Key, v) -> (Text, v)) -> [(Key, v)] -> [(Text, v)]
forall a b. (a -> b) -> [a] -> [b]
L.map ((Key -> Text) -> (Key, v) -> (Text, v)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first Key -> Text
Key.toText) ([(Key, v)] -> [(Text, v)])
-> (KeyMap v -> [(Key, v)]) -> KeyMap v -> [(Text, v)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyMap v -> [(Key, v)]
forall v. KeyMap v -> [(Key, v)]
toList
fromHashMapText :: HashMap Text v -> KeyMap v
fromHashMapText :: HashMap Text v -> KeyMap v
fromHashMapText = [(Key, v)] -> KeyMap v
forall v. [(Key, v)] -> KeyMap v
fromList ([(Key, v)] -> KeyMap v)
-> (HashMap Text v -> [(Key, v)]) -> HashMap Text v -> KeyMap v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Text, v) -> (Key, v)) -> [(Text, v)] -> [(Key, v)]
forall a b. (a -> b) -> [a] -> [b]
L.map ((Text -> Key) -> (Text, v) -> (Key, v)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first Text -> Key
Key.fromText) ([(Text, v)] -> [(Key, v)])
-> (HashMap Text v -> [(Text, v)]) -> HashMap Text v -> [(Key, v)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashMap Text v -> [(Text, v)]
forall k v. HashMap k v -> [(k, v)]
H.toList
instance Read v => Read (KeyMap v) where
readPrec :: ReadPrec (KeyMap v)
readPrec = ReadPrec (KeyMap v) -> ReadPrec (KeyMap v)
forall a. ReadPrec a -> ReadPrec a
parens (ReadPrec (KeyMap v) -> ReadPrec (KeyMap v))
-> ReadPrec (KeyMap v) -> ReadPrec (KeyMap v)
forall a b. (a -> b) -> a -> b
$ Int -> ReadPrec (KeyMap v) -> ReadPrec (KeyMap v)
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
10 (ReadPrec (KeyMap v) -> ReadPrec (KeyMap v))
-> ReadPrec (KeyMap v) -> ReadPrec (KeyMap v)
forall a b. (a -> b) -> a -> b
$ do
Ident [Char]
"fromList" <- ReadPrec Lexeme
lexP
[(Key, v)]
xs <- ReadPrec [(Key, v)]
forall a. Read a => ReadPrec a
readPrec
KeyMap v -> ReadPrec (KeyMap v)
forall (m :: * -> *) a. Monad m => a -> m a
return ([(Key, v)] -> KeyMap v
forall v. [(Key, v)] -> KeyMap v
fromList [(Key, v)]
xs)
readListPrec :: ReadPrec [KeyMap v]
readListPrec = ReadPrec [KeyMap v]
forall a. Read a => ReadPrec [a]
readListPrecDefault
instance Show v => Show (KeyMap v) where
showsPrec :: Int -> KeyMap v -> ShowS
showsPrec Int
d KeyMap v
m = Bool -> ShowS -> ShowS
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
[Char] -> ShowS
showString [Char]
"fromList " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Key, v)] -> ShowS
forall a. Show a => a -> ShowS
shows (KeyMap v -> [(Key, v)]
forall v. KeyMap v -> [(Key, v)]
toAscList KeyMap v
m)
instance F.Foldable KeyMap where
foldMap :: (a -> m) -> KeyMap a -> m
foldMap a -> m
f = (Key -> a -> m) -> KeyMap a -> m
forall m a. Monoid m => (Key -> a -> m) -> KeyMap a -> m
foldMapWithKey (\ Key
_k a
v -> a -> m
f a
v)
{-# INLINE foldMap #-}
foldr :: (a -> b -> b) -> b -> KeyMap a -> b
foldr = (a -> b -> b) -> b -> KeyMap a -> b
forall a b. (a -> b -> b) -> b -> KeyMap a -> b
foldr
foldr' :: (a -> b -> b) -> b -> KeyMap a -> b
foldr' = (a -> b -> b) -> b -> KeyMap a -> b
forall a b. (a -> b -> b) -> b -> KeyMap a -> b
foldr'
foldl :: (b -> a -> b) -> b -> KeyMap a -> b
foldl = (b -> a -> b) -> b -> KeyMap a -> b
forall b a. (b -> a -> b) -> b -> KeyMap a -> b
foldl
foldl' :: (b -> a -> b) -> b -> KeyMap a -> b
foldl' = (b -> a -> b) -> b -> KeyMap a -> b
forall b a. (b -> a -> b) -> b -> KeyMap a -> b
foldl'
null :: KeyMap a -> Bool
null = KeyMap a -> Bool
forall a. KeyMap a -> Bool
null
length :: KeyMap a -> Int
length = KeyMap a -> Int
forall a. KeyMap a -> Int
size
instance T.Traversable KeyMap where
traverse :: (a -> f b) -> KeyMap a -> f (KeyMap b)
traverse = (a -> f b) -> KeyMap a -> f (KeyMap b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> KeyMap a -> f (KeyMap b)
traverse
instance Semigroup (KeyMap v) where
<> :: KeyMap v -> KeyMap v -> KeyMap v
(<>) = KeyMap v -> KeyMap v -> KeyMap v
forall v. KeyMap v -> KeyMap v -> KeyMap v
union
instance Monoid (KeyMap v) where
mempty :: KeyMap v
mempty = KeyMap v
forall v. KeyMap v
empty
mappend :: KeyMap v -> KeyMap v -> KeyMap v
mappend = KeyMap v -> KeyMap v -> KeyMap v
forall a. Semigroup a => a -> a -> a
(<>)
instance TH.Lift v => TH.Lift (KeyMap v) where
lift :: KeyMap v -> Q Exp
lift KeyMap v
m = [| fromList m' |] where m' :: [(Key, v)]
m' = KeyMap v -> [(Key, v)]
forall v. KeyMap v -> [(Key, v)]
toList KeyMap v
m
#if MIN_VERSION_template_haskell(2,17,0)
liftTyped = TH.unsafeCodeCoerce . TH.lift
#elif MIN_VERSION_template_haskell(2,16,0)
liftTyped :: KeyMap v -> Q (TExp (KeyMap v))
liftTyped = Q Exp -> Q (TExp (KeyMap v))
forall a. Q Exp -> Q (TExp a)
TH.unsafeTExpCoerce (Q Exp -> Q (TExp (KeyMap v)))
-> (KeyMap v -> Q Exp) -> KeyMap v -> Q (TExp (KeyMap v))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyMap v -> Q Exp
forall t. Lift t => t -> Q Exp
TH.lift
#endif
instance Hashable v => Hashable (KeyMap v) where
#ifdef USE_ORDEREDMAP
hashWithSalt salt (KeyMap m) = M.foldlWithKey'
(\acc k v -> acc `hashWithSalt` k `hashWithSalt` v)
(hashWithSalt salt (M.size m)) m
#else
hashWithSalt :: Int -> KeyMap v -> Int
hashWithSalt Int
salt (KeyMap HashMap Key v
hm) = Int -> HashMap Key v -> Int
forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
salt HashMap Key v
hm
#endif
instance NFData v => NFData (KeyMap v) where
rnf :: KeyMap v -> ()
rnf (KeyMap HashMap Key v
hm) = HashMap Key v -> ()
forall a. NFData a => a -> ()
rnf HashMap Key v
hm
instance WI.FunctorWithIndex Key KeyMap where
imap :: (Key -> a -> b) -> KeyMap a -> KeyMap b
imap = (Key -> a -> b) -> KeyMap a -> KeyMap b
forall a b. (Key -> a -> b) -> KeyMap a -> KeyMap b
mapWithKey
instance WI.FoldableWithIndex Key KeyMap where
ifoldr :: (Key -> a -> b -> b) -> b -> KeyMap a -> b
ifoldr = (Key -> a -> b -> b) -> b -> KeyMap a -> b
forall v a. (Key -> v -> a -> a) -> a -> KeyMap v -> a
foldrWithKey
instance WI.TraversableWithIndex Key KeyMap where
itraverse :: (Key -> a -> f b) -> KeyMap a -> f (KeyMap b)
itraverse = (Key -> a -> f b) -> KeyMap a -> f (KeyMap b)
forall (f :: * -> *) a b.
Applicative f =>
(Key -> a -> f b) -> KeyMap a -> f (KeyMap b)
traverseWithKey
instance SA.Zip KeyMap where
zipWith :: (a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
zipWith = (a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
forall a b c. (a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
intersectionWith
instance SAI.ZipWithIndex Key KeyMap where
izipWith :: (Key -> a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
izipWith = (Key -> a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
forall a b c.
(Key -> a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
intersectionWithKey
instance SA.Semialign KeyMap where
alignWith :: (These a b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
alignWith = (These a b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
forall a b c. (These a b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
alignWith
instance SAI.SemialignWithIndex Key KeyMap where
ialignWith :: (Key -> These a b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
ialignWith = (Key -> These a b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
forall a b c.
(Key -> These a b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
alignWithKey
instance SA.Align KeyMap where
nil :: KeyMap a
nil = KeyMap a
forall v. KeyMap v
empty
instance W.Filterable KeyMap where
filter :: (a -> Bool) -> KeyMap a -> KeyMap a
filter = (a -> Bool) -> KeyMap a -> KeyMap a
forall a. (a -> Bool) -> KeyMap a -> KeyMap a
filter
mapMaybe :: (a -> Maybe b) -> KeyMap a -> KeyMap b
mapMaybe = (a -> Maybe b) -> KeyMap a -> KeyMap b
forall a b. (a -> Maybe b) -> KeyMap a -> KeyMap b
mapMaybe
instance W.Witherable KeyMap where
instance W.FilterableWithIndex Key KeyMap where
ifilter :: (Key -> a -> Bool) -> KeyMap a -> KeyMap a
ifilter = (Key -> a -> Bool) -> KeyMap a -> KeyMap a
forall a. (Key -> a -> Bool) -> KeyMap a -> KeyMap a
filterWithKey
imapMaybe :: (Key -> a -> Maybe b) -> KeyMap a -> KeyMap b
imapMaybe = (Key -> a -> Maybe b) -> KeyMap a -> KeyMap b
forall a b. (Key -> a -> Maybe b) -> KeyMap a -> KeyMap b
mapMaybeWithKey
instance W.WitherableWithIndex Key KeyMap where