{-# LANGUAGE CPP #-}

module HaskellWorks.Data.Aeson.Compat.Map.V2
  (
#if MIN_VERSION_aeson(2,0,0)
    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
#endif
  ) where

#if MIN_VERSION_aeson(2,0,0)

import qualified Data.Aeson.Key as K
import qualified Data.Aeson.KeyMap as KM
import qualified Data.Map as M
import qualified HaskellWorks.Data.Aeson.Compat as J

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 = KM.KeyMap v
type Key = J.Key

foldlWithKey :: (a -> Key -> b -> a) -> a -> KeyMap b -> a
foldlWithKey :: (a -> Key -> b -> a) -> a -> KeyMap b -> a
foldlWithKey a -> Key -> b -> a
f a
a = (a -> Key -> b -> a) -> a -> Map Key b -> a
forall a k b. (a -> k -> b -> a) -> a -> Map k b -> a
M.foldlWithKey a -> Key -> b -> a
f a
a (Map Key b -> a) -> (KeyMap b -> Map Key b) -> KeyMap b -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyMap b -> Map Key b
forall v. KeyMap v -> Map Key v
KM.toMap

foldlWithKey' :: (a -> Key -> b -> a) -> a -> KeyMap b -> a
foldlWithKey' :: (a -> Key -> b -> a) -> a -> KeyMap b -> a
foldlWithKey' a -> Key -> b -> a
f a
a = (a -> Key -> b -> a) -> a -> Map Key b -> a
forall a k b. (a -> k -> b -> a) -> a -> Map k b -> a
M.foldlWithKey' a -> Key -> b -> a
f a
a (Map Key b -> a) -> (KeyMap b -> Map Key b) -> KeyMap b -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyMap b -> Map Key b
forall v. KeyMap v -> Map Key v
KM.toMap

null :: KeyMap v -> Bool
null :: KeyMap v -> Bool
null = KeyMap v -> Bool
forall v. KeyMap v -> Bool
KM.null

lookup :: Key -> KeyMap v -> Maybe v
lookup :: Key -> KeyMap v -> Maybe v
lookup = Key -> KeyMap v -> Maybe v
forall v. Key -> KeyMap v -> Maybe v
KM.lookup

size :: KeyMap v -> Int
size :: KeyMap v -> Int
size = KeyMap v -> Int
forall v. KeyMap v -> Int
KM.size

member :: Key -> KeyMap v -> Bool
member :: Key -> KeyMap v -> Bool
member = Key -> KeyMap v -> Bool
forall a. Key -> KeyMap a -> Bool
KM.member

empty :: KeyMap v
empty :: KeyMap v
empty = KeyMap v
forall v. KeyMap v
KM.empty

singleton :: Key -> v -> KeyMap v
singleton :: Key -> v -> KeyMap v
singleton = Key -> v -> KeyMap v
forall v. Key -> v -> KeyMap v
KM.singleton

insert :: Key -> v -> KeyMap v -> KeyMap v
insert :: Key -> v -> KeyMap v -> KeyMap v
insert = Key -> v -> KeyMap v -> KeyMap v
forall v. Key -> v -> KeyMap v -> KeyMap v
KM.insert

delete :: Key -> KeyMap v -> KeyMap v
delete :: Key -> KeyMap v -> KeyMap v
delete = Key -> KeyMap v -> KeyMap v
forall v. Key -> KeyMap v -> KeyMap v
KM.delete

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)) -> Key -> KeyMap v -> f (KeyMap v)
forall (f :: * -> *) v.
Functor f =>
(Maybe v -> f (Maybe v)) -> Key -> KeyMap v -> f (KeyMap v)
KM.alterF

difference :: KeyMap v -> KeyMap v' -> KeyMap v
difference :: KeyMap v -> KeyMap v' -> KeyMap v
difference = KeyMap v -> KeyMap v' -> KeyMap v
forall v v'. KeyMap v -> KeyMap v' -> KeyMap v
KM.difference

union :: KeyMap v -> KeyMap v -> KeyMap v
union :: KeyMap v -> KeyMap v -> KeyMap v
union = KeyMap v -> KeyMap v -> KeyMap v
forall v. KeyMap v -> KeyMap v -> KeyMap v
KM.union

unionWith :: (v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v
unionWith :: (v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v
unionWith = (v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v
forall v. (v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v
KM.unionWith

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) -> KeyMap v -> KeyMap v -> KeyMap v
forall v. (Key -> v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v
KM.unionWithKey

intersection :: KeyMap a -> KeyMap b -> KeyMap a
intersection :: KeyMap a -> KeyMap b -> KeyMap a
intersection = KeyMap a -> KeyMap b -> KeyMap a
forall v v'. KeyMap v -> KeyMap v' -> KeyMap v
KM.intersection

intersectionWith :: (a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
intersectionWith :: (a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
intersectionWith = (a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
forall a b c. (a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
KM.intersectionWith

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) -> KeyMap a -> KeyMap b -> KeyMap c
forall a b c.
(Key -> a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c
KM.intersectionWithKey

fromList :: [(Key, v)] -> KeyMap v
fromList :: [(Key, v)] -> KeyMap v
fromList = [(Key, v)] -> KeyMap v
forall v. [(Key, v)] -> KeyMap v
KM.fromList

fromListWith :: (v -> v -> v) -> [(Key, v)] -> KeyMap v
fromListWith :: (v -> v -> v) -> [(Key, v)] -> KeyMap v
fromListWith = (v -> v -> v) -> [(Key, v)] -> KeyMap v
forall v. (v -> v -> v) -> [(Key, v)] -> KeyMap v
KM.fromListWith

toList :: KeyMap v -> [(Key, v)]
toList :: KeyMap v -> [(Key, v)]
toList = KeyMap v -> [(Key, v)]
forall v. KeyMap v -> [(Key, v)]
KM.toList

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

elems :: KeyMap v -> [v]
#if MIN_VERSION_aeson(2,0,3)
elems :: KeyMap v -> [v]
elems = KeyMap v -> [v]
forall v. KeyMap v -> [v]
KM.elems
#else
elems = M.elems . KM.toMap
#endif

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
KM.fromHashMap

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
KM.toHashMap

fromHashMapText :: HashMap Text v -> KeyMap v
fromHashMapText :: HashMap Text v -> KeyMap v
fromHashMapText = HashMap Text v -> KeyMap v
forall v. HashMap Text v -> KeyMap v
KM.fromHashMapText

toHashMapText :: KeyMap v -> HashMap Text v
toHashMapText :: KeyMap v -> HashMap Text v
toHashMapText = KeyMap v -> HashMap Text v
forall v. KeyMap v -> HashMap Text v
KM.toHashMapText

fromMap :: Map Key v -> KeyMap v
fromMap :: Map Key v -> KeyMap v
fromMap = [(Key, v)] -> KeyMap v
forall v. [(Key, v)] -> KeyMap v
KM.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

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)]
KM.toList

fromMapText :: Map Text v -> KeyMap v
fromMapText :: Map Text v -> KeyMap v
fromMapText = Map Key v -> KeyMap v
forall v. Map Key v -> KeyMap v
KM.fromMap (Map Key v -> KeyMap v)
-> (Map Text v -> Map Key v) -> Map Text v -> KeyMap v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Key) -> Map Text v -> Map Key v
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
M.mapKeys Text -> Key
K.fromText

toMapText :: KeyMap v -> Map Text v
toMapText :: KeyMap v -> Map Text v
toMapText = (Key -> Text) -> Map Key v -> Map Text v
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
M.mapKeys Key -> Text
K.toText (Map Key v -> Map Text v)
-> (KeyMap v -> Map Key v) -> KeyMap v -> Map Text v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyMap v -> Map Key v
forall v. KeyMap v -> Map Key v
KM.toMap

map :: (a -> b) -> KeyMap a -> KeyMap b
map :: (a -> b) -> KeyMap a -> KeyMap b
map = (a -> b) -> KeyMap a -> KeyMap b
forall a b. (a -> b) -> KeyMap a -> KeyMap b
KM.map

mapWithKey :: (Key -> a -> b) -> KeyMap a -> KeyMap b
#if MIN_VERSION_aeson(2,1,0)
mapWithKey :: (Key -> a -> b) -> KeyMap a -> KeyMap b
mapWithKey = (Key -> a -> b) -> KeyMap a -> KeyMap b
forall a b. (Key -> a -> b) -> KeyMap a -> KeyMap b
KM.mapWithKey
#else
mapWithKey f = KM.fromMap . M.mapWithKey f . KM.toMap
#endif

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) -> KeyMap v1 -> f (KeyMap v2)
forall (f :: * -> *) v1 v2.
Applicative f =>
(Key -> v1 -> f v2) -> KeyMap v1 -> f (KeyMap v2)
KM.traverseWithKey

foldr :: (a -> b -> b) -> b -> KeyMap a -> b
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
KM.foldr

foldr' :: (a -> b -> b) -> b -> KeyMap a -> b
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
KM.foldr'

foldl :: (b -> a -> b) -> b -> KeyMap a -> b
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
KM.foldl

foldl' :: (b -> a -> b) -> b -> KeyMap a -> b
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
KM.foldl'

foldMapWithKey :: Monoid m => (Key -> a -> m) -> KeyMap a -> m
foldMapWithKey :: (Key -> a -> m) -> KeyMap a -> m
foldMapWithKey = (Key -> a -> m) -> KeyMap a -> m
forall m a. Monoid m => (Key -> a -> m) -> KeyMap a -> m
KM.foldMapWithKey

foldrWithKey :: (Key -> v -> a -> a) -> a -> KeyMap v -> a
foldrWithKey :: (Key -> v -> a -> a) -> a -> KeyMap v -> a
foldrWithKey = (Key -> v -> a -> a) -> a -> KeyMap v -> a
forall v a. (Key -> v -> a -> a) -> a -> KeyMap v -> a
KM.foldrWithKey

keys :: KeyMap v -> [Key]
keys :: KeyMap v -> [Key]
keys = KeyMap v -> [Key]
forall v. KeyMap v -> [Key]
KM.keys

filter :: (v -> Bool) -> KeyMap v -> KeyMap v
filter :: (v -> Bool) -> KeyMap v -> KeyMap v
filter = (v -> Bool) -> KeyMap v -> KeyMap v
forall v. (v -> Bool) -> KeyMap v -> KeyMap v
KM.filter

filterWithKey :: (Key -> v -> Bool) -> KeyMap v -> KeyMap v
filterWithKey :: (Key -> v -> Bool) -> KeyMap v -> KeyMap v
filterWithKey = (Key -> v -> Bool) -> KeyMap v -> KeyMap v
forall v. (Key -> v -> Bool) -> KeyMap v -> KeyMap v
KM.filterWithKey

mapMaybe :: (a -> Maybe b) -> KeyMap a -> KeyMap b
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
KM.mapMaybe

mapMaybeWithKey :: (Key -> v -> Maybe u) -> KeyMap v -> KeyMap u
mapMaybeWithKey :: (Key -> v -> Maybe u) -> KeyMap v -> KeyMap u
mapMaybeWithKey = (Key -> v -> Maybe u) -> KeyMap v -> KeyMap u
forall v u. (Key -> v -> Maybe u) -> KeyMap v -> KeyMap u
KM.mapMaybeWithKey

#endif