hw-aeson 0.1.6.0 → 0.1.7.0

raw patch · 6 files changed

+436/−44 lines, 6 filesdep +bytestringdep +hashablePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: bytestring, hashable

API changes (from Hackage documentation)

Files

• hw-aeson.cabal +8/−2
• src/HaskellWorks/Data/Aeson.hs +8/−1
• src/HaskellWorks/Data/Aeson/Compat/Map.hs +2/−41
• src/HaskellWorks/Data/Aeson/Compat/Map/V1.hs +198/−0
• src/HaskellWorks/Data/Aeson/Compat/Map/V2.hs +206/−0
• test/HaskellWorks/Data/AesonSpec.hs +14/−0

@@ -1,7 +1,7 @@ cabal-version: 2.2  name:                   hw-aeson-version:                0.1.6.0+version:                0.1.7.0 synopsis:               Convenience functions for Aeson description:            Convenience functions for Aeson. category:               Data, JSON@@ -23,9 +23,11 @@ common base                       { build-depends: base                       >= 4.11       && < 5      }  common aeson                      { build-depends: aeson                      >= 1.4        && < 2.1    }-common containers                 { build-depends: containers                 >= 0.6        && < 0.7   }+common bytestring                 { build-depends: bytestring                 >= 0.10       && < 0.12   }+common containers                 { build-depends: containers                 >= 0.6        && < 0.7    } common doctest                    { build-depends: doctest                    >= 0.16.2     && < 0.21   } common doctest-discover           { build-depends: doctest-discover           >= 0.2        && < 0.3    }+common hashable                   { build-depends: hashable                   >= 1.3        && < 1.5    } common hedgehog                   { build-depends: hedgehog                   >= 0.6        && < 1.3    } common hspec                      { build-depends: hspec                      >= 2.4        && < 3      } common text                       { build-depends: text                       >= 1.2        && < 1.3    }@@ -40,7 +42,9 @@ library   import:               base, config                       , aeson+                      , bytestring                       , containers+                      , hashable                       , text                       , text-short                       , unordered-containers@@ -51,6 +55,8 @@   exposed-modules:      HaskellWorks.Data.Aeson                         HaskellWorks.Data.Aeson.Compat                         HaskellWorks.Data.Aeson.Compat.Map+                        HaskellWorks.Data.Aeson.Compat.Map.V1+                        HaskellWorks.Data.Aeson.Compat.Map.V2  test-suite hw-aeson-test   import:               base, config

@@ -13,11 +13,15 @@  import Data.Aeson (pairs, object, KeyValue((.=)), ToJSON(toJSON, toEncoding), Series, Value(Null)) import Data.Aeson.Encoding (Encoding)-import Data.Aeson.Types (Pair, Parser)+import Data.Aeson.Types (Pair, Parser, parseEither) import Data.Monoid (Endo(..)) import HaskellWorks.Data.Aeson.Compat (Key) import Text.Read (readMaybe) +import qualified Data.Aeson           as J+import qualified Data.Aeson.Types     as J+import qualified Data.ByteString.Lazy as LBS+ infixr 7 .?= infixr 7 .!= @@ -96,3 +100,6 @@ instance ToJsonKeyValues a => ToJSON (WithJsonKeyValues a) where   toJSON = objectEndo . toJsonKeyValues . unWithJsonKeyValues   toEncoding = pairs . mconcat . toJsonKeyValues . unWithJsonKeyValues++eitherDecodeWith :: (Value -> Parser a) -> LBS.ByteString -> Either String a+eitherDecodeWith f lbs = J.eitherDecode lbs >>= J.parseEither f

@@ -2,49 +2,10 @@  module HaskellWorks.Data.Aeson.Compat.Map   ( module JM-  , KeyMap(..)-  , foldlWithKey'-  , fromHashMapText-  , toHashMapText   ) where -import qualified Data.Map as M-import qualified HaskellWorks.Data.Aeson.Compat as J--import Data.HashMap.Strict (HashMap)-import Data.Text (Text)- #if MIN_VERSION_aeson(2,0,0)-import qualified Data.Aeson.KeyMap as JM-import Data.Aeson.KeyMap (KeyMap)-#else-import qualified Data.HashMap.Strict as JM-import Data.HashMap.Strict hiding (foldlWithKey')-#endif--#if !MIN_VERSION_aeson(2,0,0)-type KeyMap v = JM.HashMap Text v-#endif--foldlWithKey' :: (a -> J.Key -> b -> a) -> a -> KeyMap b -> a-#if MIN_VERSION_aeson(2,0,0)-foldlWithKey' f a = M.foldlWithKey' f a . JM.toMap-#else-foldlWithKey'= JM.foldlWithKey'-#endif--#if MIN_VERSION_aeson(2,0,0)-fromHashMapText :: HashMap Text a ->  KeyMap a-fromHashMapText = JM.fromHashMapText-#else-fromHashMapText :: HashMap Text a -> HashMap Text a-fromHashMapText = id-#endif--#if MIN_VERSION_aeson(2,0,0)-toHashMapText :: KeyMap a -> HashMap Text a-toHashMapText = JM.toHashMapText+import HaskellWorks.Data.Aeson.Compat.Map.V2 as JM #else-toHashMapText :: HashMap Text a -> HashMap Text a-toHashMapText = id+import HaskellWorks.Data.Aeson.Compat.Map.V1 as JM #endif

@@ -0,0 +1,198 @@+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 = HM.foldlWithKey++foldlWithKey' :: (a -> Key -> b -> a) -> a -> KeyMap b -> a+foldlWithKey' = HM.foldlWithKey'++null :: KeyMap v -> Bool+null = HM.null++lookup :: Key -> KeyMap v -> Maybe v+lookup = HM.lookup++size :: KeyMap v -> Int+size = HM.size++member :: Key -> KeyMap v -> Bool+member = HM.member++empty :: KeyMap v+empty = HM.empty++singleton :: Key -> v -> KeyMap v+singleton = HM.singleton++insert :: Key -> v -> KeyMap v -> KeyMap v+insert = HM.insert++delete :: Key -> KeyMap v -> KeyMap v+delete = HM.delete++alterF :: Functor f => (Maybe v -> f (Maybe v)) -> Key -> KeyMap v -> f (KeyMap v)+alterF = HM.alterF++difference :: KeyMap v -> KeyMap v' -> KeyMap v+difference = HM.difference++union :: KeyMap v -> KeyMap v -> KeyMap v+union = HM.union++unionWith :: (v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v+unionWith = HM.unionWith++unionWithKey :: (Key -> v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v+unionWithKey = HM.unionWithKey++intersection :: KeyMap a -> KeyMap b -> KeyMap a+intersection = HM.intersection++intersectionWith :: (a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c+intersectionWith = HM.intersectionWith++intersectionWithKey :: (Key -> a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c+intersectionWithKey = HM.intersectionWithKey++fromList :: [(Key, v)] -> KeyMap v+fromList = HM.fromList++fromListWith :: (v -> v -> v) -> [(Key, v)] -> KeyMap v+fromListWith = HM.fromListWith++toList :: KeyMap v -> [(Key, v)]+toList = HM.toList++toAscList :: KeyMap v -> [(Key, v)]+toAscList = M.toList . toMap++elems :: KeyMap v -> [v]+elems = HM.elems++fromHashMap :: HashMap Key v -> KeyMap v+fromHashMap = id++toHashMap :: KeyMap v -> HashMap Key v+toHashMap = id++fromHashMapText :: HashMap Text v -> KeyMap v+fromHashMapText = id++toHashMapText :: KeyMap v -> HashMap Text v+toHashMapText = id++fromMap :: Map Key v -> KeyMap v+fromMap = HM.fromList . M.toList++toMap :: KeyMap v -> Map Key v+toMap = M.fromList . HM.toList++fromMapText :: Map Text v -> KeyMap v+fromMapText = fromMap++toMapText :: KeyMap v -> Map Text v+toMapText = toMap++map :: (a -> b) -> KeyMap a -> KeyMap b+map = HM.map++mapWithKey :: (Key -> a -> b) -> KeyMap a -> KeyMap b+mapWithKey = HM.mapWithKey++traverseWithKey :: Applicative f => (Key -> v1 -> f v2) -> KeyMap v1 -> f (KeyMap v2)+traverseWithKey = HM.traverseWithKey++foldr :: (a -> b -> b) -> b -> KeyMap a -> b+foldr = HM.foldr++foldr' :: (a -> b -> b) -> b -> KeyMap a -> b+foldr' = HM.foldr'++foldl :: (b -> a -> b) -> b -> KeyMap a -> b+foldl = HM.foldl++foldl' :: (b -> a -> b) -> b -> KeyMap a -> b+foldl' = HM.foldl'++foldMapWithKey :: Monoid m => (Key -> a -> m) -> KeyMap a -> m+foldMapWithKey = HM.foldMapWithKey++foldrWithKey :: (Key -> v -> a -> a) -> a -> KeyMap v -> a+foldrWithKey = HM.foldrWithKey++keys :: KeyMap v -> [Key]+keys = HM.keys++filter :: (v -> Bool) -> KeyMap v -> KeyMap v+filter = HM.filter++filterWithKey :: (Key -> v -> Bool) -> KeyMap v -> KeyMap v+filterWithKey = HM.filterWithKey++mapMaybe :: (a -> Maybe b) -> KeyMap a -> KeyMap b+mapMaybe = HM.mapMaybe++mapMaybeWithKey :: (Key -> v -> Maybe u) -> KeyMap v -> KeyMap u+mapMaybeWithKey = HM.mapMaybeWithKey

@@ -0,0 +1,206 @@+{-# 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 f a = M.foldlWithKey f a . KM.toMap++foldlWithKey' :: (a -> Key -> b -> a) -> a -> KeyMap b -> a+foldlWithKey' f a = M.foldlWithKey' f a . KM.toMap++null :: KeyMap v -> Bool+null = KM.null++lookup :: Key -> KeyMap v -> Maybe v+lookup = KM.lookup++size :: KeyMap v -> Int+size = KM.size++member :: Key -> KeyMap v -> Bool+member = KM.member++empty :: KeyMap v+empty = KM.empty++singleton :: Key -> v -> KeyMap v+singleton = KM.singleton++insert :: Key -> v -> KeyMap v -> KeyMap v+insert = KM.insert++delete :: Key -> KeyMap v -> KeyMap v+delete = KM.delete++alterF :: Functor f => (Maybe v -> f (Maybe v)) -> Key -> KeyMap v -> f (KeyMap v)+alterF = KM.alterF++difference :: KeyMap v -> KeyMap v' -> KeyMap v+difference = KM.difference++union :: KeyMap v -> KeyMap v -> KeyMap v+union = KM.union++unionWith :: (v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v+unionWith = KM.unionWith++unionWithKey :: (Key -> v -> v -> v) -> KeyMap v -> KeyMap v -> KeyMap v+unionWithKey = KM.unionWithKey++intersection :: KeyMap a -> KeyMap b -> KeyMap a+intersection = KM.intersection++intersectionWith :: (a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c+intersectionWith = KM.intersectionWith++intersectionWithKey :: (Key -> a -> b -> c) -> KeyMap a -> KeyMap b -> KeyMap c+intersectionWithKey = KM.intersectionWithKey++fromList :: [(Key, v)] -> KeyMap v+fromList = KM.fromList++fromListWith :: (v -> v -> v) -> [(Key, v)] -> KeyMap v+fromListWith = KM.fromListWith++toList :: KeyMap v -> [(Key, v)]+toList = KM.toList++toAscList :: KeyMap v -> [(Key, v)]+toAscList = M.toList . toMap++elems :: KeyMap v -> [v]+elems = KM.elems++fromHashMap :: HashMap Key v -> KeyMap v+fromHashMap = KM.fromHashMap++toHashMap :: KeyMap v -> HashMap Key v+toHashMap = KM.toHashMap++fromHashMapText :: HashMap Text v -> KeyMap v+fromHashMapText = KM.fromHashMapText++toHashMapText :: KeyMap v -> HashMap Text v+toHashMapText = KM.toHashMapText++fromMap :: Map Key v -> KeyMap v+fromMap = KM.fromList . M.toList++toMap :: KeyMap v -> Map Key v+toMap = M.fromList . KM.toList++fromMapText :: Map Text v -> KeyMap v+fromMapText = KM.fromMap . M.mapKeys K.fromText++toMapText :: KeyMap v -> Map Text v+toMapText = M.mapKeys K.toText . KM.toMap++map :: (a -> b) -> KeyMap a -> KeyMap b+map = KM.map++mapWithKey :: (Key -> a -> b) -> KeyMap a -> KeyMap b+mapWithKey f = KM.fromMap . M.mapWithKey f . KM.toMap++traverseWithKey :: Applicative f => (Key -> v1 -> f v2) -> KeyMap v1 -> f (KeyMap v2)+traverseWithKey = KM.traverseWithKey++foldr :: (a -> b -> b) -> b -> KeyMap a -> b+foldr = KM.foldr++foldr' :: (a -> b -> b) -> b -> KeyMap a -> b+foldr' = KM.foldr'++foldl :: (b -> a -> b) -> b -> KeyMap a -> b+foldl = KM.foldl++foldl' :: (b -> a -> b) -> b -> KeyMap a -> b+foldl' = KM.foldl'++foldMapWithKey :: Monoid m => (Key -> a -> m) -> KeyMap a -> m+foldMapWithKey = KM.foldMapWithKey++foldrWithKey :: (Key -> v -> a -> a) -> a -> KeyMap v -> a+foldrWithKey = KM.foldrWithKey++keys :: KeyMap v -> [Key]+keys = KM.keys++filter :: (v -> Bool) -> KeyMap v -> KeyMap v+filter = KM.filter++filterWithKey :: (Key -> v -> Bool) -> KeyMap v -> KeyMap v+filterWithKey = KM.filterWithKey++mapMaybe :: (a -> Maybe b) -> KeyMap a -> KeyMap b+mapMaybe = KM.mapMaybe++mapMaybeWithKey :: (Key -> v -> Maybe u) -> KeyMap v -> KeyMap u+mapMaybeWithKey = KM.mapMaybeWithKey++#endif

@@ -1,4 +1,5 @@ {-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE TypeApplications #-}  module HaskellWorks.Data.AesonSpec   ( spec@@ -8,6 +9,8 @@ import HaskellWorks.Data.Aeson import Test.Hspec +import qualified HaskellWorks.Data.Aeson.Compat.Map as JM+ {- HLINT ignore "Redundant do"        -}  spec :: Spec@@ -23,3 +26,14 @@           , "two"    .= (2 :: Int)           ]     actual `shouldBe` expected+  it "Re-exports complete" $ do+    let _ = JM.toList+    let _ = JM.toMap+    let _ = JM.foldlWithKey+    let _ = JM.fromHashMapText+    let _ = JM.lookup @Int+    let _ = JM.toHashMapText+    let _ = JM.toList+    let _ = JM.toMap++    True