module HaskellWorks.Data.Aeson.Compat.Map.V1
  ( KeyMap
  , Key
  , foldlWithKey
  , foldlWithKey'
  , null
  , lookup
  , size
  , member
  , empty
  , singleton
  , insert
  , delete
  , alterF
  , difference
  , union
  , unionWith
  , unionWithKey
  , intersection
  , intersectionWith
  , intersectionWithKey
  , fromList
  , fromListWith
  , toList
  , toAscList
  , elems
  , fromHashMap
  , toHashMap
  , fromHashMapText
  , toHashMapText
  , fromMap
  , toMap
  , fromMapText
  , toMapText
  , map
  , mapWithKey
  , traverseWithKey
  , foldr
  , foldr'
  , foldl
  , foldl'
  , foldMapWithKey
  , foldrWithKey
  , keys
  , filter
  , filterWithKey
  , mapMaybe
  , mapMaybeWithKey
  ) where

import qualified Data.HashMap.Strict as HM
import qualified Data.HashMap.Strict as HMS
import qualified Data.Map as M
import qualified HaskellWorks.Data.Aeson.Compat as J

import Data.Hashable (Hashable)
import Data.HashMap.Strict (HashMap)
import Data.Map (Map)
import Data.Text (Text)
import Prelude hiding (filter, foldl, foldr, lookup, map, null)

type KeyMap v = HM.HashMap Text v
type Key = Text

foldlWithKey :: (a -> Key -> b -> a) -> a -> KeyMap b -> a
foldlWithKey :: forall a b. (a -> Key -> b -> a) -> a -> KeyMap b -> a
foldlWithKey = forall a k v. (a -> k -> v -> a) -> a -> HashMap k v -> a
HM.foldlWithKey

foldlWithKey' :: (a -> Key -> b -> a) -> a -> KeyMap b -> a
foldlWithKey' :: forall a b. (a -> Key -> b -> a) -> a -> KeyMap b -> a
foldlWithKey' = forall a k v. (a -> k -> v -> a) -> a -> HashMap k v -> a
HM.foldlWithKey'

null :: KeyMap v -> Bool
null :: forall v. KeyMap v -> Bool
null = forall k v. HashMap k v -> Bool
HM.null

lookup :: Key -> KeyMap v -> Maybe v
lookup :: forall v. Key -> KeyMap v -> Maybe v
lookup = forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HM.lookup

size :: KeyMap v -> Int
size :: forall v. KeyMap v -> Int
size = forall k v. HashMap k v -> Int
HM.size

member :: Key -> KeyMap v -> Bool
member :: forall v. Key -> KeyMap v -> Bool
member = forall k a. (Eq k, Hashable k) => k -> HashMap k a -> Bool
HM.member

empty :: KeyMap v
empty :: forall v. KeyMap v
empty = forall k v. HashMap k v
HM.empty

singleton :: Key -> v -> KeyMap v
singleton :: forall v. Key -> v -> KeyMap v
singleton = forall k v. Hashable k => k -> v -> HashMap k v
HM.singleton

insert :: Key -> v -> KeyMap v -> KeyMap v
insert :: forall v. Key -> v -> KeyMap v -> KeyMap v
insert = forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
HM.insert

delete :: Key -> KeyMap v -> KeyMap v
delete :: forall v. Key -> KeyMap v -> KeyMap v
delete = forall k v. (Eq k, Hashable k) => k -> HashMap k v -> HashMap k v
HM.delete

alterF :: Functor f => (Maybe v -> f (Maybe v)) -> Key -> KeyMap v -> f (KeyMap v)
alterF :: forall (f :: * -> *) v.
Functor f =>
(Maybe v -> f (Maybe v)) -> Key -> KeyMap v -> f (KeyMap v)
alterF = forall (f :: * -> *) k v.
(Functor f, Eq k, Hashable k) =>
(Maybe v -> f (Maybe v)) -> k -> HashMap k v -> f (HashMap k v)
HM.alterF

difference :: KeyMap v -> KeyMap v' -> KeyMap v
difference :: forall v v'. KeyMap v -> KeyMap v' -> KeyMap v
difference = forall k v w.
(Eq k, Hashable k) =>
HashMap k v -> HashMap k w -> HashMap k v
HM.difference

union :: KeyMap v -> KeyMap v -> KeyMap v
union :: forall v. KeyMap v -> KeyMap v -> KeyMap v
union = forall k v.
(Eq k, Hashable k) =>
HashMap k v -> HashMap k v -> HashMap k v
HM.union

unionWith :: (v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v
unionWith :: forall v. (v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v
unionWith = forall k v.
(Eq k, Hashable k) =>
(v -> v -> v) -> HashMap k v -> HashMap k v -> HashMap k v
HM.unionWith

unionWithKey :: (Key -> v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v
unionWithKey :: forall v. (Key -> v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v
unionWithKey = forall k v.
(Eq k, Hashable k) =>
(k -> v -> v -> v) -> HashMap k v -> HashMap k v -> HashMap k v
HM.unionWithKey

intersection :: KeyMap a -> KeyMap b -> KeyMap a
intersection :: forall v v'. KeyMap v -> KeyMap v' -> KeyMap v
intersection = forall k v w.
(Eq k, Hashable k) =>
HashMap k v -> HashMap k w -> HashMap k v
HM.intersection

intersectionWith :: (a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
intersectionWith :: forall a b c. (a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
intersectionWith = forall k v1 v2 v3.
(Eq k, Hashable k) =>
(v1 -> v2 -> v3) -> HashMap k v1 -> HashMap k v2 -> HashMap k v3
HM.intersectionWith

intersectionWithKey :: (Key -> a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
intersectionWithKey :: forall a b c.
(Key -> a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
intersectionWithKey = forall k v1 v2 v3.
(Eq k, Hashable k) =>
(k -> v1 -> v2 -> v3)
-> HashMap k v1 -> HashMap k v2 -> HashMap k v3
HM.intersectionWithKey

fromList :: [(Key, v)] -> KeyMap v
fromList :: forall v. [(Key, v)] -> KeyMap v
fromList = forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList

fromListWith :: (v -> v -> v) -> [(Key, v)] -> KeyMap v
fromListWith :: forall v. (v -> v -> v) -> [(Key, v)] -> KeyMap v
fromListWith = forall k v.
(Eq k, Hashable k) =>
(v -> v -> v) -> [(k, v)] -> HashMap k v
HM.fromListWith

toList :: KeyMap v -> [(Key, v)]
toList :: forall v. KeyMap v -> [(Key, v)]
toList = forall k v. HashMap k v -> [(k, v)]
HM.toList

toAscList :: KeyMap v -> [(Key, v)]
toAscList :: forall v. KeyMap v -> [(Key, v)]
toAscList = forall k a. Map k a -> [(k, a)]
M.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall v. KeyMap v -> Map Key v
toMap

elems :: KeyMap v -> [v]
elems :: forall v. KeyMap v -> [v]
elems = forall k v. HashMap k v -> [v]
HM.elems

fromHashMap :: HashMap Key v -> KeyMap v
fromHashMap :: forall v. HashMap Key v -> HashMap Key v
fromHashMap = forall a. a -> a
id

toHashMap :: KeyMap v -> HashMap Key v
toHashMap :: forall v. HashMap Key v -> HashMap Key v
toHashMap = forall a. a -> a
id

fromHashMapText :: HashMap Text v -> KeyMap v
fromHashMapText :: forall v. HashMap Key v -> HashMap Key v
fromHashMapText = forall a. a -> a
id

toHashMapText :: KeyMap v -> HashMap Text v
toHashMapText :: forall v. HashMap Key v -> HashMap Key v
toHashMapText = forall a. a -> a
id

fromMap :: Map Key v -> KeyMap v
fromMap :: forall v. Map Key v -> KeyMap v
fromMap = forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k a. Map k a -> [(k, a)]
M.toList

toMap :: KeyMap v -> Map Key v
toMap :: forall v. KeyMap v -> Map Key v
toMap = forall k a. Ord k => [(k, a)] -> Map k a
M.fromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k v. HashMap k v -> [(k, v)]
HM.toList

fromMapText :: Map Text v -> KeyMap v
fromMapText :: forall v. Map Key v -> KeyMap v
fromMapText = forall v. Map Key v -> KeyMap v
fromMap

toMapText :: KeyMap v -> Map Text v
toMapText :: forall v. KeyMap v -> Map Key v
toMapText = forall v. KeyMap v -> Map Key v
toMap

map :: (a -> b) -> KeyMap a -> KeyMap b
map :: forall a b. (a -> b) -> KeyMap a -> KeyMap b
map = forall v1 v2 k. (v1 -> v2) -> HashMap k v1 -> HashMap k v2
HM.map

mapWithKey :: (Key -> a -> b) -> KeyMap a -> KeyMap b
mapWithKey :: forall a b. (Key -> a -> b) -> KeyMap a -> KeyMap b
mapWithKey = forall k v1 v2. (k -> v1 -> v2) -> HashMap k v1 -> HashMap k v2
HM.mapWithKey

traverseWithKey :: Applicative f => (Key -> v1 -> f v2) -> KeyMap v1 -> f (KeyMap v2)
traverseWithKey :: forall (f :: * -> *) v1 v2.
Applicative f =>
(Key -> v1 -> f v2) -> KeyMap v1 -> f (KeyMap v2)
traverseWithKey = forall (f :: * -> *) k v1 v2.
Applicative f =>
(k -> v1 -> f v2) -> HashMap k v1 -> f (HashMap k v2)
HM.traverseWithKey

foldr :: (a -> b -> b) -> b -> KeyMap a -> b
foldr :: forall a b. (a -> b -> b) -> b -> KeyMap a -> b
foldr = forall v a k. (v -> a -> a) -> a -> HashMap k v -> a
HM.foldr

foldr' :: (a -> b -> b) -> b -> KeyMap a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> KeyMap a -> b
foldr' = forall v a k. (v -> a -> a) -> a -> HashMap k v -> a
HM.foldr'

foldl :: (b -> a -> b) -> b -> KeyMap a -> b
foldl :: forall b a. (b -> a -> b) -> b -> KeyMap a -> b
foldl = forall a v k. (a -> v -> a) -> a -> HashMap k v -> a
HM.foldl

foldl' :: (b -> a -> b) -> b -> KeyMap a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> KeyMap a -> b
foldl' = forall a v k. (a -> v -> a) -> a -> HashMap k v -> a
HM.foldl'

foldMapWithKey :: Monoid m => (Key -> a -> m) -> KeyMap a -> m
foldMapWithKey :: forall m a. Monoid m => (Key -> a -> m) -> KeyMap a -> m
foldMapWithKey = forall m k v. Monoid m => (k -> v -> m) -> HashMap k v -> m
HM.foldMapWithKey

foldrWithKey :: (Key -> v -> a -> a) -> a -> KeyMap v -> a
foldrWithKey :: forall v a. (Key -> v -> a -> a) -> a -> KeyMap v -> a
foldrWithKey = forall k v a. (k -> v -> a -> a) -> a -> HashMap k v -> a
HM.foldrWithKey

keys :: KeyMap v -> [Key]
keys :: forall v. KeyMap v -> [Key]
keys = forall k v. HashMap k v -> [k]
HM.keys

filter :: (v -> Bool) -> KeyMap v -> KeyMap v
filter :: forall v. (v -> Bool) -> KeyMap v -> KeyMap v
filter = forall v k. (v -> Bool) -> HashMap k v -> HashMap k v
HM.filter

filterWithKey :: (Key -> v -> Bool) -> KeyMap v -> KeyMap v
filterWithKey :: forall v. (Key -> v -> Bool) -> KeyMap v -> KeyMap v
filterWithKey = forall k v. (k -> v -> Bool) -> HashMap k v -> HashMap k v
HM.filterWithKey

mapMaybe :: (a -> Maybe b) -> KeyMap a -> KeyMap b
mapMaybe :: forall a b. (a -> Maybe b) -> KeyMap a -> KeyMap b
mapMaybe = forall v1 v2 k. (v1 -> Maybe v2) -> HashMap k v1 -> HashMap k v2
HM.mapMaybe

mapMaybeWithKey :: (Key -> v -> Maybe u) -> KeyMap v -> KeyMap u
mapMaybeWithKey :: forall v u. (Key -> v -> Maybe u) -> KeyMap v -> KeyMap u
mapMaybeWithKey = forall k v1 v2.
(k -> v1 -> Maybe v2) -> HashMap k v1 -> HashMap k v2
HM.mapMaybeWithKey