@@ -5,16 +5,19 @@
5{-# LANGUAGE FlexibleInstances #-}
5{-# LANGUAGE FlexibleInstances #-}
6{-# LANGUAGE GADTs #-}
6{-# LANGUAGE GADTs #-}
7{-# LANGUAGE MultiParamTypeClasses #-}
7{-# LANGUAGE MultiParamTypeClasses #-}
8−{-# LANGUAGE NoImplicitPrelude #-}
8+{-# LANGUAGE NamedFieldPuns #-}
9{-# LANGUAGE OverloadedStrings #-}
9{-# LANGUAGE OverloadedStrings #-}
10−{-# LANGUAGE PolyKinds #-}
11{-# LANGUAGE RecordWildCards #-}
10{-# LANGUAGE RecordWildCards #-}
12{-# LANGUAGE ScopedTypeVariables #-}
11{-# LANGUAGE ScopedTypeVariables #-}
13{-# LANGUAGE TypeOperators #-}
12{-# LANGUAGE TypeOperators #-}
14−{-# LANGUAGE TupleSections #-}
13+{-# LANGUAGE TypeSynonymInstances #-}
15{-# LANGUAGE UndecidableInstances #-}
14{-# LANGUAGE UndecidableInstances #-}
16{-# LANGUAGE ViewPatterns #-}
15{-# LANGUAGE ViewPatterns #-}
17+#if __GLASGOW_HASKELL__ >= 706
18+{-# LANGUAGE PolyKinds #-}
18#include "incoherent-compat.h"
21#include "incoherent-compat.h"
19#include "overlapping-compat.h"
22#include "overlapping-compat.h"
@@ -42,9 +45,6 @@ module Data.Aeson.Types.FromJSON
42 , coerceFromJSONKeyFunction
45 , coerceFromJSONKeyFunction
43 , mapFromJSONKeyFunction
46 , mapFromJSONKeyFunction
48 -- * List functions
48 -- * List functions
49 , listParser
49 , listParser
@@ -52,22 +52,20 @@ module Data.Aeson.Types.FromJSON
52 , withObject
52 , withObject
53 , withText
53 , withText
54 , withArray
54 , withArray
55 , withScientific
56 , withScientific
56 , withBool
57 , withBool
59 -- * Functions
59 -- * Functions
60 , fromJSON
60 , fromJSON
61 , ifromJSON
61 , ifromJSON
62 , typeMismatch
62 , typeMismatch
64 , parseField
63 , parseField
65 , parseFieldMaybe
64 , parseFieldMaybe
66 , parseFieldMaybe'
65 , parseFieldMaybe'
67 , explicitParseField
66 , explicitParseField
68 , explicitParseFieldMaybe
67 , explicitParseFieldMaybe
69 , explicitParseFieldMaybe'
68 , explicitParseFieldMaybe'
71 -- ** Operators
69 -- ** Operators
@@ -78,16 +76,17 @@ module Data.Aeson.Types.FromJSON
78 , parseOptionalFieldWith
76 , parseOptionalFieldWith
81import Prelude.Compat
80import Prelude.Compat
83−import Control.Applicative ((<|>), Const(..), liftA2)
82+import Control.Applicative ((<|>), Const(..))
84−import Control.Monad (zipWithM)
83+import Control.Monad ((<=<), zipWithM)
85import Data.Aeson.Internal.Functions (mapKey)
84import Data.Aeson.Internal.Functions (mapKey)
86−import Data.Aeson.Parser.Internal (eitherDecodeWith, jsonEOF)
87import Data.Aeson.Types.Generic
85import Data.Aeson.Types.Generic
88import Data.Aeson.Types.Internal
86import Data.Aeson.Types.Internal
87+import Data.Attoparsec.Number (Number(..))
89import Data.Bits (unsafeShiftR)
88import Data.Bits (unsafeShiftR)
90−import Data.Fixed (Fixed, HasResolution (resolution), Nano)
89+import Data.Fixed (Fixed, HasResolution)
91import Data.Functor.Compose (Compose(..))
90import Data.Functor.Compose (Compose(..))
92import Data.Functor.Identity (Identity(..))
91import Data.Functor.Identity (Identity(..))
93import Data.Functor.Product (Product(..))
92import Data.Functor.Product (Product(..))
@@ -96,31 +95,26 @@ import Data.Hashable (Hashable(..))
96import Data.Int (Int16, Int32, Int64, Int8)
95import Data.Int (Int16, Int32, Int64, Int8)
97import Data.List.NonEmpty (NonEmpty(..))
96import Data.List.NonEmpty (NonEmpty(..))
98import Data.Maybe (fromMaybe)
97import Data.Maybe (fromMaybe)
99−import Data.Semigroup ((<>))
98+import Data.Monoid ((<>))
100import Data.Proxy (Proxy(..))
99import Data.Proxy (Proxy(..))
101import Data.Ratio ((%), Ratio)
100import Data.Ratio ((%), Ratio)
102−import Data.Scientific (Scientific, base10Exponent)
101+import Data.Scientific (Scientific)
103import Data.Tagged (Tagged(..))
102import Data.Tagged (Tagged(..))
104import Data.Text (Text, pack, unpack)
103import Data.Text (Text, pack, unpack)
105−import Data.Time (Day, DiffTime, LocalTime, NominalDiffTime, TimeOfDay, UTCTime, ZonedTime)
104+import Data.Time (Day, LocalTime, NominalDiffTime, TimeOfDay, UTCTime, ZonedTime)
106−import Data.Time.Calendar.Compat (CalendarDiffDays (..), DayOfWeek (..))
105+import Data.Time.Format (parseTime)
107−import Data.Time.LocalTime.Compat (CalendarDiffTime (..))
108−import Data.Time.Clock.System.Compat (SystemTime (..))
109−import Data.Time.Format.Compat (parseTimeM, defaultTimeLocale)
106+import Data.Time.Locale.Compat (defaultTimeLocale)
110import Data.Traversable as Tr (sequence)
107import Data.Traversable as Tr (sequence)
111import Data.Vector (Vector)
108import Data.Vector (Vector)
112import Data.Version (Version, parseVersion)
109import Data.Version (Version, parseVersion)
113−import Data.Void (Void)
114import Data.Word (Word16, Word32, Word64, Word8)
110import Data.Word (Word16, Word32, Word64, Word8)
115import Foreign.Storable (Storable)
111import Foreign.Storable (Storable)
116−import Foreign.C.Types (CTime (..))
117import GHC.Generics
112import GHC.Generics
118import Numeric.Natural (Natural)
113import Numeric.Natural (Natural)
119import Text.ParserCombinators.ReadP (readP_to_S)
114import Text.ParserCombinators.ReadP (readP_to_S)
120import Unsafe.Coerce (unsafeCoerce)
115import Unsafe.Coerce (unsafeCoerce)
121import qualified Data.Aeson.Parser.Time as Time
116import qualified Data.Aeson.Parser.Time as Time
122import qualified Data.Attoparsec.ByteString.Char8 as A (endOfInput, parseOnly, scientific)
117import qualified Data.Attoparsec.ByteString.Char8 as A (endOfInput, parseOnly, scientific)
123−import qualified Data.ByteString.Lazy as L
124import qualified Data.DList as DList
118import qualified Data.DList as DList
125import qualified Data.HashMap.Strict as H
119import qualified Data.HashMap.Strict as H
126import qualified Data.HashSet as HashSet
120import qualified Data.HashSet as HashSet
@@ -143,20 +137,18 @@ import qualified Data.Vector.Primitive as VP
143import qualified Data.Vector.Storable as VS
137import qualified Data.Vector.Storable as VS
144import qualified Data.Vector.Unboxed as VU
138import qualified Data.Vector.Unboxed as VU
146−import qualified GHC.Exts as Exts
140+#ifndef HAS_COERCIBLE
147−import qualified Data.Primitive.Array as PM
141+#define HAS_COERCIBLE (__GLASGOW_HASKELL__ >= 707)
148−import qualified Data.Primitive.SmallArray as PM
149−import qualified Data.Primitive.Types as PM
151−#if MIN_VERSION_primitive(0,6,4)
152−#if !MIN_VERSION_primitive(0,7,0)
153−import qualified Data.Primitive.UnliftedArray as PM
155−import qualified Data.Primitive.PrimArray as PM
159import Data.Coerce (Coercible, coerce)
145import Data.Coerce (Coercible, coerce)
146+coerce' :: Coercible a b => a -> b
150+coerce' = unsafeCoerce
161parseIndexedJSON :: (Value -> Parser a) -> Int -> Value -> Parser a
153parseIndexedJSON :: (Value -> Parser a) -> Int -> Value -> Parser a
162parseIndexedJSON p idx value = p value <?> Index idx
154parseIndexedJSON p idx value = p value <?> Index idx
@@ -165,7 +157,7 @@ parseIndexedJSON p idx value = p value <?> Index idx
165parseIndexedJSONPair :: (Value -> Parser a) -> (Value -> Parser b) -> Int -> Value -> Parser (a, b)
157parseIndexedJSONPair :: (Value -> Parser a) -> (Value -> Parser b) -> Int -> Value -> Parser (a, b)
166parseIndexedJSONPair keyParser valParser idx value = p value <?> Index idx
158parseIndexedJSONPair keyParser valParser idx value = p value <?> Index idx
168− p = withArray "(k, v)" $ \ab ->
160+ p = withArray "(k,v)" $ \ab ->
169 let n = V.length ab
161 let n = V.length ab
170 in if n == 2
162 in if n == 2
171 then (,) <$> parseJSONElemAtIndex keyParser 0 ab
163 then (,) <$> parseJSONElemAtIndex keyParser 0 ab
@@ -177,34 +169,43 @@ parseIndexedJSONPair keyParser valParser idx value = p value <?> Index idx
177parseJSONElemAtIndex :: (Value -> Parser a) -> Int -> V.Vector Value -> Parser a
169parseJSONElemAtIndex :: (Value -> Parser a) -> Int -> V.Vector Value -> Parser a
178parseJSONElemAtIndex p idx ary = p (V.unsafeIndex ary idx) <?> Index idx
170parseJSONElemAtIndex p idx ary = p (V.unsafeIndex ary idx) <?> Index idx
172+scientificToNumber :: Scientific -> Number
174+ | e < 0 = D $ Scientific.toRealFloat s
175+ | otherwise = I $ c * 10 ^ e
177+ e = Scientific.base10Exponent s
178+ c = Scientific.coefficient s
179+{-# INLINE scientificToNumber #-}
180parseRealFloat :: RealFloat a => String -> Value -> Parser a
181parseRealFloat :: RealFloat a => String -> Value -> Parser a
181−parseRealFloat _ (Number s) = pure $ Scientific.toRealFloat s
182+parseRealFloat _ (Number s) = pure $ Scientific.toRealFloat s
182−parseRealFloat _ Null = pure (0/0)
183+parseRealFloat _ Null = pure (0/0)
183−parseRealFloat name v = prependContext name (unexpected v)
184+parseRealFloat expected v = typeMismatch expected v
184{-# INLINE parseRealFloat #-}
185{-# INLINE parseRealFloat #-}
186−parseIntegralFromScientific :: forall a. Integral a => Scientific -> Parser a
187+parseIntegralFromScientific :: forall a. Integral a => String -> Scientific -> Parser a
187−parseIntegralFromScientific s =
188+parseIntegralFromScientific expected s =
188 case Scientific.floatingOrInteger s :: Either Double a of
189 case Scientific.floatingOrInteger s :: Either Double a of
189 Right x -> pure x
190 Right x -> pure x
190− Left _ -> fail $ "unexpected floating number " ++ show s
191+ Left _ -> fail $ "Floating number specified for " ++ expected ++ ": " ++ show s
191{-# INLINE parseIntegralFromScientific #-}
192{-# INLINE parseIntegralFromScientific #-}
193parseIntegral :: Integral a => String -> Value -> Parser a
194parseIntegral :: Integral a => String -> Value -> Parser a
194−parseIntegral name =
195+parseIntegral expected =
195− prependContext name . withBoundedScientific' parseIntegralFromScientific
196+ withScientific expected $ parseIntegralFromScientific expected
196{-# INLINE parseIntegral #-}
197{-# INLINE parseIntegral #-}
198−parseBoundedIntegralFromScientific :: (Bounded a, Integral a) => Scientific -> Parser a
199+parseBoundedIntegralFromScientific :: (Bounded a, Integral a) => String -> Scientific -> Parser a
199−parseBoundedIntegralFromScientific s = maybe
200+parseBoundedIntegralFromScientific expected s = maybe
200− (fail $ "value is either floating or will cause over or underflow " ++ show s)
201+ (fail $ expected ++ " is either floating or will cause over or underflow: " ++ show s)
202 (Scientific.toBoundedInteger s)
203 (Scientific.toBoundedInteger s)
203{-# INLINE parseBoundedIntegralFromScientific #-}
204{-# INLINE parseBoundedIntegralFromScientific #-}
205parseBoundedIntegral :: (Bounded a, Integral a) => String -> Value -> Parser a
206parseBoundedIntegral :: (Bounded a, Integral a) => String -> Value -> Parser a
206−parseBoundedIntegral name =
207+parseBoundedIntegral expected =
207− prependContext name . withScientific' parseBoundedIntegralFromScientific
208+ withScientific expected $ parseBoundedIntegralFromScientific expected
208{-# INLINE parseBoundedIntegral #-}
209{-# INLINE parseBoundedIntegral #-}
210parseScientificText :: Text -> Parser Scientific
211parseScientificText :: Text -> Parser Scientific
@@ -214,20 +215,13 @@ parseScientificText
214 . T.encodeUtf8
215 . T.encodeUtf8
216parseIntegralText :: Integral a => String -> Text -> Parser a
217parseIntegralText :: Integral a => String -> Text -> Parser a
217−parseIntegralText name t =
218+parseIntegralText expected t =
218− prependContext name $
219− parseScientificText t
220− >>= rejectLargeExponent
221− >>= parseIntegralFromScientific
219+ parseScientificText t >>= parseIntegralFromScientific expected
223− rejectLargeExponent :: Scientific -> Parser Scientific
224− rejectLargeExponent s = withBoundedScientific' pure (Number s)
225{-# INLINE parseIntegralText #-}
220{-# INLINE parseIntegralText #-}
227parseBoundedIntegralText :: (Bounded a, Integral a) => String -> Text -> Parser a
222parseBoundedIntegralText :: (Bounded a, Integral a) => String -> Text -> Parser a
228−parseBoundedIntegralText name t =
223+parseBoundedIntegralText expected t =
229− prependContext name $
230− parseScientificText t >>= parseBoundedIntegralFromScientific
224+ parseScientificText t >>= parseBoundedIntegralFromScientific expected
232parseOptionalFieldWith :: (Value -> Parser (Maybe a))
226parseOptionalFieldWith :: (Value -> Parser (Maybe a))
233 -> Object -> Text -> Parser (Maybe a)
227 -> Object -> Text -> Parser (Maybe a)
@@ -287,21 +281,14 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
288-- The basic ways to signal a failed conversion are as follows:
282-- The basic ways to signal a failed conversion are as follows:
290−-- * 'fail' yields a custom error message: it is the recommended way of
284+-- * 'empty' and 'mzero' work, but are terse and uninformative
291−-- reporting a failure;
293−-- * 'Control.Applicative.empty' (or 'Control.Monad.mzero') is uninformative:
286+-- * 'fail' yields a custom error message
294−-- use it when the error is meant to be caught by some @('<|>')@;
296−-- * 'typeMismatch' can be used to report a failure when the encountered value
288+-- * 'typeMismatch' produces an informative message for cases when the
297−-- is not of the expected JSON type; 'unexpected' is an appropriate alternative
289+-- value encountered is not of the expected type
298−-- when more than one type may be expected, or to keep the expected type
301−-- 'prependFailure' (or 'modifyFailure') add more information to a parser's
304−-- An example type and instance using 'typeMismatch' and 'prependFailure':
291+-- An example type and instance using 'typeMismatch':
307-- \-- Allow ourselves to write 'Text' literals.
294-- \-- Allow ourselves to write 'Text' literals.
@@ -309,29 +296,27 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
310-- data Coord = Coord { x :: Double, y :: Double }
297-- data Coord = Coord { x :: Double, y :: Double }
312−-- instance 'FromJSON' Coord where
299+-- instance FromJSON Coord where
313−-- 'parseJSON' ('Object' v) = Coord
300+-- parseJSON ('Object' v) = Coord
314−-- '<$>' v '.:' \"x\"
301+-- '<$>' v '.:' \"x\"
315-- '<*>' v '.:' \"y\"
302-- '<*>' v '.:' \"y\"
317-- \-- We do not expect a non-'Object' value here.
304-- \-- We do not expect a non-'Object' value here.
318−-- \-- We could use 'Control.Applicative.empty' to fail, but 'typeMismatch'
305+-- \-- We could use 'mzero' to fail, but 'typeMismatch'
319-- \-- gives a much more informative error message.
306-- \-- gives a much more informative error message.
320−-- 'parseJSON' invalid =
307+-- parseJSON invalid = 'typeMismatch' \"Coord\" invalid
321−-- 'prependFailure' "parsing Coord failed, "
322−-- ('typeMismatch' \"Object\" invalid)
325-- For this common case of only being concerned with a single
310-- For this common case of only being concerned with a single
326−-- type of JSON value, the functions 'withObject', 'withScientific', etc.
311+-- type of JSON value, the functions @withObject@, @withNumber@, etc.
327-- are provided. Their use is to be preferred when possible, since
312-- are provided. Their use is to be preferred when possible, since
328−-- they are more terse. Using 'withObject', we can rewrite the above instance
313+-- they are more terse. Using @withObject@, we can rewrite the above instance
329-- (assuming the same language extension and data type) as:
314-- (assuming the same language extension and data type) as:
332−-- instance 'FromJSON' Coord where
317+-- instance FromJSON Coord where
333−-- 'parseJSON' = 'withObject' \"Coord\" $ \\v -> Coord
318+-- parseJSON = withObject \"Coord\" $ \v -> Coord
334−-- '<$>' v '.:' \"x\"
319+-- '<$>' v '.:' \"x\"
335-- '<*>' v '.:' \"y\"
320-- '<*>' v '.:' \"y\"
@@ -340,7 +325,7 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
341-- * "Data.Aeson.TH" provides Template Haskell functions which will derive an
326-- * "Data.Aeson.TH" provides Template Haskell functions which will derive an
342-- instance at compile time. The generated instance is optimized for your type
327-- instance at compile time. The generated instance is optimized for your type
343−-- so it will probably be more efficient than the following option.
328+-- so will probably be more efficient than the following two options:
345-- * The compiler can provide a default generic implementation for
330-- * The compiler can provide a default generic implementation for
346-- 'parseJSON'.
331-- 'parseJSON'.
@@ -358,21 +343,18 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
359-- data Coord = Coord { x :: Double, y :: Double } deriving 'Generic'
344-- data Coord = Coord { x :: Double, y :: Double } deriving 'Generic'
361−-- instance 'FromJSON' Coord
346+-- instance FromJSON Coord
364−-- The default implementation will be equivalent to
349+-- If @DefaultSignatures@ doesn't give exactly the results you want,
365−-- @parseJSON = 'genericParseJSON' 'defaultOptions'@; if you need different
366−-- options, you can customize the generic decoding by defining:
350+-- you can customize the generic decoding with only a tiny amount of
351+-- effort, using 'genericParseJSON' with your preferred 'Options':
369−-- customOptions = 'defaultOptions'
370−-- { 'fieldLabelModifier' = 'map' 'Data.Char.toUpper'
373−-- instance 'FromJSON' Coord where
354+-- instance FromJSON Coord where
374−-- 'parseJSON' = 'genericParseJSON' customOptions
355+-- parseJSON = 'genericParseJSON' 'defaultOptions'
376class FromJSON a where
358class FromJSON a where
377 parseJSON :: Value -> Parser a
359 parseJSON :: Value -> Parser a
@@ -380,11 +362,13 @@ class FromJSON a where
380 parseJSON = genericParseJSON defaultOptions
362 parseJSON = genericParseJSON defaultOptions
382 parseJSONList :: Value -> Parser [a]
364 parseJSONList :: Value -> Parser [a]
383− parseJSONList = withArray "[]" $ \a ->
365+ parseJSONList (Array a)
384− zipWithM (parseIndexedJSON parseJSON) [0..]
366+ = zipWithM (parseIndexedJSON parseJSON) [0..]
385 . V.toList
367 . V.toList
370+ parseJSONList v = typeMismatch "[a]" v
388-------------------------------------------------------------------------------
372-------------------------------------------------------------------------------
389-- Classes and types for map keys
373-- Classes and types for map keys
390-------------------------------------------------------------------------------
374-------------------------------------------------------------------------------
@@ -396,16 +380,6 @@ class FromJSON a where
396-- > newtype SomeId = SomeId { getSomeId :: Text }
380-- > newtype SomeId = SomeId { getSomeId :: Text }
397-- > deriving (Eq,Ord,Hashable,FromJSONKey)
381-- > deriving (Eq,Ord,Hashable,FromJSONKey)
399−-- If you have a sum of nullary constructors, you may use the generic
403−-- data Color = Red | Green | Blue
406−-- instance 'FromJSONKey' Color where
407−-- 'fromJSONKey' = 'genericFromJSONKey' 'defaultJSONKeyOptions'
409class FromJSONKey a where
383class FromJSONKey a where
410 -- | Strategy for parsing the key of a map-like container.
384 -- | Strategy for parsing the key of a map-like container.
411 fromJSONKey :: FromJSONKeyFunction a
385 fromJSONKey :: FromJSONKeyFunction a
@@ -428,7 +402,11 @@ class FromJSONKey a where
428-- At the moment this type is intentionally not exported. 'FromJSONKeyFunction'
402-- At the moment this type is intentionally not exported. 'FromJSONKeyFunction'
429-- can be inspected, but cannot be constructed.
403-- can be inspected, but cannot be constructed.
430data CoerceText a where
404data CoerceText a where
431 CoerceText :: Coercible Text a => CoerceText a
406 CoerceText :: Coercible Text a => CoerceText a
408+ CoerceText :: CoerceText a
433-- | This type is related to 'ToJSONKeyFunction'. If 'FromJSONKeyValue' is used in the
411-- | This type is related to 'ToJSONKeyFunction'. If 'FromJSONKeyValue' is used in the
434-- 'FromJSONKey' instance, then 'ToJSONKeyValue' should be used in the 'ToJSONKey'
412-- 'FromJSONKey' instance, then 'ToJSONKeyValue' should be used in the 'ToJSONKey'
@@ -448,7 +426,7 @@ data FromJSONKeyFunction a
449-- | Only law abiding up to interpretation
427-- | Only law abiding up to interpretation
450instance Functor FromJSONKeyFunction where
428instance Functor FromJSONKeyFunction where
451− fmap h (FromJSONKeyCoerce CoerceText) = FromJSONKeyText (h . coerce)
429+ fmap h (FromJSONKeyCoerce CoerceText) = FromJSONKeyText (h . coerce')
452 fmap h (FromJSONKeyText f) = FromJSONKeyText (h . f)
430 fmap h (FromJSONKeyText f) = FromJSONKeyText (h . f)
453 fmap h (FromJSONKeyTextParser f) = FromJSONKeyTextParser (fmap h . f)
431 fmap h (FromJSONKeyTextParser f) = FromJSONKeyTextParser (fmap h . f)
454 fmap h (FromJSONKeyValue f) = FromJSONKeyValue (fmap h . f)
432 fmap h (FromJSONKeyValue f) = FromJSONKeyValue (fmap h . f)
@@ -462,7 +440,9 @@ instance Functor FromJSONKeyFunction where
463-- On pre GHC 7.8 this is unconstrainted function.
441-- On pre GHC 7.8 this is unconstrainted function.
464fromJSONKeyCoerce ::
442fromJSONKeyCoerce ::
465 Coercible Text a =>
444 Coercible Text a =>
466 FromJSONKeyFunction a
446 FromJSONKeyFunction a
467fromJSONKeyCoerce = FromJSONKeyCoerce CoerceText
447fromJSONKeyCoerce = FromJSONKeyCoerce CoerceText
@@ -470,91 +450,60 @@ fromJSONKeyCoerce = FromJSONKeyCoerce CoerceText
471-- See note on 'fromJSONKeyCoerce'.
451-- See note on 'fromJSONKeyCoerce'.
472coerceFromJSONKeyFunction ::
452coerceFromJSONKeyFunction ::
473 Coercible a b =>
454 Coercible a b =>
474 FromJSONKeyFunction a -> FromJSONKeyFunction b
456 FromJSONKeyFunction a -> FromJSONKeyFunction b
475coerceFromJSONKeyFunction = coerce
458coerceFromJSONKeyFunction = coerce
460+coerceFromJSONKeyFunction (FromJSONKeyCoerce CoerceText) = FromJSONKeyCoerce CoerceText
461+coerceFromJSONKeyFunction (FromJSONKeyText f) = FromJSONKeyText (coerce' . f)
462+coerceFromJSONKeyFunction (FromJSONKeyTextParser f) = FromJSONKeyTextParser (fmap coerce' . f)
463+coerceFromJSONKeyFunction (FromJSONKeyValue f) = FromJSONKeyValue (fmap coerce' . f)
478 "FromJSONKeyCoerce: fmap id" forall (x :: FromJSONKeyFunction a).
467 "FromJSONKeyCoerce: fmap id" forall (x :: FromJSONKeyFunction a).
479 fmap id x = x
468 fmap id x = x
482 "FromJSONKeyCoerce: fmap coerce" forall x .
472 "FromJSONKeyCoerce: fmap coerce" forall x .
483 fmap coerce x = coerceFromJSONKeyFunction x
473 fmap coerce x = coerceFromJSONKeyFunction x
486-- | Same as 'fmap'. Provided for the consistency with 'ToJSONKeyFunction'.
477-- | Same as 'fmap'. Provided for the consistency with 'ToJSONKeyFunction'.
487mapFromJSONKeyFunction :: (a -> b) -> FromJSONKeyFunction a -> FromJSONKeyFunction b
478mapFromJSONKeyFunction :: (a -> b) -> FromJSONKeyFunction a -> FromJSONKeyFunction b
488mapFromJSONKeyFunction = fmap
479mapFromJSONKeyFunction = fmap
490−-- | 'fromJSONKey' for 'Generic' types.
491−-- These types must be sums of nullary constructors, whose names will be used
492−-- as keys for JSON objects.
494−-- See also 'genericToJSONKey'.
499−-- data Color = Red | Green | Blue
500−-- deriving 'Generic'
502−-- instance 'FromJSONKey' Color where
503−-- 'fromJSONKey' = 'genericFromJSONKey' 'defaultJSONKeyOptions'
505−genericFromJSONKey :: forall a. (Generic a, GFromJSONKey (Rep a))
507− -> FromJSONKeyFunction a
508−genericFromJSONKey opts = FromJSONKeyTextParser $ \t ->
509− case parseSumFromString (keyModifier opts) t of
511− "invalid key " ++ show t ++ ", expected one of " ++ show cnames
512− Just k -> pure (to k)
514− cnames = unTagged2 (constructorTags (keyModifier opts) :: Tagged2 (Rep a) [String])
516−class (ConstructorNames f, SumFromString f) => GFromJSONKey f where
517−instance (ConstructorNames f, SumFromString f) => GFromJSONKey f where
519-------------------------------------------------------------------------------
481-------------------------------------------------------------------------------
520-- Functions needed for documentation
482-- Functions needed for documentation
521-------------------------------------------------------------------------------
483-------------------------------------------------------------------------------
523-- | Fail parsing due to a type mismatch, with a descriptive message.
485-- | Fail parsing due to a type mismatch, with a descriptive message.
525−-- The following wrappers should generally be prefered:
487+-- Example usage:
526−-- 'withObject', 'withArray', 'withText', 'withBool'.
528−-- ==== Error message example
530−-- > typeMismatch "Object" (String "oops")
489+-- @
531−-- > -- Error: "expected Object, but encountered String"
490+-- instance FromJSON Coord where
491+-- parseJSON ('Object' v) = {- type matches, life is good -}
492+-- parseJSON wat = 'typeMismatch' \"Coord\" wat
532−typeMismatch :: String -- ^ The name of the JSON type being parsed
494+typeMismatch :: String -- ^ The name of the type you are trying to parse.
533− -- (@\"Object\"@, @\"Array\"@, @\"String\"@, @\"Number\"@,
534− -- @\"Boolean\"@, or @\"Null\"@).
535 -> Value -- ^ The actual value encountered.
495 -> Value -- ^ The actual value encountered.
536 -> Parser a
496 -> Parser a
537typeMismatch expected actual =
497typeMismatch expected actual =
538− fail $ "expected " ++ expected ++ ", but encountered " ++ typeOf actual
498+ fail $ "expected " ++ expected ++ ", encountered " ++ name
540−-- | Fail parsing due to a type mismatch, when the expected types are implicit.
542−-- ==== Error message example
544−-- > unexpected (String "oops")
545−-- > -- Error: "unexpected String"
546−unexpected :: Value -> Parser a
547−unexpected actual = fail $ "unexpected " ++ typeOf actual
549−-- | JSON type of a value, name of the head constructor.
550−typeOf :: Value -> String
551−typeOf v = case v of
500+ name = case actual of
552− Object _ -> "Object"
501+ Object _ -> "Object"
553− Array _ -> "Array"
502+ Array _ -> "Array"
554− String _ -> "String"
503+ String _ -> "String"
555− Number _ -> "Number"
504+ Number _ -> "Number"
556− Bool _ -> "Boolean"
505+ Bool _ -> "Boolean"
557− Null -> "Null"
506+ Null -> "Null"
559-------------------------------------------------------------------------------
508-------------------------------------------------------------------------------
560-- Lifings of FromJSON and ToJSON to unary and binary type constructors
509-- Lifings of FromJSON and ToJSON to unary and binary type constructors
@@ -567,7 +516,7 @@ typeOf v = case v of
568-- * "Data.Aeson.TH" provides Template Haskell functions which will derive an
517-- * "Data.Aeson.TH" provides Template Haskell functions which will derive an
569-- instance at compile time. The generated instance is optimized for your type
518-- instance at compile time. The generated instance is optimized for your type
570−-- so it will probably be more efficient than the following option.
519+-- so will probably be more efficient than the following two options:
572-- * The compiler can provide a default generic implementation for
521-- * The compiler can provide a default generic implementation for
573-- 'liftParseJSON'.
522-- 'liftParseJSON'.
@@ -585,20 +534,16 @@ typeOf v = case v of
586-- data Pair a b = Pair { pairFst :: a, pairSnd :: b } deriving 'Generic1'
535-- data Pair a b = Pair { pairFst :: a, pairSnd :: b } deriving 'Generic1'
588−-- instance 'FromJSON' a => 'FromJSON1' (Pair a)
537+-- instance FromJSON a => FromJSON1 (Pair a)
591−-- If the default implementation doesn't give exactly the results you want,
540+-- If @DefaultSignatures@ doesn't give exactly the results you want,
592-- you can customize the generic decoding with only a tiny amount of
541-- you can customize the generic decoding with only a tiny amount of
593-- effort, using 'genericLiftParseJSON' with your preferred 'Options':
542-- effort, using 'genericLiftParseJSON' with your preferred 'Options':
596−-- customOptions = 'defaultOptions'
597−-- { 'fieldLabelModifier' = 'map' 'Data.Char.toUpper'
600−-- instance 'FromJSON' a => 'FromJSON1' (Pair a) where
545+-- instance FromJSON a => FromJSON1 (Pair a) where
601−-- 'liftParseJSON' = 'genericLiftParseJSON' customOptions
546+-- liftParseJSON = 'genericLiftParseJSON' 'defaultOptions'
603class FromJSON1 f where
548class FromJSON1 f where
604 liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a)
549 liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a)
@@ -635,8 +580,9 @@ class FromJSON2 f where
635 -> (Value -> Parser b)
580 -> (Value -> Parser b)
636 -> (Value -> Parser [b])
581 -> (Value -> Parser [b])
637 -> Value -> Parser [f a b]
582 -> Value -> Parser [f a b]
638− liftParseJSONList2 fa ga fb gb = withArray "[]" $ \vals ->
583+ liftParseJSONList2 fa ga fb gb v = case v of
639− fmap V.toList (V.mapM (liftParseJSON2 fa ga fb gb) vals)
584+ Array vals -> fmap V.toList (V.mapM (liftParseJSON2 fa ga fb gb) vals)
585+ _ -> typeMismatch "[a]" v
641-- | Lift the standard 'parseJSON' function through the type constructor.
587-- | Lift the standard 'parseJSON' function through the type constructor.
642parseJSON2 :: (FromJSON2 f, FromJSON a, FromJSON b) => Value -> Parser (f a b)
588parseJSON2 :: (FromJSON2 f, FromJSON a, FromJSON b) => Value -> Parser (f a b)
@@ -650,7 +596,7 @@ parseJSON2 = liftParseJSON2 parseJSON parseJSONList parseJSON parseJSONList
650-- | Helper function to use with 'liftParseJSON'. See 'Data.Aeson.ToJSON.listEncoding'.
596-- | Helper function to use with 'liftParseJSON'. See 'Data.Aeson.ToJSON.listEncoding'.
651listParser :: (Value -> Parser a) -> Value -> Parser [a]
597listParser :: (Value -> Parser a) -> Value -> Parser [a]
652listParser f (Array xs) = fmap V.toList (V.mapM f xs)
598listParser f (Array xs) = fmap V.toList (V.mapM f xs)
653−listParser _ v = typeMismatch "Array" v
599+listParser _ v = typeMismatch "[a]" v
654{-# INLINE listParser #-}
600{-# INLINE listParser #-}
656-------------------------------------------------------------------------------
602-------------------------------------------------------------------------------
@@ -668,139 +614,48 @@ instance (FromJSON a) => FromJSON [a] where
668-- Functions
614-- Functions
669-------------------------------------------------------------------------------
615-------------------------------------------------------------------------------
671−-- | Add context to a failure message, indicating the name of the structure
674−-- > prependContext "MyType" (fail "[error message]")
675−-- > -- Error: "parsing MyType failed, [error message]"
676−prependContext :: String -> Parser a -> Parser a
677−prependContext name = prependFailure ("parsing " ++ name ++ " failed, ")
679−-- | @'withObject' name f value@ applies @f@ to the 'Object' when @value@
617+-- | @withObject expected f value@ applies @f@ to the 'Object' when @value@ is an @Object@
680−-- is an 'Data.Aeson.Object' and fails otherwise.
618+-- and fails using @'typeMismatch' expected@ otherwise.
682−-- ==== Error message example
684−-- > withObject "MyType" f (String "oops")
685−-- > -- Error: "parsing MyType failed, expected Object, but encountered String"
686withObject :: String -> (Object -> Parser a) -> Value -> Parser a
619withObject :: String -> (Object -> Parser a) -> Value -> Parser a
687−withObject _ f (Object obj) = f obj
620+withObject _ f (Object obj) = f obj
688−withObject name _ v = prependContext name (typeMismatch "Object" v)
621+withObject expected _ v = typeMismatch expected v
689{-# INLINE withObject #-}
622{-# INLINE withObject #-}
691−-- | @'withText' name f value@ applies @f@ to the 'Text' when @value@ is a
624+-- | @withText expected f value@ applies @f@ to the 'Text' when @value@ is a @String@
692−-- 'Data.Aeson.String' and fails otherwise.
625+-- and fails using @'typeMismatch' expected@ otherwise.
694−-- ==== Error message example
696−-- > withText "MyType" f Null
697−-- > -- Error: "parsing MyType failed, expected String, but encountered Null"
698withText :: String -> (Text -> Parser a) -> Value -> Parser a
626withText :: String -> (Text -> Parser a) -> Value -> Parser a
699−withText _ f (String txt) = f txt
627+withText _ f (String txt) = f txt
700−withText name _ v = prependContext name (typeMismatch "String" v)
628+withText expected _ v = typeMismatch expected v
701{-# INLINE withText #-}
629{-# INLINE withText #-}
703−-- | @'withArray' expected f value@ applies @f@ to the 'Array' when @value@ is
631+-- | @withArray expected f value@ applies @f@ to the 'Array' when @value@ is an @Array@
704−-- an 'Data.Aeson.Array' and fails otherwise.
632+-- and fails using @'typeMismatch' expected@ otherwise.
706−-- ==== Error message example
708−-- > withArray "MyType" f (String "oops")
709−-- > -- Error: "parsing MyType failed, expected Array, but encountered String"
710withArray :: String -> (Array -> Parser a) -> Value -> Parser a
633withArray :: String -> (Array -> Parser a) -> Value -> Parser a
711−withArray _ f (Array arr) = f arr
634+withArray _ f (Array arr) = f arr
712−withArray name _ v = prependContext name (typeMismatch "Array" v)
635+withArray expected _ v = typeMismatch expected v
713{-# INLINE withArray #-}
636{-# INLINE withArray #-}
638+-- | @withNumber expected f value@ applies @f@ to the 'Number' when @value@ is a 'Number'.
639+-- and fails using @'typeMismatch' expected@ otherwise.
640+withNumber :: String -> (Number -> Parser a) -> Value -> Parser a
641+withNumber expected f = withScientific expected (f . scientificToNumber)
642+{-# INLINE withNumber #-}
643+{-# DEPRECATED withNumber "Use withScientific instead" #-}
715−-- | @'withScientific' name f value@ applies @f@ to the 'Scientific' number
645+-- | @withScientific expected f value@ applies @f@ to the 'Scientific' number when @value@ is a 'Number'.
716−-- when @value@ is a 'Data.Aeson.Number' and fails using 'typeMismatch'
646+-- and fails using @'typeMismatch' expected@ otherwise.
719−-- /Warning/: If you are converting from a scientific to an unbounded
720−-- type such as 'Integer' you may want to add a restriction on the
721−-- size of the exponent (see 'withBoundedScientific') to prevent
722−-- malicious input from filling up the memory of the target system.
724−-- ==== Error message example
726−-- > withScientific "MyType" f (String "oops")
727−-- > -- Error: "parsing MyType failed, expected Number, but encountered String"
728withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
647withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
729−withScientific _ f (Number scientific) = f scientific
648+withScientific _ f (Number scientific) = f scientific
730−withScientific name _ v = prependContext name (typeMismatch "Number" v)
649+withScientific expected _ v = typeMismatch expected v
731{-# INLINE withScientific #-}
650{-# INLINE withScientific #-}
733−-- | A variant of 'withScientific' which doesn't use 'prependContext', so that
652+-- | @withBool expected f value@ applies @f@ to the 'Bool' when @value@ is a @Bool@
734−-- such context can be added separately in a way that also applies when the
735−-- continuation @f :: Scientific -> Parser a@ fails.
737−-- /Warning/: If you are converting from a scientific to an unbounded
738−-- type such as 'Integer' you may want to add a restriction on the
739−-- size of the exponent (see 'withBoundedScientific') to prevent
740−-- malicious input from filling up the memory of the target system.
742−-- ==== Error message examples
744−-- > withScientific' f (String "oops")
745−-- > -- Error: "unexpected String"
747−-- > prependContext "MyType" (withScientific' f (String "oops"))
748−-- > -- Error: "parsing MyType failed, unexpected String"
749−withScientific' :: (Scientific -> Parser a) -> Value -> Parser a
750−withScientific' f v = case v of
752− _ -> typeMismatch "Number" v
753−{-# INLINE withScientific' #-}
755−-- | @'withBoundedScientific' name f value@ applies @f@ to the 'Scientific' number
756−-- when @value@ is a 'Number' with exponent less than or equal to 1024.
757−withBoundedScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
758−withBoundedScientific name f v = withBoundedScientific_ (prependContext name) f v
759−{-# INLINE withBoundedScientific #-}
761−-- | A variant of 'withBoundedScientific' which doesn't use 'prependContext',
762−-- so that such context can be added separately in a way that also applies
763−-- when the continuation @f :: Scientific -> Parser a@ fails.
764−withBoundedScientific' :: (Scientific -> Parser a) -> Value -> Parser a
765−withBoundedScientific' f v = withBoundedScientific_ id f v
766−{-# INLINE withBoundedScientific' #-}
768−-- | A variant of 'withBoundedScientific_' parameterized by a function to apply
769−-- to the 'Parser' in case of failure.
770−withBoundedScientific_ :: (Parser a -> Parser a) -> (Scientific -> Parser a) -> Value -> Parser a
771−withBoundedScientific_ whenFail f (Number scientific) =
773− then whenFail (fail msg)
776− exp10 = base10Exponent scientific
777− msg = "found a number with exponent " ++ show exp10 ++ ", but it must not be greater than 1024"
778−withBoundedScientific_ whenFail _ v =
779− whenFail (typeMismatch "Number" v)
780−{-# INLINE withBoundedScientific_ #-}
782−-- | @'withBool' expected f value@ applies @f@ to the 'Bool' when @value@ is a
783−-- 'Boolean' and fails otherwise.
653+-- and fails using @'typeMismatch' expected@ otherwise.
785−-- ==== Error message example
787−-- > withBool "MyType" f (String "oops")
788−-- > -- Error: "parsing MyType failed, expected Boolean, but encountered String"
789withBool :: String -> (Bool -> Parser a) -> Value -> Parser a
654withBool :: String -> (Bool -> Parser a) -> Value -> Parser a
790−withBool _ f (Bool arr) = f arr
655+withBool _ f (Bool arr) = f arr
791−withBool name _ v = prependContext name (typeMismatch "Boolean" v)
656+withBool expected _ v = typeMismatch expected v
792{-# INLINE withBool #-}
657{-# INLINE withBool #-}
794−-- | Decode a nested JSON-encoded string.
795−withEmbeddedJSON :: String -> (Value -> Parser a) -> Value -> Parser a
796−withEmbeddedJSON _ innerParser (String txt) =
797− either fail innerParser $ eitherDecode (L.fromStrict $ T.encodeUtf8 txt)
799− eitherDecode = eitherFormatError . eitherDecodeWith jsonEOF ifromJSON
800− eitherFormatError = either (Left . uncurry formatError) Right
801−withEmbeddedJSON name _ v = prependContext name (typeMismatch "String" v)
802−{-# INLINE withEmbeddedJSON #-}
804-- | Convert a value from JSON, failing if the types do not match.
659-- | Convert a value from JSON, failing if the types do not match.
805fromJSON :: (FromJSON a) => Value -> Result a
660fromJSON :: (FromJSON a) => Value -> Result a
806fromJSON = parse parseJSON
661fromJSON = parse parseJSON
@@ -863,7 +718,7 @@ parseFieldMaybe' = (.:!)
863-- E.g. @'explicitParseField' 'parseJSON1' :: ('FromJSON1' f, 'FromJSON' a) -> 'Object' -> 'Text' -> 'Parser' (f a)@
718-- E.g. @'explicitParseField' 'parseJSON1' :: ('FromJSON1' f, 'FromJSON' a) -> 'Object' -> 'Text' -> 'Parser' (f a)@
864explicitParseField :: (Value -> Parser a) -> Object -> Text -> Parser a
719explicitParseField :: (Value -> Parser a) -> Object -> Text -> Parser a
865explicitParseField p obj key = case H.lookup key obj of
720explicitParseField p obj key = case H.lookup key obj of
866− Nothing -> fail $ "key " ++ show key ++ " not found"
721+ Nothing -> fail $ "key " ++ show key ++ " not present"
867 Just v -> p v <?> Key key
722 Just v -> p v <?> Key key
868{-# INLINE explicitParseField #-}
723{-# INLINE explicitParseField #-}
@@ -903,47 +758,11 @@ pmval .!= val = fromMaybe val <$> pmval
903-- Generic parseJSON
758-- Generic parseJSON
904-------------------------------------------------------------------------------
759-------------------------------------------------------------------------------
906−instance GFromJSON arity V1 where
907− -- Whereof we cannot format, thereof we cannot parse:
908− gParseJSON _ _ _ = fail "Attempted to parse empty type"
911instance OVERLAPPABLE_ (GFromJSON arity a) => GFromJSON arity (M1 i c a) where
761instance OVERLAPPABLE_ (GFromJSON arity a) => GFromJSON arity (M1 i c a) where
912 -- Meta-information, which is not handled elsewhere, is just added to the
762 -- Meta-information, which is not handled elsewhere, is just added to the
913 -- parsed value:
763 -- parsed value:
914 gParseJSON opts fargs = fmap M1 . gParseJSON opts fargs
764 gParseJSON opts fargs = fmap M1 . gParseJSON opts fargs
916−-- Information for error messages
918−type TypeName = String
919−type ConName = String
921−-- | Add the name of the type being parsed to a parser's error messages.
922−contextType :: TypeName -> Parser a -> Parser a
923−contextType = prependContext
925−-- | Add the tagKey that will be looked up while building an ADT
926−-- | Produce the error equivalent to
927−-- | Left "Error in $: parsing T failed, expected an object with keys "tag" and
928−-- | "contents", where "tag" i-- |s associated to one of ["Foo", "Bar"],
929−-- | The parser returned error was: could not find key "tag"
930−contextTag :: Text -> [String] -> Parser a -> Parser a
931−contextTag tagKey cnames = prependFailure
932− ("expected Object with key \"" ++ unpack tagKey ++ "\"" ++
933− " containing one of " ++ show cnames ++ ", ")
935−-- | Add the name of the constructor being parsed to a parser's error messages.
936−contextCons :: ConName -> TypeName -> Parser a -> Parser a
937−contextCons cname tname = prependContext (showCons cname tname)
939−-- | Render a constructor as @\"MyType(MyConstructor)\"@.
940−showCons :: ConName -> TypeName -> String
941−showCons cname tname = tname ++ "(" ++ cname ++ ")"
943−--------------------------------------------------------------------------------
945−-- Parsing single fields
947instance (FromJSON a) => GFromJSON arity (K1 i a) where
766instance (FromJSON a) => GFromJSON arity (K1 i a) where
948 -- Constant values are decoded using their FromJSON instance:
767 -- Constant values are decoded using their FromJSON instance:
949 gParseJSON _opts _ = fmap K1 . parseJSON
768 gParseJSON _opts _ = fmap K1 . parseJSON
@@ -958,499 +777,326 @@ instance (FromJSON1 f) => GFromJSON One (Rec1 f) where
958 -- FromJSON1 instance:
777 -- FromJSON1 instance:
959 gParseJSON _opts (From1Args pj pjl) = fmap Rec1 . liftParseJSON pj pjl
778 gParseJSON _opts (From1Args pj pjl) = fmap Rec1 . liftParseJSON pj pjl
780+instance GFromJSON arity U1 where
781+ -- Empty constructors are expected to be encoded as an empty array:
782+ gParseJSON _opts _ v
783+ | isEmptyArray v = pure U1
784+ | otherwise = typeMismatch "unit constructor (U1)" v
786+instance (ConsFromJSON arity a) => GFromJSON arity (C1 c a) where
787+ -- Constructors need to be decoded differently depending on whether they're
788+ -- a record or not. This distinction is made by consParseJSON:
789+ gParseJSON opts fargs = fmap M1 . consParseJSON opts fargs
791+instance ( FromProduct arity a, FromProduct arity b
792+ , ProductSize a, ProductSize b
793+ ) => GFromJSON arity (a :*: b) where
794+ -- Products are expected to be encoded to an array. Here we check whether we
795+ -- got an array of the same size as the product, then parse each of the
796+ -- product's elements using parseProduct:
797+ gParseJSON opts fargs = withArray "product (:*:)" $ \arr ->
798+ let lenArray = V.length arr
799+ lenProduct = (unTagged2 :: Tagged2 (a :*: b) Int -> Int)
801+ if lenArray == lenProduct
802+ then parseProduct opts fargs arr 0 lenProduct
803+ else fail $ "When expecting a product of " ++ show lenProduct ++
804+ " values, encountered an Array of " ++ show lenArray ++
807+instance ( AllNullary (a :+: b) allNullary
808+ , ParseSum arity (a :+: b) allNullary
809+ ) => GFromJSON arity (a :+: b) where
810+ -- If all constructors of a sum datatype are nullary and the
811+ -- 'allNullaryToStringTag' option is set they are expected to be
812+ -- encoded as strings. This distinction is made by 'parseSum':
813+ gParseJSON opts fargs =
814+ (unTagged :: Tagged allNullary (Parser ((a :+: b) d)) ->
815+ Parser ((a :+: b) d))
816+ . parseSum opts fargs
961instance (FromJSON1 f, GFromJSON One g) => GFromJSON One (f :.: g) where
818instance (FromJSON1 f, GFromJSON One g) => GFromJSON One (f :.: g) where
962 -- If an occurrence of the last type parameter is nested inside two
819 -- If an occurrence of the last type parameter is nested inside two
963 -- composed types, it is decoded by using the outermost type's FromJSON1
820 -- composed types, it is decoded by using the outermost type's FromJSON1
964 -- instance to generically decode the innermost type:
821 -- instance to generically decode the innermost type:
965 gParseJSON opts fargs =
822 gParseJSON opts fargs =
966− let gpj = gParseJSON opts fargs in
823+ let gpj = gParseJSON opts fargs in
967− fmap Comp1 . liftParseJSON gpj (listParser gpj)
824+ fmap Comp1 . liftParseJSON gpj (listParser gpj)
969−--------------------------------------------------------------------------------
971−instance (GFromJSON' arity a, Datatype d) => GFromJSON arity (D1 d a) where
972− -- Meta-information, which is not handled elsewhere, is just added to the
974− gParseJSON opts fargs = fmap M1 . gParseJSON' (tname :* opts :* fargs)
976− tname = moduleName proxy ++ "." ++ datatypeName proxy
977− proxy = undefined :: M1 _i d _f _p
979−-- | 'GFromJSON', after unwrapping the 'D1' constructor, now carrying the data
981−class GFromJSON' arity f where
982− gParseJSON' :: TypeName :* Options :* FromArgs arity a
986−-- | Single constructor.
987−instance ( ConsFromJSON arity a
988− , AllNullary (C1 c a) allNullary
989− , ParseSum arity (C1 c a) allNullary
991− ) => GFromJSON' arity (C1 c a) where
992− -- The option 'tagSingleConstructors' determines whether to wrap
993− -- a single-constructor type.
994− gParseJSON' p@(_ :* opts :* _)
995− | tagSingleConstructors opts
996− = (unTagged :: Tagged allNullary (Parser (C1 c a p)) -> Parser (C1 c a p))
998− | otherwise = fmap M1 . consParseJSON (cname :* p)
1000− cname = conName (undefined :: M1 _i c _f _p)
1002−-- | Multiple constructors.
1003−instance ( AllNullary (a :+: b) allNullary
1004− , ParseSum arity (a :+: b) allNullary
1005− ) => GFromJSON' arity (a :+: b) where
1006− -- If all constructors of a sum datatype are nullary and the
1007− -- 'allNullaryToStringTag' option is set they are expected to be
1008− -- encoded as strings. This distinction is made by 'parseSum':
1010− (unTagged :: Tagged allNullary (Parser ((a :+: b) _d)) ->
1011− Parser ((a :+: b) _d))
1014--------------------------------------------------------------------------------
826--------------------------------------------------------------------------------
1016class ParseSum arity f allNullary where
828class ParseSum arity f allNullary where
1017− parseSum :: TypeName :* Options :* FromArgs arity a
829+ parseSum :: Options -> FromArgs arity a
1019− -> Tagged allNullary (Parser (f a))
830+ -> Value -> Tagged allNullary (Parser (f a))
1021−instance ( ConstructorNames f
1022− , SumFromString f
832+instance ( SumFromString (a :+: b)
1023− , FromPair arity f
833+ , FromPair arity (a :+: b)
1024− , FromTaggedObject arity f
834+ , FromTaggedObject arity (a :+: b)
1025− , FromUntaggedValue arity f
835+ , FromUntaggedValue arity (a :+: b)
1026− ) => ParseSum arity f True where
836+ ) => ParseSum arity (a :+: b) True where
1027− parseSum p@(tname :* opts :* _)
837+ parseSum opts fargs
1028− | allNullaryToStringTag opts = Tagged . parseAllNullarySum tname opts
838+ | allNullaryToStringTag opts = Tagged . parseAllNullarySum opts
1029− | otherwise = Tagged . parseNonAllNullarySum p
839+ | otherwise = Tagged . parseNonAllNullarySum opts fargs
1031−instance ( ConstructorNames f
1032− , FromPair arity f
841+instance ( FromPair arity (a :+: b)
1033− , FromTaggedObject arity f
842+ , FromTaggedObject arity (a :+: b)
1034− , FromUntaggedValue arity f
843+ , FromUntaggedValue arity (a :+: b)
1035− ) => ParseSum arity f False where
844+ ) => ParseSum arity (a :+: b) False where
1036− parseSum p = Tagged . parseNonAllNullarySum p
845+ parseSum opts fargs = Tagged . parseNonAllNullarySum opts fargs
1038--------------------------------------------------------------------------------
847--------------------------------------------------------------------------------
1040−parseAllNullarySum :: (SumFromString f, ConstructorNames f)
849+parseAllNullarySum :: SumFromString f => Options -> Value -> Parser (f a)
1041− => TypeName -> Options -> Value -> Parser (f a)
1042−parseAllNullarySum tname opts =
850+parseAllNullarySum opts = withText "Text" $ \key ->
1043− withText tname $ \tag ->
1044− maybe (badTag tag) return $
851+ maybe (notFound key) return $
1045− parseSumFromString modifier tag
852+ parseSumFromString opts key
1047− badTag tag = failWithCTags tname modifier $ \cnames ->
1048− "expected one of the tags " ++ show cnames ++
1049− ", but found tag " ++ show tag
1050− modifier = constructorTagModifier opts
1052−-- | Fail with an informative error message about a mismatched tag.
1053−-- The error message is parameterized by the list of expected tags,
1054−-- to be inferred from the result type of the parser.
1056− :: forall f a t. ConstructorNames f
1057− => TypeName -> (String -> t) -> ([t] -> String) -> Parser (f a)
1058−failWithCTags tname modifier f =
1059− contextType tname . fail $ f cnames
1061− cnames = unTagged2 (constructorTags modifier :: Tagged2 f [t])
1063class SumFromString f where
854class SumFromString f where
1064− parseSumFromString :: (String -> String) -> Text -> Maybe (f a)
855+ parseSumFromString :: Options -> Text -> Maybe (f a)
1066instance (SumFromString a, SumFromString b) => SumFromString (a :+: b) where
857instance (SumFromString a, SumFromString b) => SumFromString (a :+: b) where
1067 parseSumFromString opts key = (L1 <$> parseSumFromString opts key) <|>
858 parseSumFromString opts key = (L1 <$> parseSumFromString opts key) <|>
1068 (R1 <$> parseSumFromString opts key)
859 (R1 <$> parseSumFromString opts key)
1070instance (Constructor c) => SumFromString (C1 c U1) where
861instance (Constructor c) => SumFromString (C1 c U1) where
1071− parseSumFromString modifier key
862+ parseSumFromString opts key | key == name = Just $ M1 U1
1072− | key == name = Just $ M1 U1
1073− | otherwise = Nothing
863+ | otherwise = Nothing
1075− name = pack $ modifier $ conName (undefined :: M1 _i c _f _p)
865+ name = pack $ constructorTagModifier opts $
1077−-- For genericFromJSONKey
1078−instance SumFromString a => SumFromString (D1 d a) where
1079− parseSumFromString modifier key = M1 <$> parseSumFromString modifier key
1081−-- | List of all constructor tags.
1082−constructorTags :: ConstructorNames a => (String -> t) -> Tagged2 a [t]
1083−constructorTags modifier =
1084− fmap DList.toList (constructorNames' modifier)
1086−-- | List of all constructor names of an ADT, after a given conversion
1087−-- function. (Better inlining.)
1088−class ConstructorNames a where
1089− constructorNames' :: (String -> t) -> Tagged2 a (DList.DList t)
1091−instance (ConstructorNames a, ConstructorNames b) => ConstructorNames (a :+: b) where
1092− constructorNames' = liftA2 append constructorNames' constructorNames'
1095− :: Tagged2 a (DList.DList t)
1096− -> Tagged2 b (DList.DList t)
1097− -> Tagged2 (a :+: b) (DList.DList t)
1098− append (Tagged2 xs) (Tagged2 ys) = Tagged2 (DList.append xs ys)
1100−instance Constructor c => ConstructorNames (C1 c a) where
1101− constructorNames' f = Tagged2 (pure (f cname))
1103− cname = conName (undefined :: M1 _i c _f _p)
866+ conName (undefined :: t c U1 p)
1105−-- For genericFromJSONKey
1106−instance ConstructorNames a => ConstructorNames (D1 d a) where
1107− constructorNames' = retag . constructorNames'
1109− retag :: Tagged2 a u -> Tagged2 (D1 d a) u
1110− retag (Tagged2 x) = Tagged2 x
1112--------------------------------------------------------------------------------
868--------------------------------------------------------------------------------
1113−parseNonAllNullarySum :: forall f c arity.
870+parseNonAllNullarySum :: ( FromPair arity (a :+: b)
1115− , FromTaggedObject arity f
871+ , FromTaggedObject arity (a :+: b)
1116− , FromUntaggedValue arity f
872+ , FromUntaggedValue arity (a :+: b)
1117− , ConstructorNames f
1118− ) => TypeName :* Options :* FromArgs arity c
873+ ) => Options -> FromArgs arity c
1119− -> Value -> Parser (f c)
874+ -> Value -> Parser ((a :+: b) c)
1120−parseNonAllNullarySum p@(tname :* opts :* _) =
875+parseNonAllNullarySum opts fargs =
1121 case sumEncoding opts of
876 case sumEncoding opts of
1122 TaggedObject{..} ->
877 TaggedObject{..} ->
1123− withObject tname $ \obj -> do
878+ withObject "Object" $ \obj -> do
1124− tag <- contextType tname . contextTag tagKey cnames_ $ obj .: tagKey
1125− fromMaybe (badTag tag <?> Key tagKey) $
1126− parseFromTaggedObject (tag :* contentsFieldName :* p) obj
1128− tagKey = pack tagFieldName
879+ tag <- obj .: pack tagFieldName
1129− badTag tag = failWith_ $ \cnames ->
880+ fromMaybe (notFound tag) $
1130− "expected tag field to be one of " ++ show cnames ++
881+ parseFromTaggedObject opts fargs contentsFieldName obj tag
1131− ", but found tag " ++ show tag
1132− cnames_ = unTagged2 (constructorTags (constructorTagModifier opts) :: Tagged2 f [String])
1134 ObjectWithSingleField ->
883 ObjectWithSingleField ->
884+ withObject "Object" $ \obj ->
1135− withObject tname $ \obj -> case H.toList obj of
885+ case H.toList obj of
1136− [(tag, v)] -> maybe (badTag tag) (<?> Key tag) $
886+ [pair@(tag, _)] -> fromMaybe (notFound tag) $
1137− parsePair (tag :* p) v
887+ parsePair opts fargs pair
1138− _ -> contextType tname . fail $
888+ _ -> fail "Object doesn't have a single field"
1139− "expected an Object with a single pair, but found " ++
1140− show (H.size obj) ++ " pairs"
1142− badTag tag = failWith_ $ \cnames ->
1143− "expected an Object with a single pair where the tag is one of " ++
1144− show cnames ++ ", but found tag " ++ show tag
1146 TwoElemArray ->
890 TwoElemArray ->
1147− withArray tname $ \arr -> case V.length arr of
891+ withArray "Array" $ \arr ->
892+ if V.length arr == 2
1148− 2 | String tag <- V.unsafeIndex arr 0 ->
893+ then case V.unsafeIndex arr 0 of
1149− maybe (badTag tag <?> Index 0) (<?> Index 1) $
894+ String tag -> fromMaybe (notFound tag) $
1150− parsePair (tag :* p) (V.unsafeIndex arr 1)
895+ parsePair opts fargs (tag, V.unsafeIndex arr 1)
1152− contextType tname $
1153− fail "tag element is not a String" <?> Index 0
896+ _ -> fail "First element is not a String"
1154− len -> contextType tname . fail $
897+ else fail "Array doesn't have 2 elements"
1155− "expected a 2-element Array, but encountered an Array of length " ++
1158− badTag tag = failWith_ $ \cnames ->
1159− "expected tag of the 2-element Array to be one of " ++
1160− show cnames ++ ", but found tag " ++ show tag
1162− UntaggedValue -> parseUntaggedValue p
899+ UntaggedValue -> parseUntaggedValue opts fargs
1164− failWith_ = failWithCTags tname (constructorTagModifier opts)
1166--------------------------------------------------------------------------------
901--------------------------------------------------------------------------------
1168class FromTaggedObject arity f where
903class FromTaggedObject arity f where
1169− -- The first two components of the parameter tuple are: the constructor tag
1170− -- to match against, and the contents field name.
1171− parseFromTaggedObject
904+ parseFromTaggedObject :: Options -> FromArgs arity a
1172− :: Text :* String :* TypeName :* Options :* FromArgs arity a
1173− -> Object
905+ -> String -> Object
1174− -> Maybe (Parser (f a))
906+ -> Text -> Maybe (Parser (f a))
1176instance ( FromTaggedObject arity a, FromTaggedObject arity b) =>
908instance ( FromTaggedObject arity a, FromTaggedObject arity b) =>
1177 FromTaggedObject arity (a :+: b) where
909 FromTaggedObject arity (a :+: b) where
1178− parseFromTaggedObject p obj =
910+ parseFromTaggedObject opts fargs contentsFieldName obj tag =
1179− (fmap L1 <$> parseFromTaggedObject p obj) <|>
911+ (fmap L1 <$> parseFromTaggedObject opts fargs contentsFieldName obj tag) <|>
1180− (fmap R1 <$> parseFromTaggedObject p obj)
912+ (fmap R1 <$> parseFromTaggedObject opts fargs contentsFieldName obj tag)
1182−instance ( IsRecord f isRecord
1183− , FromTaggedObject' arity f isRecord
914+instance ( FromTaggedObject' arity f
1184 , Constructor c
915 , Constructor c
1185 ) => FromTaggedObject arity (C1 c f) where
916 ) => FromTaggedObject arity (C1 c f) where
1186− parseFromTaggedObject (tag :* contentsFieldName :* p@(_ :* opts :* _))
917+ parseFromTaggedObject opts fargs contentsFieldName obj tag
1189− (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a)) .
1190− parseFromTaggedObject' (contentsFieldName :* cname :* p)
918+ | tag == name = Just $ M1 <$> parseFromTaggedObject'
919+ opts fargs contentsFieldName obj
1191− | otherwise = const Nothing
920+ | otherwise = Nothing
1193− tag' = pack $ constructorTagModifier opts cname
922+ name = pack $ constructorTagModifier opts $
1194− cname = conName (undefined :: M1 _i c _f _p)
923+ conName (undefined :: t c f p)
1196--------------------------------------------------------------------------------
925--------------------------------------------------------------------------------
1198−class FromTaggedObject' arity f isRecord where
927+class FromTaggedObject' arity f where
1199− -- The first component of the parameter tuple is the contents field name.
928+ parseFromTaggedObject' :: Options -> FromArgs arity a -> String
1200− parseFromTaggedObject'
929+ -> Object -> Parser (f a)
931+class FromTaggedObject'' arity f isRecord where
1201− :: String :* ConName :* TypeName :* Options :* FromArgs arity a
932+ parseFromTaggedObject'' :: Options -> FromArgs arity a -> String
1202− -> Object -> Tagged isRecord (Parser (f a))
933+ -> Object -> Tagged isRecord (Parser (f a))
935+instance ( IsRecord f isRecord
1204−instance (RecordFromJSON arity f, FieldNames f) => FromTaggedObject' arity f True where
936+ , FromTaggedObject'' arity f isRecord
1205− -- Records are unpacked in the tagged object
1206− parseFromTaggedObject' (_ :* p) = Tagged . recordParseJSON (True :* p)
1208−instance (ConsFromJSON arity f) => FromTaggedObject' arity f False where
937+ ) => FromTaggedObject' arity f where
1209− -- Nonnullary nonrecords are encoded in the contents field
1210− parseFromTaggedObject' p obj = Tagged $ do
938+ parseFromTaggedObject' opts fargs contentsFieldName =
1211− contents <- contextCons cname tname (obj .: key)
939+ (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a)) .
1212− consParseJSON p' contents <?> Key key
940+ parseFromTaggedObject'' opts fargs contentsFieldName
1214− key = pack contentsFieldName
1215− contentsFieldName :* p'@(cname :* tname :* _) = p
942+instance (FromRecord arity f) => FromTaggedObject'' arity f True where
943+ parseFromTaggedObject'' opts fargs _ =
944+ Tagged . parseRecord opts fargs Nothing
946+instance (GFromJSON arity f) => FromTaggedObject'' arity f False where
947+ parseFromTaggedObject'' opts fargs contentsFieldName = Tagged .
948+ (gParseJSON opts fargs <=< (.: pack contentsFieldName))
1217−instance OVERLAPPING_ FromTaggedObject' arity U1 False where
950+instance OVERLAPPING_ FromTaggedObject'' arity U1 False where
1218− -- Nullary constructors don't need a contents field
951+ parseFromTaggedObject'' _ _ _ _ = Tagged (pure U1)
1219− parseFromTaggedObject' _ _ = Tagged (pure U1)
1221--------------------------------------------------------------------------------
953--------------------------------------------------------------------------------
1223−-- | Constructors need to be decoded differently depending on whether they're
1224−-- a record or not. This distinction is made by 'ConsParseJSON'.
1225class ConsFromJSON arity f where
955class ConsFromJSON arity f where
1227− :: ConName :* TypeName :* Options :* FromArgs arity a
956+ consParseJSON :: Options -> FromArgs arity a
1228− -> Value -> Parser (f a)
957+ -> Value -> Parser (f a)
1230class ConsFromJSON' arity f isRecord where
959class ConsFromJSON' arity f isRecord where
1232− :: ConName :* TypeName :* Options :* FromArgs arity a
960+ consParseJSON' :: Options -> FromArgs arity a
961+ -> Maybe Text -- ^ A dummy label
962+ -- (Nothing to use proper label)
1233− -> Value -> Tagged isRecord (Parser (f a))
963+ -> Value -> Tagged isRecord (Parser (f a))
1235instance ( IsRecord f isRecord
965instance ( IsRecord f isRecord
1236 , ConsFromJSON' arity f isRecord
966 , ConsFromJSON' arity f isRecord
1237 ) => ConsFromJSON arity f where
967 ) => ConsFromJSON arity f where
1238− consParseJSON p =
968+ consParseJSON opts fargs v = let
969+ (v2,lab) = case (unwrapUnaryRecords opts,isUnary (undefined :: f a)) of
970+ -- use a dummy object with a dummy label
971+ (True,True) -> (object [(pack "dummy",v)], Just $ pack "dummy")
1239− (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a))
973+ in (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a))
1242−instance OVERLAPPING_
1243− ( GFromJSON arity a, RecordFromJSON arity (S1 s a)
1244− ) => ConsFromJSON' arity (S1 s a) True where
1245− consParseJSON' p@(cname :* tname :* opts :* fargs)
974+ $ consParseJSON' opts fargs lab v2
1246− | unwrapUnaryRecords opts = Tagged . fmap M1 . gParseJSON opts fargs
1247− | otherwise = Tagged . withObject (showCons cname tname) (recordParseJSON (False :* p))
1249−instance RecordFromJSON arity f => ConsFromJSON' arity f True where
1250− consParseJSON' p@(cname :* tname :* _) =
1251− Tagged . withObject (showCons cname tname) (recordParseJSON (False :* p))
1253−instance OVERLAPPING_
1254− ConsFromJSON' arity U1 False where
1255− -- Empty constructors are expected to be encoded as an empty array:
1256− consParseJSON' (cname :* tname :* _) v =
1257− Tagged . contextCons cname tname $ case v of
1258− Array a | V.null a -> pure U1
1259− | otherwise -> fail_ a
1260− _ -> typeMismatch "Array" v
1263− "expected an empty Array, but encountered an Array of length " ++
1266−instance OVERLAPPING_
1267− GFromJSON arity f => ConsFromJSON' arity (S1 s f) False where
977+instance (FromRecord arity f) => ConsFromJSON' arity f True where
1268− consParseJSON' (_ :* _ :* opts :* fargs) =
978+ consParseJSON' opts fargs mlab = Tagged . withObject "record (:*:)"
1269− Tagged . fmap M1 . gParseJSON opts fargs
979+ (parseRecord opts fargs mlab)
1271−instance (ProductFromJSON arity f, ProductSize f
1272− ) => ConsFromJSON' arity f False where
981+instance (GFromJSON arity f) => ConsFromJSON' arity f False where
1273− consParseJSON' p = Tagged . productParseJSON0 p
982+ consParseJSON' opts fargs _ = Tagged . gParseJSON opts fargs
1275--------------------------------------------------------------------------------
984--------------------------------------------------------------------------------
1277−class FieldNames f where
986+class FromRecord arity f where
1278− fieldNames :: f a -> [Text] -> [Text]
987+ parseRecord :: Options -> FromArgs arity a
988+ -> Maybe Text -- ^ A dummy label
989+ -- (Nothing to use proper label)
990+ -> Object -> Parser (f a)
1280−instance (FieldNames a, FieldNames b) => FieldNames (a :*: b) where
992+instance ( FromRecord arity a
1281− fieldNames _ =
993+ , FromRecord arity b
1282− fieldNames (undefined :: a x) .
1283− fieldNames (undefined :: b y)
1285−instance (Selector s) => FieldNames (S1 s f) where
1286− fieldNames _ = (pack (selName (undefined :: M1 _i s _f _p)) :)
1288−class RecordFromJSON arity f where
1290− :: Bool :* ConName :* TypeName :* Options :* FromArgs arity a
1291− -> Object -> Parser (f a)
1293−instance ( FieldNames f
1294− , RecordFromJSON' arity f
1295− ) => RecordFromJSON arity f where
1296− recordParseJSON (fromTaggedSum :* p@(cname :* tname :* opts :* _)) =
1297− \obj -> checkUnknown obj >> recordParseJSON' p obj
1299− knownFields :: H.HashMap Text ()
1300− knownFields = H.fromList $ map (,()) $
1301− fieldNames (undefined :: f a)
1302− [pack (tagFieldName (sumEncoding opts)) | fromTaggedSum]
1304− if not (rejectUnknownFields opts)
1305− then \_ -> return ()
1306− else \obj -> case H.keys (H.difference obj knownFields) of
1308− unknownFields -> contextCons cname tname $
1309− fail ("unknown fields: " ++ show unknownFields)
1311−class RecordFromJSON' arity f where
1313− :: ConName :* TypeName :* Options :* FromArgs arity a
1314− -> Object -> Parser (f a)
1316−instance ( RecordFromJSON' arity a
1317− , RecordFromJSON' arity b
1318− ) => RecordFromJSON' arity (a :*: b) where
994+ ) => FromRecord arity (a :*: b) where
1319− recordParseJSON' p obj =
995+ parseRecord opts fargs _ obj =
1320− (:*:) <$> recordParseJSON' p obj
996+ (:*:) <$> parseRecord opts fargs Nothing obj
1321− <*> recordParseJSON' p obj
997+ <*> parseRecord opts fargs Nothing obj
1323instance OVERLAPPABLE_ (Selector s, GFromJSON arity a) =>
999instance OVERLAPPABLE_ (Selector s, GFromJSON arity a) =>
1324− RecordFromJSON' arity (S1 s a) where
1000+ FromRecord arity (S1 s a) where
1325− recordParseJSON' (cname :* tname :* opts :* fargs) obj = do
1001+ parseRecord opts fargs lab =
1326− fv <- contextCons cname tname (obj .: label)
1002+ (<?> Key label) . gParseJSON opts fargs <=< (.: label)
1327− M1 <$> gParseJSON opts fargs fv <?> Key label
1003+ where
1328− where
1004+ label = fromMaybe defLabel lab
1329− label = pack $ fieldLabelModifier opts sname
1330− sname = selName (undefined :: M1 _i s _f _p)
1332−instance INCOHERENT_ (Selector s, FromJSON a) =>
1333− RecordFromJSON' arity (S1 s (K1 i (Maybe a))) where
1334− recordParseJSON' (_ :* _ :* opts :* _) obj = M1 . K1 <$> obj .:? pack label
1336− label = fieldLabelModifier opts sname
1005+ defLabel = pack . fieldLabelModifier opts $
1337− sname = selName (undefined :: M1 _i s _f _p)
1006+ selName (undefined :: t s a p)
1339−-- Parse an Option like a Maybe.
1340instance INCOHERENT_ (Selector s, FromJSON a) =>
1008instance INCOHERENT_ (Selector s, FromJSON a) =>
1341− RecordFromJSON' arity (S1 s (K1 i (Semigroup.Option a))) where
1009+ FromRecord arity (S1 s (K1 i (Maybe a))) where
1342− recordParseJSON' p obj = wrap <$> recordParseJSON' p obj
1010+ parseRecord _ _ (Just lab) obj = (M1 . K1) <$> obj .:? lab
1011+ parseRecord opts _ Nothing obj = (M1 . K1) <$> obj .:? pack label
1344− wrap :: S1 s (K1 i (Maybe a)) p -> S1 s (K1 i (Semigroup.Option a)) p
1013+ label = fieldLabelModifier opts $
1345− wrap (M1 (K1 a)) = M1 (K1 (Semigroup.Option a))
1014+ selName (undefined :: t s (K1 i (Maybe a)) p)
1347--------------------------------------------------------------------------------
1016--------------------------------------------------------------------------------
1350− :: forall f arity a. (ProductFromJSON arity f, ProductSize f)
1351− => ConName :* TypeName :* Options :* FromArgs arity a
1352− -> Value -> Parser (f a)
1353− -- Products are expected to be encoded to an array. Here we check whether we
1354− -- got an array of the same size as the product, then parse each of the
1355− -- product's elements using productParseJSON:
1356−productParseJSON0 p@(cname :* tname :* _ :* _) =
1357− withArray (showCons cname tname) $ \arr ->
1358− let lenArray = V.length arr
1359− lenProduct = (unTagged2 :: Tagged2 f Int -> Int)
1361− if lenArray == lenProduct
1362− then productParseJSON p arr 0 lenProduct
1363− else contextCons cname tname $
1364− fail $ "expected an Array of length " ++ show lenProduct ++
1365− ", but encountered an Array of length " ++ show lenArray
1369−class ProductFromJSON arity f where
1018+class FromProduct arity f where
1370− productParseJSON :: ConName :* TypeName :* Options :* FromArgs arity a
1019+ parseProduct :: Options -> FromArgs arity a
1371 -> Array -> Int -> Int
1020 -> Array -> Int -> Int
1372 -> Parser (f a)
1021 -> Parser (f a)
1374−instance ( ProductFromJSON arity a
1023+instance ( FromProduct arity a
1375− , ProductFromJSON arity b
1024+ , FromProduct arity b
1376− ) => ProductFromJSON arity (a :*: b) where
1025+ ) => FromProduct arity (a :*: b) where
1377− productParseJSON p arr ix len =
1026+ parseProduct opts fargs arr ix len =
1378− (:*:) <$> productParseJSON p arr ix lenL
1027+ (:*:) <$> parseProduct opts fargs arr ix lenL
1379− <*> productParseJSON p arr ixR lenR
1028+ <*> parseProduct opts fargs arr ixR lenR
1381 lenL = len `unsafeShiftR` 1
1030 lenL = len `unsafeShiftR` 1
1382 ixR = ix + lenL
1031 ixR = ix + lenL
1383 lenR = len - lenL
1032 lenR = len - lenL
1385−instance (GFromJSON arity a) => ProductFromJSON arity (S1 s a) where
1034+instance (GFromJSON arity a) => FromProduct arity (S1 s a) where
1386− productParseJSON (_ :* _ :* opts :* fargs) arr ix _ =
1035+ parseProduct opts fargs arr ix _ =
1387− M1 <$> gParseJSON opts fargs (V.unsafeIndex arr ix) <?> Index ix
1036+ gParseJSON opts fargs $ V.unsafeIndex arr ix
1389--------------------------------------------------------------------------------
1038--------------------------------------------------------------------------------
1391class FromPair arity f where
1040class FromPair arity f where
1392− -- The first component of the parameter tuple is the tag to match.
1393− parsePair :: Text :* TypeName :* Options :* FromArgs arity a
1041+ parsePair :: Options -> FromArgs arity a
1395− -> Maybe (Parser (f a))
1042+ -> Pair -> Maybe (Parser (f a))
1397instance ( FromPair arity a
1044instance ( FromPair arity a
1398 , FromPair arity b
1045 , FromPair arity b
1399 ) => FromPair arity (a :+: b) where
1046 ) => FromPair arity (a :+: b) where
1401− (fmap L1 <$> parsePair p pair) <|>
1047+ parsePair opts fargs pair = (fmap L1 <$> parsePair opts fargs pair) <|>
1402− (fmap R1 <$> parsePair p pair)
1048+ (fmap R1 <$> parsePair opts fargs pair)
1404instance ( Constructor c
1050instance ( Constructor c
1051+ , GFromJSON arity a
1405 , ConsFromJSON arity a
1052 , ConsFromJSON arity a
1406 ) => FromPair arity (C1 c a) where
1053 ) => FromPair arity (C1 c a) where
1407− parsePair (tag :* p@(_ :* opts :* _)) v
1054+ parsePair opts fargs (tag, value)
1408− | tag == tag' = Just $ M1 <$> consParseJSON (cname :* p) v
1055+ | tag == tag' = Just $ gParseJSON opts fargs value
1409 | otherwise = Nothing
1056 | otherwise = Nothing
1411− tag' = pack $ constructorTagModifier opts cname
1058+ tag' = pack $ constructorTagModifier opts $
1412− cname = conName (undefined :: M1 _i c _a _p)
1059+ conName (undefined :: t c a p)
1414--------------------------------------------------------------------------------
1061--------------------------------------------------------------------------------
1416class FromUntaggedValue arity f where
1063class FromUntaggedValue arity f where
1417− parseUntaggedValue :: TypeName :* Options :* FromArgs arity a
1064+ parseUntaggedValue :: Options -> FromArgs arity a
1419− -> Parser (f a)
1065+ -> Value -> Parser (f a)
1422 ( FromUntaggedValue arity a
1068 ( FromUntaggedValue arity a
1423 , FromUntaggedValue arity b
1069 , FromUntaggedValue arity b
1424 ) => FromUntaggedValue arity (a :+: b)
1070 ) => FromUntaggedValue arity (a :+: b)
1426− parseUntaggedValue p value =
1072+ parseUntaggedValue opts fargs value =
1427− L1 <$> parseUntaggedValue p value <|>
1073+ L1 <$> parseUntaggedValue opts fargs value <|>
1428− R1 <$> parseUntaggedValue p value
1074+ R1 <$> parseUntaggedValue opts fargs value
1430instance OVERLAPPABLE_
1076instance OVERLAPPABLE_
1431− ( ConsFromJSON arity a
1077+ ( GFromJSON arity a
1432− , Constructor c
1078+ , ConsFromJSON arity a
1433 ) => FromUntaggedValue arity (C1 c a)
1079 ) => FromUntaggedValue arity (C1 c a)
1435− parseUntaggedValue p = fmap M1 . consParseJSON (cname :* p)
1081+ parseUntaggedValue = gParseJSON
1437− cname = conName (undefined :: M1 _i c _f _p)
1439instance OVERLAPPING_
1083instance OVERLAPPING_
1440 ( Constructor c )
1084 ( Constructor c )
1441 => FromUntaggedValue arity (C1 c U1)
1085 => FromUntaggedValue arity (C1 c U1)
1443− parseUntaggedValue (tname :* opts :* _) v =
1087+ parseUntaggedValue opts _ (String s)
1444− contextCons cname tname $ case v of
1088+ | s == pack (constructorTagModifier opts (conName (undefined :: t c U1 p))) =
1446− | tag == tag' -> pure $ M1 U1
1089+ pure $ M1 U1
1447− | otherwise -> fail_ tag
1090+ | otherwise =
1448− _ -> typeMismatch "String" v
1091+ fail $ "Invalid tag: " ++ unpack s
1449− where
1092+ parseUntaggedValue _ _ v = typeMismatch (conName (undefined :: t c U1 p)) v
1450− tag' = pack $ constructorTagModifier opts cname
1093+
1451− cname = conName (undefined :: M1 _i c _f _p)
1094+
1452− fail_ tag = fail $
1095+--------------------------------------------------------------------------------
1453− "expected tag " ++ show tag' ++ ", but found tag " ++ show tag
1096+
1097+notFound :: Text -> Parser a
1098+notFound key = fail $ "The key \"" ++ unpack key ++ "\" was not found"
1099+{-# INLINE notFound #-}
1455-------------------------------------------------------------------------------
1101-------------------------------------------------------------------------------
1456-- Instances
1102-- Instances
@@ -1508,20 +1154,17 @@ instance (FromJSON a, FromJSON b) => FromJSON (Either a b) where
1508 parseJSON = parseJSON2
1154 parseJSON = parseJSON2
1509 {-# INLINE parseJSON #-}
1155 {-# INLINE parseJSON #-}
1511−instance FromJSON Void where
1157+
1512− parseJSON _ = fail "Cannot parse Void"
1513− {-# INLINE parseJSON #-}
1515instance FromJSON Bool where
1159instance FromJSON Bool where
1516− parseJSON (Bool b) = pure b
1160+ parseJSON = withBool "Bool" pure
1517− parseJSON v = typeMismatch "Bool" v
1518 {-# INLINE parseJSON #-}
1161 {-# INLINE parseJSON #-}
1520instance FromJSONKey Bool where
1163instance FromJSONKey Bool where
1521 fromJSONKey = FromJSONKeyTextParser $ \t -> case t of
1164 fromJSONKey = FromJSONKeyTextParser $ \t -> case t of
1522 "true" -> pure True
1165 "true" -> pure True
1523 "false" -> pure False
1166 "false" -> pure False
1524− _ -> fail $ "cannot parse key " ++ show t ++ " into Bool"
1167+ _ -> fail $ "Cannot parse key into Bool: " ++ T.unpack t
1526instance FromJSON Ordering where
1169instance FromJSON Ordering where
1527 parseJSON = withText "Ordering" $ \s ->
1170 parseJSON = withText "Ordering" $ \s ->
@@ -1529,30 +1172,25 @@ instance FromJSON Ordering where
1529 "LT" -> return LT
1172 "LT" -> return LT
1530 "EQ" -> return EQ
1173 "EQ" -> return EQ
1531 "GT" -> return GT
1174 "GT" -> return GT
1532− _ -> fail $ "parsing Ordering failed, unexpected " ++ show s ++
1533− " (expected \"LT\", \"EQ\", or \"GT\")"
1175+ _ -> fail "Parsing Ordering value failed: expected \"LT\", \"EQ\", or \"GT\""
1535instance FromJSON () where
1177instance FromJSON () where
1536 parseJSON = withArray "()" $ \v ->
1178 parseJSON = withArray "()" $ \v ->
1537 if V.null v
1179 if V.null v
1538 then pure ()
1180 then pure ()
1539− else prependContext "()" $ fail "expected an empty array"
1181+ else fail "Expected an empty array"
1540 {-# INLINE parseJSON #-}
1182 {-# INLINE parseJSON #-}
1542instance FromJSON Char where
1184instance FromJSON Char where
1543− parseJSON = withText "Char" parseChar
1185+ parseJSON = withText "Char" $ \t ->
1186+ if T.compareLength t 1 == EQ
1187+ then pure $ T.head t
1188+ else fail "Expected a string of length 1"
1544 {-# INLINE parseJSON #-}
1189 {-# INLINE parseJSON #-}
1546− parseJSONList (String s) = pure (T.unpack s)
1191+ parseJSONList = withText "String" $ pure . T.unpack
1547− parseJSONList v = typeMismatch "String" v
1548 {-# INLINE parseJSONList #-}
1192 {-# INLINE parseJSONList #-}
1550−parseChar :: Text -> Parser Char
1552− if T.compareLength t 1 == EQ
1553− then pure $ T.head t
1554− else prependContext "Char" $ fail "expected a string of length 1"
1556instance FromJSON Double where
1194instance FromJSON Double where
1557 parseJSON = parseRealFloat "Double"
1195 parseJSON = parseRealFloat "Double"
1558 {-# INLINE parseJSON #-}
1196 {-# INLINE parseJSON #-}
@@ -1564,6 +1202,12 @@ instance FromJSONKey Double where
1564 "-Infinity" -> pure (negate 1/0)
1202 "-Infinity" -> pure (negate 1/0)
1565 _ -> Scientific.toRealFloat <$> parseScientificText t
1203 _ -> Scientific.toRealFloat <$> parseScientificText t
1205+instance FromJSON Number where
1206+ parseJSON (Number s) = pure $ scientificToNumber s
1207+ parseJSON Null = pure (D (0/0))
1208+ parseJSON v = typeMismatch "Number" v
1209+ {-# INLINE parseJSON #-}
1567instance FromJSON Float where
1211instance FromJSON Float where
1568 parseJSON = parseRealFloat "Float"
1212 parseJSON = parseRealFloat "Float"
1569 {-# INLINE parseJSON #-}
1213 {-# INLINE parseJSON #-}
@@ -1576,30 +1220,17 @@ instance FromJSONKey Float where
1576 _ -> Scientific.toRealFloat <$> parseScientificText t
1220 _ -> Scientific.toRealFloat <$> parseScientificText t
1578instance (FromJSON a, Integral a) => FromJSON (Ratio a) where
1222instance (FromJSON a, Integral a) => FromJSON (Ratio a) where
1579− parseJSON (Number x)
1581− , exp10 >= -1024 = return $! realToFrac x
1582− | otherwise = prependContext "Ratio" $ fail msg
1584− exp10 = base10Exponent x
1585− msg = "found a number with exponent " ++ show exp10
1586− ++ ", but it must not be greater than 1024 or less than -1024"
1587− parseJSON o = objParser o
1589− objParser = withObject "Rational" $ \obj -> do
1223+ parseJSON = withObject "Rational" $ \obj ->
1590− numerator <- obj .: "numerator"
1224+ (%) <$> obj .: "numerator"
1591− denominator <- obj .: "denominator"
1592− if denominator == 0
1593− then fail "Ratio denominator was 0"
1594− else pure $ numerator % denominator
1225+ <*> obj .: "denominator"
1595− {-# INLINE parseJSON #-}
1226+ {-# INLINE parseJSON #-}
1597−-- | This instance includes a bounds check to prevent maliciously
1228+-- | /WARNING:/ Only parse fixed-precision numbers from trusted input
1598−-- large inputs to fill up the memory of the target system. You can
1229+-- since an attacker could easily fill up the memory of the target
1599−-- newtype 'Scientific' and provide your own instance using
1230+-- system by specifying a scientific number with a big exponent like
1600−-- 'withScientific' if you want to allow larger inputs.
1231+-- @1e1000000000@.
1601instance HasResolution a => FromJSON (Fixed a) where
1232instance HasResolution a => FromJSON (Fixed a) where
1602− parseJSON = prependContext "Fixed" . withBoundedScientific' (pure . realToFrac)
1233+ parseJSON = withScientific "Fixed" $ pure . realToFrac
1603 {-# INLINE parseJSON #-}
1234 {-# INLINE parseJSON #-}
1605instance FromJSON Int where
1236instance FromJSON Int where
@@ -1609,10 +1240,10 @@ instance FromJSON Int where
1609instance FromJSONKey Int where
1240instance FromJSONKey Int where
1610 fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Int"
1241 fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Int"
1612−-- | This instance includes a bounds check to prevent maliciously
1243+-- | /WARNING:/ Only parse Integers from trusted input since an
1613−-- large inputs to fill up the memory of the target system. You can
1244+-- attacker could easily fill up the memory of the target system by
1614−-- newtype 'Scientific' and provide your own instance using
1245+-- specifying a scientific number with a big exponent like
1615−-- 'withScientific' if you want to allow larger inputs.
1246+-- @1e1000000000@.
1616instance FromJSON Integer where
1247instance FromJSON Integer where
1617 parseJSON = parseIntegral "Integer"
1248 parseJSON = parseIntegral "Integer"
1618 {-# INLINE parseJSON #-}
1249 {-# INLINE parseJSON #-}
@@ -1621,21 +1252,16 @@ instance FromJSONKey Integer where
1621 fromJSONKey = FromJSONKeyTextParser $ parseIntegralText "Integer"
1252 fromJSONKey = FromJSONKeyTextParser $ parseIntegralText "Integer"
1623instance FromJSON Natural where
1254instance FromJSON Natural where
1624− parseJSON value = do
1255+ parseJSON = withScientific "Natural" $ \s ->
1625− integer <- parseIntegral "Natural" value
1256+ if Scientific.coefficient s < 0
1626− parseNatural integer
1257+ then fail $ "Expected a Natural number but got the negative number: " <> show s
1258+ else pure $ truncate s
1628instance FromJSONKey Natural where
1260instance FromJSONKey Natural where
1629− fromJSONKey = FromJSONKeyTextParser $ \text -> do
1261+ fromJSONKey = FromJSONKeyTextParser $ \t -> parseScientificText t >>= \s ->
1630− integer <- parseIntegralText "Natural" text
1262+ if Scientific.coefficient s < 0
1631− parseNatural integer
1633−parseNatural :: Integer -> Parser Natural
1634−parseNatural integer =
1635− if integer < 0 then
1636− fail $ "parsing Natural failed, unexpected negative number " <> show integer
1263+ then fail $ "Expected a Natural number but got the negative number: " <> show s
1637− else
1264+ else pure $ truncate s
1638− pure $ fromIntegral integer
1640instance FromJSON Int8 where
1266instance FromJSON Int8 where
1641 parseJSON = parseBoundedIntegral "Int8"
1267 parseJSON = parseBoundedIntegral "Int8"
@@ -1700,9 +1326,6 @@ instance FromJSON Word64 where
1700instance FromJSONKey Word64 where
1326instance FromJSONKey Word64 where
1701 fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Word64"
1327 fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Word64"
1703−instance FromJSON CTime where
1704− parseJSON = fmap CTime . parseJSON
1705− {-# INLINE parseJSON #-}
1707instance FromJSON Text where
1330instance FromJSON Text where
1708 parseJSON = withText "Text" pure
1331 parseJSON = withText "Text" pure
@@ -1732,17 +1355,17 @@ parseVersionText = go . readP_to_S parseVersion . unpack
1733 go [(v,[])] = return v
1356 go [(v,[])] = return v
1734 go (_ : xs) = go xs
1357 go (_ : xs) = go xs
1735− go _ = fail "parsing Version failed"
1358+ go _ = fail "could not parse Version"
1737-------------------------------------------------------------------------------
1360-------------------------------------------------------------------------------
1738-- semigroups NonEmpty
1361-- semigroups NonEmpty
1739-------------------------------------------------------------------------------
1362-------------------------------------------------------------------------------
1741instance FromJSON1 NonEmpty where
1364instance FromJSON1 NonEmpty where
1742− liftParseJSON p _ = withArray "NonEmpty" $
1365+ liftParseJSON p _ = withArray "NonEmpty a" $
1743 (>>= ne) . Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
1366 (>>= ne) . Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
1745− ne [] = fail "parsing NonEmpty failed, unexpected empty list"
1368+ ne [] = fail "Expected a NonEmpty but got an empty list"
1746 ne (x:xs) = pure (x :| xs)
1369 ne (x:xs) = pure (x :| xs)
1747 {-# INLINE liftParseJSON #-}
1370 {-# INLINE liftParseJSON #-}
@@ -1763,7 +1386,7 @@ instance FromJSON Scientific where
1763-------------------------------------------------------------------------------
1386-------------------------------------------------------------------------------
1765instance FromJSON1 DList.DList where
1388instance FromJSON1 DList.DList where
1766− liftParseJSON p _ = withArray "DList" $
1389+ liftParseJSON p _ = withArray "DList a" $
1767 fmap DList.fromList .
1390 fmap DList.fromList .
1768 Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
1391 Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
1769 {-# INLINE liftParseJSON #-}
1392 {-# INLINE liftParseJSON #-}
@@ -1840,7 +1463,7 @@ instance (FromJSON1 f, FromJSON1 g) => FromJSON1 (Sum f g) where
1840 inr = "InR"
1463 inr = "InR"
1842 liftParseJSON _ _ _ = fail $
1465 liftParseJSON _ _ _ = fail $
1843− "parsing Sum failed, expected an object with a single property " ++
1466+ "expected an object with a single property " ++
1844 "where the property key should be either " ++
1467 "where the property key should be either " ++
1845 "\"InL\" or \"InR\""
1468 "\"InL\" or \"InR\""
1846 {-# INLINE liftParseJSON #-}
1469 {-# INLINE liftParseJSON #-}
@@ -1854,7 +1477,7 @@ instance (FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Sum f g a) where
1854-------------------------------------------------------------------------------
1477-------------------------------------------------------------------------------
1856instance FromJSON1 Seq.Seq where
1479instance FromJSON1 Seq.Seq where
1857− liftParseJSON p _ = withArray "Seq" $
1480+ liftParseJSON p _ = withArray "Seq a" $
1858 fmap Seq.fromList .
1481 fmap Seq.fromList .
1859 Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
1482 Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
1860 {-# INLINE liftParseJSON #-}
1483 {-# INLINE liftParseJSON #-}
@@ -1888,15 +1511,15 @@ instance FromJSON a => FromJSON (IntMap.IntMap a) where
1889instance (FromJSONKey k, Ord k) => FromJSON1 (M.Map k) where
1512instance (FromJSONKey k, Ord k) => FromJSON1 (M.Map k) where
1890 liftParseJSON p _ = case fromJSONKey of
1513 liftParseJSON p _ = case fromJSONKey of
1891− FromJSONKeyCoerce _ -> withObject "Map" $
1514+ FromJSONKeyCoerce _-> withObject "Map k v" $
1892 fmap (H.foldrWithKey (M.insert . unsafeCoerce) M.empty) . H.traverseWithKey (\k v -> p v <?> Key k)
1515 fmap (H.foldrWithKey (M.insert . unsafeCoerce) M.empty) . H.traverseWithKey (\k v -> p v <?> Key k)
1893− FromJSONKeyText f -> withObject "Map" $
1516+ FromJSONKeyText f -> withObject "Map k v" $
1894 fmap (H.foldrWithKey (M.insert . f) M.empty) . H.traverseWithKey (\k v -> p v <?> Key k)
1517 fmap (H.foldrWithKey (M.insert . f) M.empty) . H.traverseWithKey (\k v -> p v <?> Key k)
1895− FromJSONKeyTextParser f -> withObject "Map" $
1518+ FromJSONKeyTextParser f -> withObject "Map k v" $
1896 H.foldrWithKey (\k v m -> M.insert <$> f k <?> Key k <*> p v <?> Key k <*> m) (pure M.empty)
1519 H.foldrWithKey (\k v m -> M.insert <$> f k <?> Key k <*> p v <?> Key k <*> m) (pure M.empty)
1897− FromJSONKeyValue f -> withArray "Map" $ \arr ->
1520+ FromJSONKeyValue f -> withArray "Map k v" $ \arr ->
1898− fmap M.fromList . Tr.sequence .
1521+ M.fromList <$> (Tr.sequence .
1899− zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr
1522+ zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr)
1900 {-# INLINE liftParseJSON #-}
1523 {-# INLINE liftParseJSON #-}
1902instance (FromJSONKey k, Ord k, FromJSON v) => FromJSON (M.Map k v) where
1525instance (FromJSONKey k, Ord k, FromJSON v) => FromJSON (M.Map k v) where
@@ -1922,18 +1545,18 @@ instance (FromJSON v) => FromJSON (Tree.Tree v) where
1923instance FromJSON UUID.UUID where
1546instance FromJSON UUID.UUID where
1924 parseJSON = withText "UUID" $
1547 parseJSON = withText "UUID" $
1925− maybe (fail "invalid UUID") pure . UUID.fromText
1548+ maybe (fail "Invalid UUID") pure . UUID.fromText
1927instance FromJSONKey UUID.UUID where
1550instance FromJSONKey UUID.UUID where
1928 fromJSONKey = FromJSONKeyTextParser $
1551 fromJSONKey = FromJSONKeyTextParser $
1929− maybe (fail "invalid UUID") pure . UUID.fromText
1552+ maybe (fail "Invalid UUID") pure . UUID.fromText
1931-------------------------------------------------------------------------------
1554-------------------------------------------------------------------------------
1932-- vector
1555-- vector
1933-------------------------------------------------------------------------------
1556-------------------------------------------------------------------------------
1935instance FromJSON1 Vector where
1558instance FromJSON1 Vector where
1936− liftParseJSON p _ = withArray "Vector" $
1559+ liftParseJSON p _ = withArray "Vector a" $
1937 V.mapM (uncurry $ parseIndexedJSON p) . V.indexed
1560 V.mapM (uncurry $ parseIndexedJSON p) . V.indexed
1938 {-# INLINE liftParseJSON #-}
1561 {-# INLINE liftParseJSON #-}
@@ -1947,14 +1570,14 @@ vectorParseJSON s = withArray s $ fmap V.convert . V.mapM (uncurry $ parseIndexe
1947{-# INLINE vectorParseJSON #-}
1570{-# INLINE vectorParseJSON #-}
1949instance (Storable a, FromJSON a) => FromJSON (VS.Vector a) where
1572instance (Storable a, FromJSON a) => FromJSON (VS.Vector a) where
1950− parseJSON = vectorParseJSON "Data.Vector.Storable.Vector"
1573+ parseJSON = vectorParseJSON "Data.Vector.Storable.Vector a"
1952instance (VP.Prim a, FromJSON a) => FromJSON (VP.Vector a) where
1575instance (VP.Prim a, FromJSON a) => FromJSON (VP.Vector a) where
1953− parseJSON = vectorParseJSON "Data.Vector.Primitive.Vector"
1576+ parseJSON = vectorParseJSON "Data.Vector.Primitive.Vector a"
1954 {-# INLINE parseJSON #-}
1577 {-# INLINE parseJSON #-}
1956instance (VG.Vector VU.Vector a, FromJSON a) => FromJSON (VU.Vector a) where
1579instance (VG.Vector VU.Vector a, FromJSON a) => FromJSON (VU.Vector a) where
1957− parseJSON = vectorParseJSON "Data.Vector.Unboxed.Vector"
1580+ parseJSON = vectorParseJSON "Data.Vector.Unboxed.Vector a"
1958 {-# INLINE parseJSON #-}
1581 {-# INLINE parseJSON #-}
1960-------------------------------------------------------------------------------
1583-------------------------------------------------------------------------------
@@ -1968,15 +1591,15 @@ instance (Eq a, Hashable a, FromJSON a) => FromJSON (HashSet.HashSet a) where
1969instance (FromJSONKey k, Eq k, Hashable k) => FromJSON1 (H.HashMap k) where
1592instance (FromJSONKey k, Eq k, Hashable k) => FromJSON1 (H.HashMap k) where
1970 liftParseJSON p _ = case fromJSONKey of
1593 liftParseJSON p _ = case fromJSONKey of
1971− FromJSONKeyCoerce _ -> withObject "HashMap ~Text" $
1594+ FromJSONKeyCoerce _ -> withObject "HashMap ~Text v" $
1972 uc . H.traverseWithKey (\k v -> p v <?> Key k)
1595 uc . H.traverseWithKey (\k v -> p v <?> Key k)
1973− FromJSONKeyText f -> withObject "HashMap" $
1596+ FromJSONKeyText f -> withObject "HashMap k v" $
1974 fmap (mapKey f) . H.traverseWithKey (\k v -> p v <?> Key k)
1597 fmap (mapKey f) . H.traverseWithKey (\k v -> p v <?> Key k)
1975− FromJSONKeyTextParser f -> withObject "HashMap" $
1598+ FromJSONKeyTextParser f -> withObject "HashMap k v" $
1976 H.foldrWithKey (\k v m -> H.insert <$> f k <?> Key k <*> p v <?> Key k <*> m) (pure H.empty)
1599 H.foldrWithKey (\k v m -> H.insert <$> f k <?> Key k <*> p v <?> Key k <*> m) (pure H.empty)
1977− FromJSONKeyValue f -> withArray "Map" $ \arr ->
1600+ FromJSONKeyValue f -> withArray "Map k v" $ \arr ->
1978− fmap H.fromList . Tr.sequence .
1601+ H.fromList <$> (Tr.sequence .
1979− zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr
1602+ zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr)
1981 uc :: Parser (H.HashMap Text v) -> Parser (H.HashMap k v)
1604 uc :: Parser (H.HashMap Text v) -> Parser (H.HashMap k v)
1982 uc = unsafeCoerce
1605 uc = unsafeCoerce
@@ -1997,33 +1620,11 @@ instance FromJSON DotNetTime where
1997 parseJSON = withText "DotNetTime" $ \t ->
1620 parseJSON = withText "DotNetTime" $ \t ->
1998 let (s,m) = T.splitAt (T.length t - 5) t
1621 let (s,m) = T.splitAt (T.length t - 5) t
1999 t' = T.concat [s,".",m]
1622 t' = T.concat [s,".",m]
2000− in case parseTimeM True defaultTimeLocale "/Date(%s%Q)/" (unpack t') of
1623+ in case parseTime defaultTimeLocale "/Date(%s%Q)/" (unpack t') of
2001 Just d -> pure (DotNetTime d)
1624 Just d -> pure (DotNetTime d)
2002 _ -> fail "could not parse .NET time"
1625 _ -> fail "could not parse .NET time"
2003 {-# INLINE parseJSON #-}
1626 {-# INLINE parseJSON #-}
2005−-------------------------------------------------------------------------------
2007−-------------------------------------------------------------------------------
2009−instance FromJSON a => FromJSON (PM.Array a) where
2010− -- note: we could do better than this if vector exposed the data
2011− -- constructor in Data.Vector.
2012− parseJSON = fmap Exts.fromList . parseJSON
2014−instance FromJSON a => FromJSON (PM.SmallArray a) where
2015− parseJSON = fmap Exts.fromList . parseJSON
2017−#if MIN_VERSION_primitive(0,6,4)
2018−instance (PM.Prim a,FromJSON a) => FromJSON (PM.PrimArray a) where
2019− parseJSON = fmap Exts.fromList . parseJSON
2021−#if !MIN_VERSION_primitive(0,7,0)
2022−instance (PM.PrimUnlifted a,FromJSON a) => FromJSON (PM.UnliftedArray a) where
2023− parseJSON = fmap Exts.fromList . parseJSON
2027-------------------------------------------------------------------------------
1628-------------------------------------------------------------------------------
2029-------------------------------------------------------------------------------
1630-------------------------------------------------------------------------------
@@ -2049,17 +1650,6 @@ instance FromJSONKey LocalTime where
2049 fromJSONKey = FromJSONKeyTextParser (Time.run Time.localTime)
1650 fromJSONKey = FromJSONKeyTextParser (Time.run Time.localTime)
2052−-- | Supported string formats:
2054−-- @YYYY-MM-DD HH:MM Z@
2055−-- @YYYY-MM-DD HH:MM:SS Z@
2056−-- @YYYY-MM-DD HH:MM:SS.SSS Z@
2058−-- The first space may instead be a @T@, and the second space is
2059−-- optional. The @Z@ represents UTC. The @Z@ may be replaced with a
2060−-- time zone offset of the form @+0000@ or @-08:00@, where the first
2061−-- two digits are hours, the @:@ is optional and the second two digits
2062−-- (also optional) are minutes.
2063instance FromJSON ZonedTime where
1653instance FromJSON ZonedTime where
2064 parseJSON = withText "ZonedTime" (Time.run Time.zonedTime)
1654 parseJSON = withText "ZonedTime" (Time.run Time.zonedTime)
@@ -2074,57 +1664,14 @@ instance FromJSONKey UTCTime where
2074 fromJSONKey = FromJSONKeyTextParser (Time.run Time.utcTime)
1664 fromJSONKey = FromJSONKeyTextParser (Time.run Time.utcTime)
2077−-- | This instance includes a bounds check to prevent maliciously
1667+-- | /WARNING:/ Only parse lengths of time from trusted input
2078−-- large inputs to fill up the memory of the target system. You can
1668+-- since an attacker could easily fill up the memory of the target
2079−-- newtype 'Scientific' and provide your own instance using
1669+-- system by specifying a scientific number with a big exponent like
2080−-- 'withScientific' if you want to allow larger inputs.
1670+-- @1e1000000000@.
2081instance FromJSON NominalDiffTime where
1671instance FromJSON NominalDiffTime where
2082− parseJSON = withBoundedScientific "NominalDiffTime" $ pure . realToFrac
1672+ parseJSON = withScientific "NominalDiffTime" $ pure . realToFrac
2083− {-# INLINE parseJSON #-}
2086−-- | This instance includes a bounds check to prevent maliciously
2087−-- large inputs to fill up the memory of the target system. You can
2088−-- newtype 'Scientific' and provide your own instance using
2089−-- 'withScientific' if you want to allow larger inputs.
2090−instance FromJSON DiffTime where
2091− parseJSON = withBoundedScientific "DiffTime" $ pure . realToFrac
2092 {-# INLINE parseJSON #-}
1673 {-# INLINE parseJSON #-}
2094−instance FromJSON SystemTime where
2095− parseJSON v = prependContext "SystemTime" $ do
2097− let n' = floor (n * fromInteger (resolution n) :: Nano)
2098− let (secs, nano) = n' `divMod` resolution n
2099− return (MkSystemTime (fromInteger secs) (fromInteger nano))
2101−instance FromJSON CalendarDiffTime where
2102− parseJSON = withObject "CalendarDiffTime" $ \obj -> CalendarDiffTime
2103− <$> obj .: "months"
2106−instance FromJSON CalendarDiffDays where
2107− parseJSON = withObject "CalendarDiffDays" $ \obj -> CalendarDiffDays
2108− <$> obj .: "months"
2111−instance FromJSON DayOfWeek where
2112− parseJSON = withText "DaysOfWeek" parseDayOfWeek
2114−parseDayOfWeek :: T.Text -> Parser DayOfWeek
2115−parseDayOfWeek t = case T.toLower t of
2116− "monday" -> return Monday
2117− "tuesday" -> return Tuesday
2118− "wednesday" -> return Wednesday
2119− "thursday" -> return Thursday
2120− "friday" -> return Friday
2121− "saturday" -> return Saturday
2122− "sunday" -> return Sunday
2123− _ -> fail "Invalid week day"
2125−instance FromJSONKey DayOfWeek where
2126− fromJSONKey = FromJSONKeyTextParser parseDayOfWeek
2128-------------------------------------------------------------------------------
1675-------------------------------------------------------------------------------
2129-- base Monoid/Semigroup
1676-- base Monoid/Semigroup
2130-------------------------------------------------------------------------------
1677-------------------------------------------------------------------------------
@@ -2245,15 +1792,14 @@ instance FromJSON a => FromJSON (Semigroup.Option a) where
2246instance FromJSON1 Proxy where
1793instance FromJSON1 Proxy where
2247 {-# INLINE liftParseJSON #-}
1794 {-# INLINE liftParseJSON #-}
2248− liftParseJSON _ _ = fromNull "Proxy" Proxy
1795+ liftParseJSON _ _ Null = pure Proxy
1796+ liftParseJSON _ _ v = typeMismatch "Proxy" v
2250instance FromJSON (Proxy a) where
1798instance FromJSON (Proxy a) where
2251 {-# INLINE parseJSON #-}
1799 {-# INLINE parseJSON #-}
2252− parseJSON = fromNull "Proxy" Proxy
1800+ parseJSON Null = pure Proxy
1801+ parseJSON v = typeMismatch "Proxy" v
2254−fromNull :: String -> a -> Value -> Parser a
2255−fromNull _ a Null = pure a
2256−fromNull c _ v = prependContext c (typeMismatch "Null" v)
2258instance FromJSON2 Tagged where
1804instance FromJSON2 Tagged where
2259 liftParseJSON2 _ _ p _ = fmap Tagged . p
1805 liftParseJSON2 _ _ p _ = fmap Tagged . p
@@ -2280,7 +1826,10 @@ instance (FromJSON a, FromJSON b, FromJSON c) => FromJSONKey (a,b,c)
2280instance (FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSONKey (a,b,c,d)
1826instance (FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSONKey (a,b,c,d)
2282instance FromJSONKey Char where
1828instance FromJSONKey Char where
2283− fromJSONKey = FromJSONKeyTextParser parseChar
1829+ fromJSONKey = FromJSONKeyTextParser $ \t ->
1831+ then return (T.index t 0)
1832+ else typeMismatch "Expected Char but String didn't contain exactly one character" (String t)
2284 fromJSONKeyList = FromJSONKeyText T.unpack
1833 fromJSONKeyList = FromJSONKeyText T.unpack
2286instance (FromJSONKey a, FromJSON a) => FromJSONKey [a] where
1835instance (FromJSONKey a, FromJSON a) => FromJSONKey [a] where