aeson-optics 1.1.1 → 1.2

raw patch · 3 files changed

+177/−172 lines, 3 filesdep +text-shortdep −base-compatdep ~aesondep ~basedep ~optics-corePVP ok

version bump matches the API change (PVP)

Dependencies added: text-short

Dependencies removed: base-compat

Dependency ranges changed: aeson, base, optics-core, optics-extra

API changes (from Hackage documentation)

Files

• CHANGELOG.md +38/−0
• aeson-optics.cabal +15/−9
• src/Data/Aeson/Optics.hs +124/−163

@@ -1,3 +1,41 @@+# 1.2++Release corresponding to [`lens-aeson-1.2`](https://hackage.haskell.org/package/lens-aeson-1.2)+API changes.++* Require `aeson-2.0.3.*` and `optics-core-0.4.1` or greater.+* Drop support for GHC-8.0+* Change the types of `_Object`, `key`, and `members`:++  ```diff+  -_Object :: Prism' t (HashMap Text Value)+  +_Object :: Prism' t (KeyMap Value)++  -key :: AsValue t => Text -> AffineTraversal' t Value+  +key :: AsValue t => Key  -> AffineTraversal' t Value++  -members :: AsValue t => IndexedTraversal' Text t Value+  +members :: AsValue t => IndexedTraversal' Key  t Value+  ```++  This mirrors similar changes made in `aeson-2.0.*`, where the type of+  `Object`'s field was changed from `HashMap Text Value` to `KeyMap Value`.++  The `Ixed Value` instance changes similarly:++  ```diff+  -type instance Index Value = Text+  +type instance Index Value = Key+  ```+* Remove `Primitive` and `AsPrimitive`, since https://tools.ietf.org/html/rfc7159+  de-emphasized the notion of primitive versus composite JSON values.+  * The `AsPrimitive` methods (`_Value`, `_String`, and `_Bool`) are now+    `AsValue` methods.+  * `_Number`'s default signature, `Bool_`, `String_`, and `Null_` now have an+    `AsValue` constraint.+* Add an `IsKey` class, whose method `_Key` is an `Iso` for converting values+  to and from a `Key`.+ # 1.1.1  - Support `aeson-2.0.0.0`: add instances for `KeyMap`.

@@ -1,4 +1,4 @@-version:            1.1.1+version:            1.2 name:               aeson-optics category:           Data, JSON, Optics license:            MIT@@ -16,14 +16,20 @@  build-type:         Simple tested-with:-  GHC ==8.0.2 || ==8.2.2 || ==8.4.4 || ==8.6.5 || ==8.8.4 || ==8.10.4 || ==9.0.1+  GHC ==8.2.2+   || ==8.4.4+   || ==8.6.5+   || ==8.8.4+   || ==8.10.7+   || ==9.0.2+   || ==9.2.2  synopsis:           Law-abiding optics for aeson description:        Law-abiding optics for aeson. extra-source-files:   AUTHORS.markdown-  README.markdown   CHANGELOG.md+  README.markdown  source-repository head   type:     git@@ -32,15 +38,15 @@ library   default-language: Haskell2010   build-depends:-      aeson                 >=0.11     && <1.6 || >=2.0 && <2.1+      aeson                 >=2.0.3.0  && <2.1     , attoparsec            >=0.13.1.0 && <0.15-    , base                  >=4.9      && <4.16-    , base-compat           >=0.9.3    && <0.13+    , base                  >=4.10     && <4.17     , bytestring            >=0.10.8.1 && <0.12-    , optics-core           >=0.1      && <0.5-    , optics-extra          >=0.1      && <0.5+    , optics-core           >=0.4.1    && <0.5+    , optics-extra          >=0.4.1    && <0.5     , scientific            >=0.3.4.9  && <0.4-    , text                  >=1.2.2.0  && <1.3+    , text-short            >=0.1.5    && <0.2+    , text                  >=1.2.2.0  && <1.3 || >=2.0 && <2.1     , unordered-containers  >=0.2.8.0  && <0.3     , vector                >=0.11     && <0.13 

@@ -27,13 +27,11 @@     AsNumber(..)   , _Integral   , nonNull-  -- * Primitive-  , Primitive(..)-  , AsPrimitive(..)   -- * Objects and Arrays   , AsValue(..)   , key, members   , nth, values+  , IsKey (..)   -- * Decoding   , AsJSON(..)   , _JSON'@@ -44,48 +42,48 @@   , pattern Double   , pattern Integer   , pattern Integral-  , pattern Primitive   , pattern Bool_   , pattern String_   , pattern Null_+  , pattern Key_   ) where -import Prelude ()-import Prelude.Compat hiding (null)+import Prelude hiding (null)  import Data.Aeson        (FromJSON, Result (..), ToJSON, Value (..), encode, fromJSON, toJSON) import Data.Aeson.Parser               (value) import Data.Attoparsec.ByteString.Lazy (maybeResult, parse)-import Data.ByteString.Lazy.Char8      as Lazy hiding (putStrLn)-import Data.Data-import Data.HashMap.Strict             (HashMap) import Data.Scientific                 (Scientific) import Data.Text                       (Text) import Data.Text.Optics                (packed)+import Data.Text.Short                 (ShortText) import Data.Vector                     (Vector)  import Optics.At () import Optics.Core import Optics.Indexed () -import qualified Data.ByteString         as Strict-import qualified Data.ByteString.Lazy    as LBS-import qualified Data.Scientific         as Scientific-import qualified Data.Text               as StrictText-import qualified Data.Text.Encoding      as StrictText-import qualified Data.Text.Lazy          as LazyText-import qualified Data.Text.Lazy.Encoding as LazyText--#if MIN_VERSION_aeson(2,0,0)-import qualified Data.Aeson.Key    as Key-import qualified Data.Aeson.KeyMap as KM-#endif+import qualified Data.Aeson.Key             as Key+import qualified Data.Aeson.KeyMap          as KM+import qualified Data.ByteString            as Strict+import qualified Data.ByteString.Lazy       as LBS+import qualified Data.Scientific            as Scientific+import qualified Data.Text                  as StrictText+import qualified Data.Text.Encoding         as StrictText+import qualified Data.Text.Lazy             as LazyText+import qualified Data.Text.Lazy.Encoding    as LazyText  -- $setup--- >>> import Data.ByteString.Char8 as Strict.Char8--- >>> import qualified Data.Vector as Vector--- >>> import qualified Data.HashMap.Strict as HashMap+-- >>> import Optics.Core+-- >>> import Data.Aeson (Value (..))+-- >>> import Data.Text (Text)+-- >>> import qualified Data.ByteString             as Strict+-- >>> import qualified Data.ByteString.Char8       as Strict.Char8+-- >>> import qualified Data.ByteString.Lazy        as Lazy+-- >>> import qualified Data.ByteString.Lazy.Char8  as Lazy.Char8+-- >>> import qualified Data.Aeson.KeyMap           as KeyMap+-- >>> import qualified Data.Vector                 as Vector -- >>> :set -XOverloadedStrings -- >>> import Optics.Operators @@ -101,8 +99,8 @@   -- >>> "[1, \"x\"]" ^? nth 1 % _Number   -- Nothing   _Number :: Prism' t Scientific-  default _Number :: AsPrimitive t => Prism' t Scientific-  _Number = _Primitive%_Number+  default _Number :: AsValue t => Prism' t Scientific+  _Number = _Value%_Number   {-# INLINE _Number #-}    -- |@@ -138,7 +136,7 @@   {-# INLINE _Number #-}  instance AsNumber Strict.ByteString-instance AsNumber Lazy.ByteString+instance AsNumber LBS.ByteString instance AsNumber Text instance AsNumber LazyText.Text instance AsNumber String@@ -158,54 +156,60 @@ _Integral = _Number % iso floor fromIntegral {-# INLINE _Integral #-} +-- | Prism into non-'Null' values+--+-- >>> "{\"a\": \"xyz\", \"b\": null}" ^? key "a" % nonNull+-- Just (String "xyz")+--+-- >>> "{\"a\": {}, \"b\": null}" ^? key "a" % nonNull+-- Just (Object (fromList []))+--+-- >>> "{\"a\": \"xyz\", \"b\": null}" ^? key "b" % nonNull+-- Nothing+nonNull :: Prism' Value Value+nonNull = prism id (\v -> if isn't _Null v then Right v else Left v)+{-# INLINE nonNull #-}+ --------------------------------------------------------------------------------- Null values and primitives+-- Non-primitive traversals ------------------------------------------------------------------------------ --- | Primitives of 'Value'-data Primitive-  = StringPrim !Text-  | NumberPrim !Scientific-  | BoolPrim !Bool-  | NullPrim-  deriving (Eq,Ord,Show,Data,Typeable)--instance AsNumber Primitive where-  _Number = prism NumberPrim $ \v -> case v of NumberPrim s -> Right s; _ -> Left v-  {-# INLINE _Number #-}+class AsNumber t => AsValue t where+  -- |+  -- >>> preview _Value "[1,2,3]" == Just (Array (Vector.fromList [Number 1.0,Number 2.0,Number 3.0]))+  -- True+  _Value :: Prism' t Value -class AsNumber t => AsPrimitive t where   -- |-  -- >>> "[1, \"x\", null, true, false]" ^? nth 0 % _Primitive-  -- Just (NumberPrim 1.0)-  ---  -- >>> "[1, \"x\", null, true, false]" ^? nth 1 % _Primitive-  -- Just (StringPrim "x")-  ---  -- >>> "[1, \"x\", null, true, false]" ^? nth 2 % _Primitive-  -- Just NullPrim+  -- >>> "{\"a\": {}, \"b\": null}" ^? key "a" % _Object+  -- Just (fromList [])   ---  -- >>> "[1, \"x\", null, true, false]" ^? nth 3 % _Primitive-  -- Just (BoolPrim True)+  -- >>> "{\"a\": {}, \"b\": null}" ^? key "b" % _Object+  -- Nothing   ---  -- >>> "[1, \"x\", null, true, false]" ^? nth 4 % _Primitive-  -- Just (BoolPrim False)-  _Primitive :: Prism' t Primitive-  default _Primitive :: AsValue t => Prism' t Primitive-  _Primitive = _Value%_Primitive-  {-# INLINE _Primitive #-}+  -- >>> _Object # KeyMap.fromList [("key", _String # "value")] :: String+  -- "{\"key\":\"value\"}"+  _Object :: Prism' t (KM.KeyMap Value)+  _Object = _Value%prism Object  (\v -> case v of Object o -> Right o; _ -> Left v)    -- |+  -- >>> preview _Array "[1,2,3]" == Just (Vector.fromList [Number 1.0,Number 2.0,Number 3.0])+  -- True+  _Array :: Prism' t (Vector Value)+  _Array = _Value%prism Array (\v -> case v of Array a -> Right a; _ -> Left v)+  {-# INLINE _Array #-}++  -- |   -- >>> "{\"a\": \"xyz\", \"b\": true}" ^? key "a" % _String   -- Just "xyz"   --   -- >>> "{\"a\": \"xyz\", \"b\": true}" ^? key "b" % _String   -- Nothing   ---  -- >>> _Object # HashMap.fromList [("key", _String # "value")] :: String+  -- >>> _Object # KeyMap.fromList [("key", _String # "value")] :: String   -- "{\"key\":\"value\"}"   _String :: Prism' t Text-  _String = _Primitive%prism StringPrim (\v -> case v of StringPrim s -> Right s; _ -> Left v)+  _String = _Value%prism String (\v -> case v of String s -> Right s; _ -> Left v)   {-# INLINE _String #-}    -- |@@ -221,7 +225,7 @@   -- >>> _Bool # False :: String   -- "false"   _Bool :: Prism' t Bool-  _Bool = _Primitive%prism BoolPrim (\v -> case v of BoolPrim b -> Right b; _ -> Left v)+  _Bool = _Value%prism Bool (\v -> case v of Bool b -> Right b; _ -> Left v)   {-# INLINE _Bool #-}    -- |@@ -234,94 +238,10 @@   -- >>> _Null # () :: String   -- "null"   _Null :: Prism' t ()-  _Null = _Primitive % prism (const NullPrim) (\v -> case v of NullPrim -> Right (); _ -> Left v)+  _Null = _Value % prism (const Null) (\v -> case v of Null -> Right (); _ -> Left v)   {-# INLINE _Null #-}  -instance AsPrimitive Value where-  _Primitive = prism fromPrim toPrim-    where-      toPrim (String s) = Right $ StringPrim s-      toPrim (Number n) = Right $ NumberPrim n-      toPrim (Bool b)   = Right $ BoolPrim b-      toPrim Null       = Right NullPrim-      toPrim v          = Left v-      {-# INLINE toPrim #-}-      fromPrim (StringPrim s) = String s-      fromPrim (NumberPrim n) = Number n-      fromPrim (BoolPrim b)   = Bool b-      fromPrim NullPrim       = Null-      {-# INLINE fromPrim #-}-  {-# INLINE _Primitive #-}-  _String = prism String $ \v -> case v of String s -> Right s; _ -> Left v-  {-# INLINE _String #-}-  _Bool = prism Bool (\v -> case v of Bool b -> Right b; _ -> Left v)-  {-# INLINE _Bool #-}-  _Null = prism (const Null) (\v -> case v of Null -> Right (); _ -> Left v)-  {-# INLINE _Null #-}--instance AsPrimitive Strict.ByteString-instance AsPrimitive Lazy.ByteString-instance AsPrimitive StrictText.Text-instance AsPrimitive LazyText.Text-instance AsPrimitive String--instance AsPrimitive Primitive where-  _Primitive = castOptic simple-  {-# INLINE _Primitive #-}---- | Prism into non-'Null' values------ >>> "{\"a\": \"xyz\", \"b\": null}" ^? key "a" % nonNull--- Just (String "xyz")------ >>> "{\"a\": {}, \"b\": null}" ^? key "a" % nonNull--- Just (Object (fromList []))------ >>> "{\"a\": \"xyz\", \"b\": null}" ^? key "b" % nonNull--- Nothing-nonNull :: Prism' Value Value-nonNull = prism id (\v -> if isn't _Null v then Right v else Left v)-{-# INLINE nonNull #-}----------------------------------------------------------------------------------- Non-primitive traversals---------------------------------------------------------------------------------class AsPrimitive t => AsValue t where-  -- |-  -- >>> preview _Value "[1,2,3]" == Just (Array (Vector.fromList [Number 1.0,Number 2.0,Number 3.0]))-  -- True-  _Value :: Prism' t Value--  -- |-  -- >>> "{\"a\": {}, \"b\": null}" ^? key "a" % _Object-  -- Just (fromList [])-  ---  -- >>> "{\"a\": {}, \"b\": null}" ^? key "b" % _Object-  -- Nothing-  ---  -- >>> _Object # HashMap.fromList [("key", _String # "value")] :: String-  -- "{\"key\":\"value\"}"-  _Object :: Prism' t (HashMap Text Value)-  _Object = _Value%prism (Object . fwd) (\v -> case v of Object o -> Right (bwd o); _ -> Left v)-    where-#if MIN_VERSION_aeson(2,0,0)-    fwd = KM.fromHashMapText-    bwd = KM.toHashMapText-#else-    fwd = id-    bwd = id-#endif-  {-# INLINE _Object #-}--  -- |-  -- >>> preview _Array "[1,2,3]" == Just (Vector.fromList [Number 1.0,Number 2.0,Number 3.0])-  -- True-  _Array :: Prism' t (Vector Value)-  _Array = _Value%prism Array (\v -> case v of Array a -> Right a; _ -> Left v)-  {-# INLINE _Array #-}- instance AsValue Value where   _Value = castOptic simple   {-# INLINE _Value #-}@@ -330,7 +250,7 @@   _Value = _JSON   {-# INLINE _Value #-} -instance AsValue Lazy.ByteString where+instance AsValue LBS.ByteString where   _Value = _JSON   {-# INLINE _Value #-} @@ -355,7 +275,7 @@ -- -- >>> "[1,2,3]" ^? key "a" -- Nothing-key :: AsValue t => Text -> AffineTraversal' t Value+key :: AsValue t => Key.Key -> AffineTraversal' t Value key i = _Object % ix i {-# INLINE key #-} @@ -366,7 +286,7 @@ -- -- >>> "{\"a\": 4}" & members % _Number %~ (*10) -- "{\"a\":40}"-members :: AsValue t => IxTraversal' Text t Value+members :: AsValue t => IxTraversal' Key.Key t Value members = _Object % itraversed {-# INLINE members #-} @@ -401,12 +321,57 @@ strictTextUtf8 :: Iso' StrictText.Text Strict.ByteString strictTextUtf8 = iso StrictText.encodeUtf8 StrictText.decodeUtf8 -lazyTextUtf8 :: Iso' LazyText.Text Lazy.ByteString+lazyTextUtf8 :: Iso' LazyText.Text LBS.ByteString lazyTextUtf8 = iso LazyText.encodeUtf8 LazyText.decodeUtf8  _JSON' :: (AsJSON t, FromJSON a, ToJSON a) => Prism' t a _JSON' = _JSON +class IsKey t where+  -- | '_Key' is an 'Iso' from something to a 'Key'. This is primarily intended+  -- for situations where one wishes to use object keys that are not string+  -- literals and therefore must be converted:+  --+  -- >>> let k = "a" :: Text+  -- >>> "{\"a\": 100, \"b\": 200}" ^? key (k ^. _Key)+  -- Just (Number 100.0)+  --+  -- Note that applying '_Key' directly to a string literal+  -- (e.g., @\"a\" ^. '_Key'@) will likely not typecheck when+  -- @OverloadedStrings@ is enabled.+  _Key :: Iso' t Key.Key++instance IsKey Key.Key where+  _Key = simple+  {-# INLINE _Key #-}++instance IsKey String where+  _Key = iso Key.fromString Key.toString+  {-# INLINE _Key #-}++instance IsKey Text where+  _Key = iso Key.fromText Key.toText+  {-# INLINE _Key #-}++instance IsKey LazyText.Text where+  _Key = iso LazyText.toStrict LazyText.fromStrict % _Key+  {-# INLINE _Key #-}++instance IsKey ShortText where+  _Key = iso Key.fromShortText Key.toShortText+  {-# INLINE _Key #-}++{-+https://github.com/lens/lens-aeson/issues/48+instance IsKey Strict.ByteString where+  _Key = from strictTextUtf8._Key+  {-# INLINE _Key #-}++instance IsKey LBS.ByteString where+  _Key = from lazyTextUtf8._Key+  {-# INLINE _Key #-}+-}+ class AsJSON t where   -- | '_JSON' is a 'Prism' from something containing JSON to something encoded in that structure   _JSON :: (FromJSON a, ToJSON b) => Prism t t a b@@ -415,10 +380,10 @@   _JSON = iso LBS.fromStrict LBS.toStrict % _JSON   {-# INLINE _JSON #-} -instance AsJSON Lazy.ByteString where+instance AsJSON LBS.ByteString where   _JSON = prism' encode decodeValue     where-      decodeValue :: (FromJSON a) => Lazy.ByteString -> Maybe a+      decodeValue :: (FromJSON a) => LBS.ByteString -> Maybe a       decodeValue s = maybeResult (parse value s) >>= \x -> case fromJSON x of         Success v -> Just v         _         -> Nothing@@ -453,7 +418,7 @@ -- >>> preview (_Integer :: Prism' Lazy.ByteString Integer) "42" -- Just 42 ----- >>> Lazy.unpack (review (_Integer :: Prism' Lazy.ByteString Integer) 42)+-- >>> Lazy.Char8.unpack (review (_Integer :: Prism' Lazy.ByteString Integer) 42) -- "42"  -- $StrictByteStringTests@@ -480,7 +445,7 @@ -- Orphan instances for lens library interop ------------------------------------------------------------------------------ -type instance Index Value = Text+type instance Index Value = Key.Key  type instance IxValue Value = Value instance Ixed Value where@@ -495,7 +460,6 @@   {-# INLINE plate #-} -} -#if MIN_VERSION_aeson(2,0,0) type instance Index (KM.KeyMap v) = Key.Key type instance IxValue (KM.KeyMap v) = v @@ -508,13 +472,11 @@ instance Each Key.Key (KM.KeyMap a) (KM.KeyMap b) a b where   each = itraversalVL KM.traverseWithKey   {-# INLINE[1] each #-}-#endif  ------------------------------------------------------------------------------ -- Pattern Synonyms ------------------------------------------------------------------------------ -#if __GLASGOW_HASKELL__ >= 800 pattern JSON :: (FromJSON a, ToJSON a, AsJSON t) => () => a -> t pattern JSON a <- (preview _JSON -> Just a) where   JSON a = _JSON # a@@ -539,19 +501,18 @@ pattern Integral d <- (preview _Integral -> Just d) where   Integral d = _Integral # d -pattern Primitive :: AsPrimitive t => Primitive -> t-pattern Primitive p <- (preview _Primitive -> Just p) where-  Primitive p = _Primitive # p--pattern Bool_ :: AsPrimitive t => Bool -> t+pattern Bool_ :: AsValue t => Bool -> t pattern Bool_ b <- (preview _Bool -> Just b) where   Bool_ b = _Bool # b -pattern String_ :: AsPrimitive t => Text -> t+pattern String_ :: AsValue t => Text -> t pattern String_ p <- (preview _String -> Just p) where   String_ p = _String # p -pattern Null_ :: AsPrimitive t => t+pattern Null_ :: AsValue t => t pattern Null_ <- (preview _Null -> Just ()) where   Null_ = _Null # ()-#endif++pattern Key_ :: IsKey t => Key.Key -> t+pattern Key_ k <- (preview _Key -> Just k) where+  Key_ k = _Key # k