@@ -61,6 +61,7 @@ module Data.Aeson.Types.FromJSON
61 , fromJSON
61 , fromJSON
62 , ifromJSON
62 , ifromJSON
63 , typeMismatch
63 , typeMismatch
64 , parseField
65 , parseField
65 , parseFieldMaybe
66 , parseFieldMaybe
66 , parseFieldMaybe'
67 , parseFieldMaybe'
@@ -79,8 +80,8 @@ module Data.Aeson.Types.FromJSON
80import Prelude.Compat
81import Prelude.Compat
82−import Control.Applicative ((<|>), Const(..))
83+import Control.Applicative ((<|>), Const(..), liftA2)
83−import Control.Monad ((<=<), zipWithM)
84+import Control.Monad (zipWithM)
84import Data.Aeson.Internal.Functions (mapKey)
85import Data.Aeson.Internal.Functions (mapKey)
85import Data.Aeson.Parser.Internal (eitherDecodeWith, jsonEOF)
86import Data.Aeson.Parser.Internal (eitherDecodeWith, jsonEOF)
86import Data.Aeson.Types.Generic
87import Data.Aeson.Types.Generic
@@ -170,7 +171,7 @@ parseIndexedJSON p idx value = p value <?> Index idx
170parseIndexedJSONPair :: (Value -> Parser a) -> (Value -> Parser b) -> Int -> Value -> Parser (a, b)
171parseIndexedJSONPair :: (Value -> Parser a) -> (Value -> Parser b) -> Int -> Value -> Parser (a, b)
171parseIndexedJSONPair keyParser valParser idx value = p value <?> Index idx
172parseIndexedJSONPair keyParser valParser idx value = p value <?> Index idx
173− p = withArray "(k,v)" $ \ab ->
174+ p = withArray "(k, v)" $ \ab ->
174 let n = V.length ab
175 let n = V.length ab
175 in if n == 2
176 in if n == 2
176 then (,) <$> parseJSONElemAtIndex keyParser 0 ab
177 then (,) <$> parseJSONElemAtIndex keyParser 0 ab
@@ -183,33 +184,33 @@ parseJSONElemAtIndex :: (Value -> Parser a) -> Int -> V.Vector Value -> Parser a
183parseJSONElemAtIndex p idx ary = p (V.unsafeIndex ary idx) <?> Index idx
184parseJSONElemAtIndex p idx ary = p (V.unsafeIndex ary idx) <?> Index idx
185parseRealFloat :: RealFloat a => String -> Value -> Parser a
186parseRealFloat :: RealFloat a => String -> Value -> Parser a
186−parseRealFloat _ (Number s) = pure $ Scientific.toRealFloat s
187+parseRealFloat _ (Number s) = pure $ Scientific.toRealFloat s
187−parseRealFloat _ Null = pure (0/0)
188+parseRealFloat _ Null = pure (0/0)
188−parseRealFloat expected v = typeMismatch expected v
189+parseRealFloat name v = prependContext name (unexpected v)
189{-# INLINE parseRealFloat #-}
190{-# INLINE parseRealFloat #-}
191−parseIntegralFromScientific :: forall a. Integral a => String -> Scientific -> Parser a
192+parseIntegralFromScientific :: forall a. Integral a => Scientific -> Parser a
192−parseIntegralFromScientific expected s =
193+parseIntegralFromScientific s =
193 case Scientific.floatingOrInteger s :: Either Double a of
194 case Scientific.floatingOrInteger s :: Either Double a of
194 Right x -> pure x
195 Right x -> pure x
195− Left _ -> fail $ "expected " ++ expected ++ ", encountered floating number " ++ show s
196+ Left _ -> fail $ "unexpected floating number " ++ show s
196{-# INLINE parseIntegralFromScientific #-}
197{-# INLINE parseIntegralFromScientific #-}
198parseIntegral :: Integral a => String -> Value -> Parser a
199parseIntegral :: Integral a => String -> Value -> Parser a
199−parseIntegral expected =
200+parseIntegral name =
200− withBoundedScientific expected $ parseIntegralFromScientific expected
201+ prependContext name . withBoundedScientific' parseIntegralFromScientific
201{-# INLINE parseIntegral #-}
202{-# INLINE parseIntegral #-}
203−parseBoundedIntegralFromScientific :: (Bounded a, Integral a) => String -> Scientific -> Parser a
204+parseBoundedIntegralFromScientific :: (Bounded a, Integral a) => Scientific -> Parser a
204−parseBoundedIntegralFromScientific expected s = maybe
205+parseBoundedIntegralFromScientific s = maybe
205− (fail $ expected ++ " is either floating or will cause over or underflow: " ++ show s)
206+ (fail $ "value is either floating or will cause over or underflow " ++ show s)
207 (Scientific.toBoundedInteger s)
208 (Scientific.toBoundedInteger s)
208{-# INLINE parseBoundedIntegralFromScientific #-}
209{-# INLINE parseBoundedIntegralFromScientific #-}
210parseBoundedIntegral :: (Bounded a, Integral a) => String -> Value -> Parser a
211parseBoundedIntegral :: (Bounded a, Integral a) => String -> Value -> Parser a
211−parseBoundedIntegral expected =
212+parseBoundedIntegral name =
212− withScientific expected $ parseBoundedIntegralFromScientific expected
213+ prependContext name . withScientific' parseBoundedIntegralFromScientific
213{-# INLINE parseBoundedIntegral #-}
214{-# INLINE parseBoundedIntegral #-}
215parseScientificText :: Text -> Parser Scientific
216parseScientificText :: Text -> Parser Scientific
@@ -219,18 +220,20 @@ parseScientificText
219 . T.encodeUtf8
220 . T.encodeUtf8
221parseIntegralText :: Integral a => String -> Text -> Parser a
222parseIntegralText :: Integral a => String -> Text -> Parser a
222−parseIntegralText expected t
223+parseIntegralText name t =
224+ prependContext name $
223− = parseScientificText t
225+ parseScientificText t
224− >>= rejectLargeExponent
226+ >>= rejectLargeExponent
225− >>= parseIntegralFromScientific expected
227+ >>= parseIntegralFromScientific
227 rejectLargeExponent :: Scientific -> Parser Scientific
229 rejectLargeExponent :: Scientific -> Parser Scientific
228− rejectLargeExponent s = withBoundedScientific expected pure (Number s)
230+ rejectLargeExponent s = withBoundedScientific' pure (Number s)
229{-# INLINE parseIntegralText #-}
231{-# INLINE parseIntegralText #-}
231parseBoundedIntegralText :: (Bounded a, Integral a) => String -> Text -> Parser a
233parseBoundedIntegralText :: (Bounded a, Integral a) => String -> Text -> Parser a
232−parseBoundedIntegralText expected t =
234+parseBoundedIntegralText name t =
235+ prependContext name $
233− parseScientificText t >>= parseBoundedIntegralFromScientific expected
236+ parseScientificText t >>= parseBoundedIntegralFromScientific
235parseOptionalFieldWith :: (Value -> Parser (Maybe a))
238parseOptionalFieldWith :: (Value -> Parser (Maybe a))
236 -> Object -> Text -> Parser (Maybe a)
239 -> Object -> Text -> Parser (Maybe a)
@@ -290,14 +293,21 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
291-- The basic ways to signal a failed conversion are as follows:
294-- The basic ways to signal a failed conversion are as follows:
293−-- * 'empty' and 'mzero' work, but are terse and uninformative;
296+-- * 'fail' yields a custom error message: it is the recommended way of
297+-- reporting a failure;
295−-- * 'fail' yields a custom error message;
299+-- * 'Control.Applicative.empty' (or 'Control.Monad.mzero') is uninformative:
300+-- use it when the error is meant to be caught by some @('<|>')@;
297−-- * 'typeMismatch' produces an informative message for cases when the
302+-- * 'typeMismatch' can be used to report a failure when the encountered value
298−-- value encountered is not of the expected type.
303+-- is not of the expected JSON type; 'unexpected' is an appropriate alternative
304+-- when more than one type may be expected, or to keep the expected type
307+-- 'prependFailure' (or 'modifyFailure') add more information to a parser's
300−-- An example type and instance using 'typeMismatch':
310+-- An example type and instance using 'typeMismatch' and 'prependFailure':
303-- \-- Allow ourselves to write 'Text' literals.
313-- \-- Allow ourselves to write 'Text' literals.
@@ -311,13 +321,15 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
311-- '<*>' v '.:' \"y\"
321-- '<*>' v '.:' \"y\"
313-- \-- We do not expect a non-'Object' value here.
323-- \-- We do not expect a non-'Object' value here.
314−-- \-- We could use 'mzero' to fail, but 'typeMismatch'
324+-- \-- We could use 'Control.Applicative.empty' to fail, but 'typeMismatch'
315-- \-- gives a much more informative error message.
325-- \-- gives a much more informative error message.
326+-- 'parseJSON' invalid =
327+-- 'prependFailure' "parsing Coord failed, "
316−-- 'parseJSON' invalid = 'typeMismatch' \"Coord\" invalid
328+-- ('typeMismatch' \"Object\" invalid)
319-- For this common case of only being concerned with a single
331-- For this common case of only being concerned with a single
320−-- type of JSON value, the functions 'withObject', 'withNumber', etc.
332+-- type of JSON value, the functions 'withObject', 'withScientific', etc.
321-- are provided. Their use is to be preferred when possible, since
333-- are provided. Their use is to be preferred when possible, since
322-- they are more terse. Using 'withObject', we can rewrite the above instance
334-- they are more terse. Using 'withObject', we can rewrite the above instance
323-- (assuming the same language extension and data type) as:
335-- (assuming the same language extension and data type) as:
@@ -356,7 +368,7 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
358-- The default implementation will be equivalent to
370-- The default implementation will be equivalent to
359−-- @parseJSON = 'genericParseJSON' 'defaultOptions'@; If you need different
371+-- @parseJSON = 'genericParseJSON' 'defaultOptions'@; if you need different
360-- options, you can customize the generic decoding by defining:
372-- options, you can customize the generic decoding by defining:
@@ -374,13 +386,11 @@ class FromJSON a where
374 parseJSON = genericParseJSON defaultOptions
386 parseJSON = genericParseJSON defaultOptions
376 parseJSONList :: Value -> Parser [a]
388 parseJSONList :: Value -> Parser [a]
377− parseJSONList (Array a)
389+ parseJSONList = withArray "[]" $ \a ->
378− = zipWithM (parseIndexedJSON parseJSON) [0..]
390+ zipWithM (parseIndexedJSON parseJSON) [0..]
379 . V.toList
391 . V.toList
382− parseJSONList v = typeMismatch "[a]" v
384-------------------------------------------------------------------------------
394-------------------------------------------------------------------------------
385-- Classes and types for map keys
395-- Classes and types for map keys
386-------------------------------------------------------------------------------
396-------------------------------------------------------------------------------
@@ -496,26 +506,39 @@ mapFromJSONKeyFunction = fmap
497-- | Fail parsing due to a type mismatch, with a descriptive message.
507-- | Fail parsing due to a type mismatch, with a descriptive message.
499−-- Example usage:
509+-- The following wrappers should generally be prefered:
510+-- 'withObject', 'withArray', 'withText', 'withBool'.
501−-- @
512+-- ==== Error message example
502−-- instance FromJSON Coord where
513+--
503−-- parseJSON ('Object' v) = {- type matches, life is good -}
514+-- > typeMismatch "Object" (String "oops")
504−-- parseJSON wat = 'typeMismatch' \"Coord\" wat
515+-- > -- Error: "expected Object, but encountered String"
506−typeMismatch :: String -- ^ The name of the type you are trying to parse.
516+typeMismatch :: String -- ^ The name of the JSON type being parsed
517+ -- (@\"Object\"@, @\"Array\"@, @\"String\"@, @\"Number\"@,
518+ -- @\"Boolean\"@, or @\"Null\"@).
507 -> Value -- ^ The actual value encountered.
519 -> Value -- ^ The actual value encountered.
508 -> Parser a
520 -> Parser a
509typeMismatch expected actual =
521typeMismatch expected actual =
510− fail $ "expected " ++ expected ++ ", encountered " ++ name
522+ fail $ "expected " ++ expected ++ ", but encountered " ++ typeOf actual
524+-- | Fail parsing due to a type mismatch, when the expected types are implicit.
526+-- ==== Error message example
528+-- > unexpected (String "oops")
529+-- > -- Error: "unexpected String"
530+unexpected :: Value -> Parser a
531+unexpected actual = fail $ "unexpected " ++ typeOf actual
533+-- | JSON type of a value, name of the head constructor.
534+typeOf :: Value -> String
512− name = case actual of
535+typeOf v = case v of
513− Object _ -> "Object"
536+ Object _ -> "Object"
514− Array _ -> "Array"
537+ Array _ -> "Array"
515− String _ -> "String"
538+ String _ -> "String"
516− Number _ -> "Number"
539+ Number _ -> "Number"
517− Bool _ -> "Boolean"
540+ Bool _ -> "Boolean"
518− Null -> "Null"
541+ Null -> "Null"
520-------------------------------------------------------------------------------
543-------------------------------------------------------------------------------
521-- Lifings of FromJSON and ToJSON to unary and binary type constructors
544-- Lifings of FromJSON and ToJSON to unary and binary type constructors
@@ -596,9 +619,8 @@ class FromJSON2 f where
596 -> (Value -> Parser b)
619 -> (Value -> Parser b)
597 -> (Value -> Parser [b])
620 -> (Value -> Parser [b])
598 -> Value -> Parser [f a b]
621 -> Value -> Parser [f a b]
599− liftParseJSONList2 fa ga fb gb v = case v of
622+ liftParseJSONList2 fa ga fb gb = withArray "[]" $ \vals ->
600− Array vals -> fmap V.toList (V.mapM (liftParseJSON2 fa ga fb gb) vals)
623+ fmap V.toList (V.mapM (liftParseJSON2 fa ga fb gb) vals)
601− _ -> typeMismatch "[a]" v
603-- | Lift the standard 'parseJSON' function through the type constructor.
625-- | Lift the standard 'parseJSON' function through the type constructor.
604parseJSON2 :: (FromJSON2 f, FromJSON a, FromJSON b) => Value -> Parser (f a b)
626parseJSON2 :: (FromJSON2 f, FromJSON a, FromJSON b) => Value -> Parser (f a b)
@@ -612,7 +634,7 @@ parseJSON2 = liftParseJSON2 parseJSON parseJSONList parseJSON parseJSONList
612-- | Helper function to use with 'liftParseJSON'. See 'Data.Aeson.ToJSON.listEncoding'.
634-- | Helper function to use with 'liftParseJSON'. See 'Data.Aeson.ToJSON.listEncoding'.
613listParser :: (Value -> Parser a) -> Value -> Parser [a]
635listParser :: (Value -> Parser a) -> Value -> Parser [a]
614listParser f (Array xs) = fmap V.toList (V.mapM f xs)
636listParser f (Array xs) = fmap V.toList (V.mapM f xs)
615−listParser _ v = typeMismatch "[a]" v
637+listParser _ v = typeMismatch "Array" v
616{-# INLINE listParser #-}
638{-# INLINE listParser #-}
618-------------------------------------------------------------------------------
640-------------------------------------------------------------------------------
@@ -630,59 +652,127 @@ instance (FromJSON a) => FromJSON [a] where
630-- Functions
652-- Functions
631-------------------------------------------------------------------------------
653-------------------------------------------------------------------------------
655+-- | Add context to a failure message, indicating the name of the structure
658+-- > prependContext "MyType" (fail "[error message]")
659+-- > -- Error: "parsing MyType failed, [error message]"
660+prependContext :: String -> Parser a -> Parser a
661+prependContext name = prependFailure ("parsing " ++ name ++ " failed, ")
633−-- | @'withObject' expected f value@ applies @f@ to the 'Object' when @value@
663+-- | @'withObject' name f value@ applies @f@ to the 'Object' when @value@
634−-- is an 'Object' and fails using @'typeMismatch' expected@ otherwise.
664+-- is an 'Data.Aeson.Object' and fails otherwise.
666+-- ==== Error message example
668+-- > withObject "MyType" f (String "oops")
669+-- > -- Error: "parsing MyType failed, expected Object, but encountered String"
635withObject :: String -> (Object -> Parser a) -> Value -> Parser a
670withObject :: String -> (Object -> Parser a) -> Value -> Parser a
636−withObject _ f (Object obj) = f obj
671+withObject _ f (Object obj) = f obj
637−withObject expected _ v = typeMismatch expected v
672+withObject name _ v = prependContext name (typeMismatch "Object" v)
638{-# INLINE withObject #-}
673{-# INLINE withObject #-}
640−-- | @'withText' expected f value@ applies @f@ to the 'Text' when @value@ is a
675+-- | @'withText' name f value@ applies @f@ to the 'Text' when @value@ is a
641−-- 'String' and fails using @'typeMismatch' expected@ otherwise.
676+-- 'Data.Aeson.String' and fails otherwise.
678+-- ==== Error message example
680+-- > withText "MyType" f Null
681+-- > -- Error: "parsing MyType failed, expected String, but encountered Null"
642withText :: String -> (Text -> Parser a) -> Value -> Parser a
682withText :: String -> (Text -> Parser a) -> Value -> Parser a
643−withText _ f (String txt) = f txt
683+withText _ f (String txt) = f txt
644−withText expected _ v = typeMismatch expected v
684+withText name _ v = prependContext name (typeMismatch "String" v)
645{-# INLINE withText #-}
685{-# INLINE withText #-}
647-- | @'withArray' expected f value@ applies @f@ to the 'Array' when @value@ is
687-- | @'withArray' expected f value@ applies @f@ to the 'Array' when @value@ is
648−-- an 'Array' and fails using @'typeMismatch' expected@ otherwise.
688+-- an 'Data.Aeson.Array' and fails otherwise.
690+-- ==== Error message example
692+-- > withArray "MyType" f (String "oops")
693+-- > -- Error: "parsing MyType failed, expected Array, but encountered String"
649withArray :: String -> (Array -> Parser a) -> Value -> Parser a
694withArray :: String -> (Array -> Parser a) -> Value -> Parser a
650−withArray _ f (Array arr) = f arr
695+withArray _ f (Array arr) = f arr
651−withArray expected _ v = typeMismatch expected v
696+withArray name _ v = prependContext name (typeMismatch "Array" v)
652{-# INLINE withArray #-}
697{-# INLINE withArray #-}
654−-- | @'withScientific' expected f value@ applies @f@ to the 'Scientific' number
699+-- | @'withScientific' name f value@ applies @f@ to the 'Scientific' number
655−-- when @value@ is a 'Number' and fails using @'typeMismatch' expected@
700+-- when @value@ is a 'Data.Aeson.Number' and fails using 'typeMismatch'
656-- otherwise.
701-- otherwise.
658-- /Warning/: If you are converting from a scientific to an unbounded
703-- /Warning/: If you are converting from a scientific to an unbounded
659-- type such as 'Integer' you may want to add a restriction on the
704-- type such as 'Integer' you may want to add a restriction on the
660-- size of the exponent (see 'withBoundedScientific') to prevent
705-- size of the exponent (see 'withBoundedScientific') to prevent
661-- malicious input from filling up the memory of the target system.
706-- malicious input from filling up the memory of the target system.
708+-- ==== Error message example
710+-- > withScientific "MyType" f (String "oops")
711+-- > -- Error: "parsing MyType failed, expected Number, but encountered String"
662withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
712withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
663−withScientific _ f (Number scientific) = f scientific
713+withScientific _ f (Number scientific) = f scientific
664−withScientific expected _ v = typeMismatch expected v
714+withScientific name _ v = prependContext name (typeMismatch "Number" v)
665{-# INLINE withScientific #-}
715{-# INLINE withScientific #-}
667−-- | @'withBoundedScientific' expected f value@ applies @f@ to the 'Scientific' number
717+-- | A variant of 'withScientific' which doesn't use 'prependContext', so that
668−-- when @value@ is a 'Number' and fails using @'typeMismatch' expected@
718+-- such context can be added separately in a way that also applies when the
669−-- otherwise.
719+-- continuation @f :: Scientific -> Parser a@ fails.
671−-- The conversion will also fail with a @'typeMismatch' if the
721+-- /Warning/: If you are converting from a scientific to an unbounded
672−-- 'Scientific' exponent is larger than 1024.
722+-- type such as 'Integer' you may want to add a restriction on the
723+-- size of the exponent (see 'withBoundedScientific') to prevent
724+-- malicious input from filling up the memory of the target system.
726+-- ==== Error message examples
728+-- > withScientific' f (String "oops")
729+-- > -- Error: "unexpected String"
731+-- > prependContext "MyType" (withScientific' f (String "oops"))
732+-- > -- Error: "parsing MyType failed, unexpected String"
733+withScientific' :: (Scientific -> Parser a) -> Value -> Parser a
734+withScientific' f v = case v of
736+ _ -> typeMismatch "Number" v
737+{-# INLINE withScientific' #-}
739+-- | @'withBoundedScientific' name f value@ applies @f@ to the 'Scientific' number
740+-- when @value@ is a 'Number' with exponent less than or equal to 1024.
673withBoundedScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
741withBoundedScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
674−withBoundedScientific _ f v@(Number scientific) =
742+withBoundedScientific name f v = withBoundedScientific_ (prependContext name) f v
675− if base10Exponent scientific > 1024
676− then typeMismatch "a number with exponent <= 1024" v
678−withBoundedScientific expected _ v = typeMismatch expected v
679{-# INLINE withBoundedScientific #-}
743{-# INLINE withBoundedScientific #-}
745+-- | A variant of 'withBoundedScientific' which doesn't use 'prependContext',
746+-- so that such context can be added separately in a way that also applies
747+-- when the continuation @f :: Scientific -> Parser a@ fails.
748+withBoundedScientific' :: (Scientific -> Parser a) -> Value -> Parser a
749+withBoundedScientific' f v = withBoundedScientific_ id f v
750+{-# INLINE withBoundedScientific' #-}
752+-- | A variant of 'withBoundedScientific_' parameterized by a function to apply
753+-- to the 'Parser' in case of failure.
754+withBoundedScientific_ :: (Parser a -> Parser a) -> (Scientific -> Parser a) -> Value -> Parser a
755+withBoundedScientific_ whenFail f v@(Number scientific) =
757+ then whenFail (fail msg)
760+ exponent = base10Exponent scientific
761+ msg = "found a number with exponent " ++ show exponent ++ ", but it must not be greater than 1024"
762+withBoundedScientific_ whenFail _ v =
763+ whenFail (typeMismatch "Number" v)
764+{-# INLINE withBoundedScientific_ #-}
681-- | @'withBool' expected f value@ applies @f@ to the 'Bool' when @value@ is a
766-- | @'withBool' expected f value@ applies @f@ to the 'Bool' when @value@ is a
682−-- 'Bool' and fails using @'typeMismatch' expected@ otherwise.
767+-- 'Boolean' and fails otherwise.
769+-- ==== Error message example
771+-- > withBool "MyType" f (String "oops")
772+-- > -- Error: "parsing MyType failed, expected Boolean, but encountered String"
683withBool :: String -> (Bool -> Parser a) -> Value -> Parser a
773withBool :: String -> (Bool -> Parser a) -> Value -> Parser a
684−withBool _ f (Bool arr) = f arr
774+withBool _ f (Bool arr) = f arr
685−withBool expected _ v = typeMismatch expected v
775+withBool name _ v = prependContext name (typeMismatch "Boolean" v)
686{-# INLINE withBool #-}
776{-# INLINE withBool #-}
688-- | Decode a nested JSON-encoded string.
778-- | Decode a nested JSON-encoded string.
@@ -692,7 +782,7 @@ withEmbeddedJSON _ innerParser (String txt) =
693 eitherDecode = eitherFormatError . eitherDecodeWith jsonEOF ifromJSON
783 eitherDecode = eitherFormatError . eitherDecodeWith jsonEOF ifromJSON
694 eitherFormatError = either (Left . uncurry formatError) Right
784 eitherFormatError = either (Left . uncurry formatError) Right
695−withEmbeddedJSON name _ v = typeMismatch name v
785+withEmbeddedJSON name _ v = prependContext name (typeMismatch "String" v)
696{-# INLINE withEmbeddedJSON #-}
786{-# INLINE withEmbeddedJSON #-}
698-- | Convert a value from JSON, failing if the types do not match.
788-- | Convert a value from JSON, failing if the types do not match.
@@ -807,6 +897,27 @@ instance OVERLAPPABLE_ (GFromJSON arity a) => GFromJSON arity (M1 i c a) where
807 -- parsed value:
897 -- parsed value:
808 gParseJSON opts fargs = fmap M1 . gParseJSON opts fargs
898 gParseJSON opts fargs = fmap M1 . gParseJSON opts fargs
900+-- Information for error messages
902+type TypeName = String
903+type ConName = String
905+-- | Add the name of the type being parsed to a parser's error messages.
906+contextType :: TypeName -> Parser a -> Parser a
907+contextType = prependContext
909+-- | Add the name of the constructor being parsed to a parser's error messages.
910+contextCons :: ConName -> TypeName -> Parser a -> Parser a
911+contextCons cname tname = prependContext (showCons cname tname)
913+-- | Render a constructor as @\"MyType(MyConstructor)\"@.
914+showCons :: ConName -> TypeName -> String
915+showCons cname tname = tname ++ "(" ++ cname ++ ")"
917+--------------------------------------------------------------------------------
919+-- Parsing single fields
810instance (FromJSON a) => GFromJSON arity (K1 i a) where
921instance (FromJSON a) => GFromJSON arity (K1 i a) where
811 -- Constant values are decoded using their FromJSON instance:
922 -- Constant values are decoded using their FromJSON instance:
812 gParseJSON _opts _ = fmap K1 . parseJSON
923 gParseJSON _opts _ = fmap K1 . parseJSON
@@ -821,92 +932,106 @@ instance (FromJSON1 f) => GFromJSON One (Rec1 f) where
821 -- FromJSON1 instance:
932 -- FromJSON1 instance:
822 gParseJSON _opts (From1Args pj pjl) = fmap Rec1 . liftParseJSON pj pjl
933 gParseJSON _opts (From1Args pj pjl) = fmap Rec1 . liftParseJSON pj pjl
824−instance GFromJSON arity U1 where
935+instance (FromJSON1 f, GFromJSON One g) => GFromJSON One (f :.: g) where
825− -- Empty constructors are expected to be encoded as an empty array:
936+ -- If an occurrence of the last type parameter is nested inside two
937+ -- composed types, it is decoded by using the outermost type's FromJSON1
938+ -- instance to generically decode the innermost type:
826− gParseJSON _opts _ v
939+ gParseJSON opts fargs =
827− | isEmptyArray v = pure U1
940+ let gpj = gParseJSON opts fargs in
828− | otherwise = typeMismatch "unit constructor (U1)" v
941+ fmap Comp1 . liftParseJSON gpj (listParser gpj)
943+--------------------------------------------------------------------------------
945+instance (GFromJSON' arity a, Datatype d) => GFromJSON arity (D1 d a) where
946+ -- Meta-information, which is not handled elsewhere, is just added to the
948+ gParseJSON opts fargs = fmap M1 . gParseJSON' (tname :* opts :* fargs)
950+ tname = moduleName proxy ++ "." ++ datatypeName proxy
951+ proxy = undefined :: M1 _i d _f _p
953+-- | 'GFromJSON', after unwrapping the 'D1' constructor, now carrying the data
955+class GFromJSON' arity f where
956+ gParseJSON' :: TypeName :* Options :* FromArgs arity a
960+-- | Single constructor.
830instance ( ConsFromJSON arity a
961instance ( ConsFromJSON arity a
831 , AllNullary (C1 c a) allNullary
962 , AllNullary (C1 c a) allNullary
832 , ParseSum arity (C1 c a) allNullary
963 , ParseSum arity (C1 c a) allNullary
833− ) => GFromJSON arity (D1 d (C1 c a)) where
965+ ) => GFromJSON' arity (C1 c a) where
834 -- The option 'tagSingleConstructors' determines whether to wrap
966 -- The option 'tagSingleConstructors' determines whether to wrap
835 -- a single-constructor type.
967 -- a single-constructor type.
836− gParseJSON opts fargs
968+ gParseJSON' p@(_ :* opts :* _)
837 | tagSingleConstructors opts
969 | tagSingleConstructors opts
839− . (unTagged :: Tagged allNullary (Parser (C1 c a p)) -> Parser (C1 c a p))
970+ = (unTagged :: Tagged allNullary (Parser (C1 c a p)) -> Parser (C1 c a p))
840− . parseSum opts fargs
971+ . parseSum p
841− | otherwise = fmap M1 . fmap M1 . consParseJSON opts fargs
972+ | otherwise = fmap M1 . consParseJSON (cname :* p)
843−instance (ConsFromJSON arity a) => GFromJSON arity (C1 c a) where
974+ cname = conName (undefined :: M1 _i c _f _p)
844− -- Constructors need to be decoded differently depending on whether they're
975+
845− -- a record or not. This distinction is made by consParseJSON:
976+-- | Multiple constructors.
846− gParseJSON opts fargs = fmap M1 . consParseJSON opts fargs
848−instance ( FromProduct arity a, FromProduct arity b
849− , ProductSize a, ProductSize b
850− ) => GFromJSON arity (a :*: b) where
851− -- Products are expected to be encoded to an array. Here we check whether we
852− -- got an array of the same size as the product, then parse each of the
853− -- product's elements using parseProduct:
854− gParseJSON opts fargs = withArray "product (:*:)" $ \arr ->
855− let lenArray = V.length arr
856− lenProduct = (unTagged2 :: Tagged2 (a :*: b) Int -> Int)
858− if lenArray == lenProduct
859− then parseProduct opts fargs arr 0 lenProduct
860− else fail $ "When expecting a product of " ++ show lenProduct ++
861− " values, encountered an Array of " ++ show lenArray ++
864−instance ( AllNullary (a :+: b) allNullary
977+instance ( AllNullary (a :+: b) allNullary
865− , ParseSum arity (a :+: b) allNullary
978+ , ParseSum arity (a :+: b) allNullary
866− ) => GFromJSON arity (a :+: b) where
979+ ) => GFromJSON' arity (a :+: b) where
867 -- If all constructors of a sum datatype are nullary and the
980 -- If all constructors of a sum datatype are nullary and the
868 -- 'allNullaryToStringTag' option is set they are expected to be
981 -- 'allNullaryToStringTag' option is set they are expected to be
869 -- encoded as strings. This distinction is made by 'parseSum':
982 -- encoded as strings. This distinction is made by 'parseSum':
870− gParseJSON opts fargs =
983+ gParseJSON' p =
871− (unTagged :: Tagged allNullary (Parser ((a :+: b) d)) ->
984+ (unTagged :: Tagged allNullary (Parser ((a :+: b) _d)) ->
872− Parser ((a :+: b) d))
985+ Parser ((a :+: b) _d))
873− . parseSum opts fargs
986+ . parseSum p
875−instance (FromJSON1 f, GFromJSON One g) => GFromJSON One (f :.: g) where
876− -- If an occurrence of the last type parameter is nested inside two
877− -- composed types, it is decoded by using the outermost type's FromJSON1
878− -- instance to generically decode the innermost type:
879− gParseJSON opts fargs =
880− let gpj = gParseJSON opts fargs in
881− fmap Comp1 . liftParseJSON gpj (listParser gpj)
883--------------------------------------------------------------------------------
988--------------------------------------------------------------------------------
885class ParseSum arity f allNullary where
990class ParseSum arity f allNullary where
886− parseSum :: Options -> FromArgs arity a
991+ parseSum :: TypeName :* Options :* FromArgs arity a
887− -> Value -> Tagged allNullary (Parser (f a))
993+ -> Tagged allNullary (Parser (f a))
995+instance ( ConstructorNames f
889−instance ( SumFromString f
996+ , SumFromString f
890 , FromPair arity f
997 , FromPair arity f
891 , FromTaggedObject arity f
998 , FromTaggedObject arity f
892 , FromUntaggedValue arity f
999 , FromUntaggedValue arity f
893 ) => ParseSum arity f True where
1000 ) => ParseSum arity f True where
894− parseSum opts fargs
1001+ parseSum p@(tname :* opts :* _)
895− | allNullaryToStringTag opts = Tagged . parseAllNullarySum opts
1002+ | allNullaryToStringTag opts = Tagged . parseAllNullarySum tname opts
896− | otherwise = Tagged . parseNonAllNullarySum opts fargs
1003+ | otherwise = Tagged . parseNonAllNullarySum p
1005+instance ( ConstructorNames f
898−instance ( FromPair arity f
1006+ , FromPair arity f
899 , FromTaggedObject arity f
1007 , FromTaggedObject arity f
900 , FromUntaggedValue arity f
1008 , FromUntaggedValue arity f
901 ) => ParseSum arity f False where
1009 ) => ParseSum arity f False where
902− parseSum opts fargs = Tagged . parseNonAllNullarySum opts fargs
1010+ parseSum p = Tagged . parseNonAllNullarySum p
904--------------------------------------------------------------------------------
1012--------------------------------------------------------------------------------
906−parseAllNullarySum :: SumFromString f => Options -> Value -> Parser (f a)
1014+parseAllNullarySum :: (SumFromString f, ConstructorNames f)
1015+ => TypeName -> Options -> Value -> Parser (f a)
907−parseAllNullarySum opts = withText "Text" $ \key ->
1016+parseAllNullarySum tname opts =
1017+ withText tname $ \tag ->
908− maybe (notFound key) return $
1018+ maybe (badTag tag) return $
909− parseSumFromString opts key
1019+ parseSumFromString opts tag
1021+ badTag tag = failWithCTags tname opts $ \cnames ->
1022+ "expected one of the tags " ++ show cnames ++
1023+ ", but found tag " ++ show tag
1025+-- | Fail with an informative error message about a mismatched tag.
1026+-- The error message is parameterized by the list of expected tags,
1027+-- to be inferred from the result type of the parser.
1029+ :: forall f a. ConstructorNames f
1030+ => TypeName -> Options -> ([String] -> String) -> Parser (f a)
1031+failWithCTags tname opts f =
1032+ contextType tname . fail $ f cnames
1034+ cnames = unTagged2 (constructorTags opts :: Tagged2 f [String])
911class SumFromString f where
1036class SumFromString f where
912 parseSumFromString :: Options -> Text -> Maybe (f a)
1037 parseSumFromString :: Options -> Text -> Maybe (f a)
@@ -920,243 +1045,339 @@ instance (Constructor c) => SumFromString (C1 c U1) where
920 | otherwise = Nothing
1045 | otherwise = Nothing
922 name = pack $ constructorTagModifier opts $
1047 name = pack $ constructorTagModifier opts $
923− conName (undefined :: t c U1 p)
1048+ conName (undefined :: M1 _i c _f _p)
1050+-- | List of all constructor tags.
1051+constructorTags :: ConstructorNames a => Options -> Tagged2 a [String]
1052+constructorTags opts =
1053+ fmap DList.toList (constructorNames' (constructorTagModifier opts))
1055+-- | List of all constructor names of an ADT, after a given conversion
1056+-- function. (Better inlining.)
1057+class ConstructorNames a where
1058+ constructorNames' :: (String -> t) -> Tagged2 a (DList.DList t)
1060+instance (ConstructorNames a, ConstructorNames b) => ConstructorNames (a :+: b) where
1061+ constructorNames' = liftA2 append constructorNames' constructorNames'
1064+ :: Tagged2 a (DList.DList t)
1065+ -> Tagged2 b (DList.DList t)
1066+ -> Tagged2 (a :+: b) (DList.DList t)
1067+ append (Tagged2 xs) (Tagged2 ys) = Tagged2 (DList.append xs ys)
1069+instance Constructor c => ConstructorNames (C1 c a) where
1070+ constructorNames' f = Tagged2 (pure (f cname))
1072+ cname = conName (undefined :: M1 _i c _f _p)
925--------------------------------------------------------------------------------
1074--------------------------------------------------------------------------------
927parseNonAllNullarySum :: ( FromPair arity f
1076parseNonAllNullarySum :: ( FromPair arity f
928 , FromTaggedObject arity f
1077 , FromTaggedObject arity f
929 , FromUntaggedValue arity f
1078 , FromUntaggedValue arity f
1079+ , ConstructorNames f
930− ) => Options -> FromArgs arity c
1080+ ) => TypeName :* Options :* FromArgs arity c
931 -> Value -> Parser (f c)
1081 -> Value -> Parser (f c)
932−parseNonAllNullarySum opts fargs =
1082+parseNonAllNullarySum p@(tname :* opts :* _) =
933 case sumEncoding opts of
1083 case sumEncoding opts of
934 TaggedObject{..} ->
1084 TaggedObject{..} ->
935− withObject "Object" $ \obj -> do
1085+ withObject tname $ \obj -> do
936− tag <- obj .: pack tagFieldName
1086+ tag <- contextType tname $ obj .: tagKey
937− fromMaybe (notFound tag) $
1087+ fromMaybe (badTag tag <?> Key tagKey) $
938− parseFromTaggedObject opts fargs contentsFieldName obj tag
1088+ parseFromTaggedObject (tag :* contentsFieldName :* p) obj
1090+ tagKey = pack tagFieldName
1091+ badTag tag = failWith_ $ \cnames ->
1092+ "expected tag field to be one of " ++ show cnames ++
1093+ ", but found tag " ++ show tag
940 ObjectWithSingleField ->
1095 ObjectWithSingleField ->
941− withObject "Object" $ \obj ->
942− case H.toList obj of
1096+ withObject tname $ \obj -> case H.toList obj of
943− [pair@(tag, _)] -> fromMaybe (notFound tag) $
1097+ [(tag, v)] -> maybe (badTag tag) (<?> Key tag) $
944− parsePair opts fargs pair
1098+ parsePair (tag :* p) v
945− _ -> fail "Object doesn't have a single field"
1099+ _ -> contextType tname . fail $
1100+ "expected an Object with a single pair, but found " ++
1101+ show (H.size obj) ++ " pairs"
1103+ badTag tag = failWith_ $ \cnames ->
1104+ "expected an Object with a single pair where the tag is one of " ++
1105+ show cnames ++ ", but found tag " ++ show tag
947 TwoElemArray ->
1107 TwoElemArray ->
948− withArray "Array" $ \arr ->
1108+ withArray tname $ \arr -> case V.length arr of
949− if V.length arr == 2
1109+ 2 | String tag <- V.unsafeIndex arr 0 ->
950− then case V.unsafeIndex arr 0 of
1110+ maybe (badTag tag <?> Index 0) (<?> Index 1) $
951− String tag -> fromMaybe (notFound tag) $
952− parsePair opts fargs (tag, V.unsafeIndex arr 1)
1111+ parsePair (tag :* p) (V.unsafeIndex arr 1)
1113+ contextType tname $
953− _ -> fail "First element is not a String"
1114+ fail "tag element is not a String" <?> Index 0
954− else fail "Array doesn't have 2 elements"
1115+ len -> contextType tname . fail $
1116+ "expected a 2-element Array, but encountered an Array of length " ++
1119+ badTag tag = failWith_ $ \cnames ->
1120+ "expected tag of the 2-element Array to be one of " ++
1121+ show cnames ++ ", but found tag " ++ show tag
956− UntaggedValue -> parseUntaggedValue opts fargs
1123+ UntaggedValue -> parseUntaggedValue p
1125+ failWith_ = failWithCTags tname opts
958--------------------------------------------------------------------------------
1127--------------------------------------------------------------------------------
960class FromTaggedObject arity f where
1129class FromTaggedObject arity f where
1130+ -- The first two components of the parameter tuple are: the constructor tag
1131+ -- to match against, and the contents field name.
961− parseFromTaggedObject :: Options -> FromArgs arity a
1132+ parseFromTaggedObject
1133+ :: Text :* String :* TypeName :* Options :* FromArgs arity a
962− -> String -> Object
1134+ -> Object
963− -> Text -> Maybe (Parser (f a))
1135+ -> Maybe (Parser (f a))
965instance ( FromTaggedObject arity a, FromTaggedObject arity b) =>
1137instance ( FromTaggedObject arity a, FromTaggedObject arity b) =>
966 FromTaggedObject arity (a :+: b) where
1138 FromTaggedObject arity (a :+: b) where
967− parseFromTaggedObject opts fargs contentsFieldName obj tag =
1139+ parseFromTaggedObject p obj =
968− (fmap L1 <$> parseFromTaggedObject opts fargs contentsFieldName obj tag) <|>
1140+ (fmap L1 <$> parseFromTaggedObject p obj) <|>
969− (fmap R1 <$> parseFromTaggedObject opts fargs contentsFieldName obj tag)
1141+ (fmap R1 <$> parseFromTaggedObject p obj)
1143+instance ( IsRecord f isRecord
971−instance ( FromTaggedObject' arity f
1144+ , FromTaggedObject' arity f isRecord
972 , Constructor c
1145 , Constructor c
973 ) => FromTaggedObject arity (C1 c f) where
1146 ) => FromTaggedObject arity (C1 c f) where
974− parseFromTaggedObject opts fargs contentsFieldName obj tag
1147+ parseFromTaggedObject (tag :* contentsFieldName :* p@(_ :* opts :* _))
1150+ (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a)) .
975− | tag == name = Just $ M1 <$> parseFromTaggedObject'
1151+ parseFromTaggedObject' (contentsFieldName :* cname :* p)
976− opts fargs contentsFieldName obj
977− | otherwise = Nothing
1152+ | otherwise = const Nothing
979− name = pack $ constructorTagModifier opts $
1154+ tag' = pack $ constructorTagModifier opts cname
980− conName (undefined :: t c f p)
1155+ cname = conName (undefined :: M1 _i c _f _p)
982--------------------------------------------------------------------------------
1157--------------------------------------------------------------------------------
984−class FromTaggedObject' arity f where
1159+class FromTaggedObject' arity f isRecord where
985− parseFromTaggedObject' :: Options -> FromArgs arity a -> String
1160+ -- The first component of the parameter tuple is the contents field name.
986− -> Object -> Parser (f a)
1161+ parseFromTaggedObject'
988−class FromTaggedObject'' arity f isRecord where
989− parseFromTaggedObject'' :: Options -> FromArgs arity a -> String
1162+ :: String :* ConName :* TypeName :* Options :* FromArgs arity a
990− -> Object -> Tagged isRecord (Parser (f a))
1163+ -> Object -> Tagged isRecord (Parser (f a))
992−instance ( IsRecord f isRecord
993− , FromTaggedObject'' arity f isRecord
994− ) => FromTaggedObject' arity f where
995− parseFromTaggedObject' opts fargs contentsFieldName =
996− (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a)) .
997− parseFromTaggedObject'' opts fargs contentsFieldName
999−instance (FromRecord arity f) => FromTaggedObject'' arity f True where
1165+instance (RecordFromJSON arity f) => FromTaggedObject' arity f True where
1166+ -- Records are unpacked in the tagged object
1000− parseFromTaggedObject'' opts fargs _ =
1167+ parseFromTaggedObject' (_ :* p) = Tagged . recordParseJSON p
1001− Tagged . parseRecord opts fargs
1168+
1003−instance (GFromJSON arity f) => FromTaggedObject'' arity f False where
1169+instance (ConsFromJSON arity f) => FromTaggedObject' arity f False where
1170+ -- Nonnullary nonrecords are encoded in the contents field
1004− parseFromTaggedObject'' opts fargs contentsFieldName = Tagged .
1171+ parseFromTaggedObject' p obj = Tagged $ do
1172+ contents <- contextCons cname tname (obj .: key)
1173+ consParseJSON p' contents <?> Key key
1005− (gParseJSON opts fargs <=< (.: pack contentsFieldName))
1175+ key = pack contentsFieldName
1176+ contentsFieldName :* p'@(cname :* tname :* _) = p
1007−instance OVERLAPPING_ FromTaggedObject'' arity U1 False where
1178+instance OVERLAPPING_ FromTaggedObject' arity U1 False where
1179+ -- Nullary constructors don't need a contents field
1008− parseFromTaggedObject'' _ _ _ _ = Tagged (pure U1)
1180+ parseFromTaggedObject' _ _ = Tagged (pure U1)
1010--------------------------------------------------------------------------------
1182--------------------------------------------------------------------------------
1184+-- | Constructors need to be decoded differently depending on whether they're
1185+-- a record or not. This distinction is made by 'ConsParseJSON'.
1012class ConsFromJSON arity f where
1186class ConsFromJSON arity f where
1013− consParseJSON :: Options -> FromArgs arity a
1188+ :: ConName :* TypeName :* Options :* FromArgs arity a
1014− -> Value -> Parser (f a)
1189+ -> Value -> Parser (f a)
1016class ConsFromJSON' arity f isRecord where
1191class ConsFromJSON' arity f isRecord where
1017− consParseJSON' :: Options -> FromArgs arity a
1193+ :: ConName :* TypeName :* Options :* FromArgs arity a
1018− -> Value -> Tagged isRecord (Parser (f a))
1194+ -> Value -> Tagged isRecord (Parser (f a))
1020instance ( IsRecord f isRecord
1196instance ( IsRecord f isRecord
1021 , ConsFromJSON' arity f isRecord
1197 , ConsFromJSON' arity f isRecord
1022 ) => ConsFromJSON arity f where
1198 ) => ConsFromJSON arity f where
1023− consParseJSON opts fargs =
1199+ consParseJSON p =
1024 (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a))
1200 (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a))
1025− . consParseJSON' opts fargs
1201+ . consParseJSON' p
1027instance OVERLAPPING_
1203instance OVERLAPPING_
1028− ( GFromJSON arity a, FromRecord arity (S1 s a)
1204+ ( GFromJSON arity a, RecordFromJSON arity (S1 s a)
1029 ) => ConsFromJSON' arity (S1 s a) True where
1205 ) => ConsFromJSON' arity (S1 s a) True where
1030− consParseJSON' opts fargs
1206+ consParseJSON' p@(cname :* tname :* opts :* fargs)
1031− | unwrapUnaryRecords opts = Tagged . gParseJSON opts fargs
1207+ | unwrapUnaryRecords opts = Tagged . fmap M1 . gParseJSON opts fargs
1032− | otherwise = Tagged . withObject "unary record" (parseRecord opts fargs)
1208+ | otherwise = Tagged . withObject (showCons cname tname) (recordParseJSON p)
1210+instance RecordFromJSON arity f => ConsFromJSON' arity f True where
1211+ consParseJSON' p@(cname :* tname :* _) =
1212+ Tagged . withObject (showCons cname tname) (recordParseJSON p)
1214+instance OVERLAPPING_
1215+ ConsFromJSON' arity U1 False where
1216+ -- Empty constructors are expected to be encoded as an empty array:
1217+ consParseJSON' (cname :* tname :* _) v =
1218+ Tagged . contextCons cname tname $ case v of
1219+ Array a | V.null a -> pure U1
1220+ | otherwise -> fail_ a
1221+ _ -> typeMismatch "Array" v
1224+ "expected an empty Array, but encountered an Array of length " ++
1227+instance OVERLAPPING_
1034−instance FromRecord arity f => ConsFromJSON' arity f True where
1228+ GFromJSON arity f => ConsFromJSON' arity (S1 s f) False where
1035− consParseJSON' opts fargs =
1229+ consParseJSON' (_ :* _ :* opts :* fargs) =
1036− Tagged . withObject "record (:*:)" (parseRecord opts fargs)
1230+ Tagged . fmap M1 . gParseJSON opts fargs
1232+instance (ProductFromJSON arity f, ProductSize f
1038−instance GFromJSON arity f => ConsFromJSON' arity f False where
1233+ ) => ConsFromJSON' arity f False where
1039− consParseJSON' opts fargs = Tagged . gParseJSON opts fargs
1234+ consParseJSON' p = Tagged . productParseJSON0 p
1041--------------------------------------------------------------------------------
1236--------------------------------------------------------------------------------
1043−class FromRecord arity f where
1238+class RecordFromJSON arity f where
1044− parseRecord :: Options -> FromArgs arity a
1240+ :: ConName :* TypeName :* Options :* FromArgs arity a
1045− -> Object -> Parser (f a)
1241+ -> Object -> Parser (f a)
1047−instance ( FromRecord arity a
1243+instance ( RecordFromJSON arity a
1048− , FromRecord arity b
1244+ , RecordFromJSON arity b
1049− ) => FromRecord arity (a :*: b) where
1245+ ) => RecordFromJSON arity (a :*: b) where
1050− parseRecord opts fargs obj =
1246+ recordParseJSON p obj =
1051− (:*:) <$> parseRecord opts fargs obj
1247+ (:*:) <$> recordParseJSON p obj
1052− <*> parseRecord opts fargs obj
1248+ <*> recordParseJSON p obj
1054instance OVERLAPPABLE_ (Selector s, GFromJSON arity a) =>
1250instance OVERLAPPABLE_ (Selector s, GFromJSON arity a) =>
1055− FromRecord arity (S1 s a) where
1251+ RecordFromJSON arity (S1 s a) where
1056− parseRecord opts fargs =
1252+ recordParseJSON (cname :* tname :* opts :* fargs) obj = do
1057− (<?> Key label) . gParseJSON opts fargs <=< (.: label)
1253+ fv <- contextCons cname tname (obj .: label)
1254+ M1 <$> gParseJSON opts fargs fv <?> Key label
1059− label = pack . fieldLabelModifier opts $ selName (undefined :: t s a p)
1256+ label = pack $ fieldLabelModifier opts sname
1257+ sname = selName (undefined :: M1 _i s _f _p)
1061instance INCOHERENT_ (Selector s, FromJSON a) =>
1259instance INCOHERENT_ (Selector s, FromJSON a) =>
1062− FromRecord arity (S1 s (K1 i (Maybe a))) where
1260+ RecordFromJSON arity (S1 s (K1 i (Maybe a))) where
1063− parseRecord opts _ obj = M1 . K1 <$> obj .:? pack label
1261+ recordParseJSON (_ :* _ :* opts :* _) obj = M1 . K1 <$> obj .:? pack label
1065− label = fieldLabelModifier opts $
1263+ label = fieldLabelModifier opts sname
1066− selName (undefined :: t s (K1 i (Maybe a)) p)
1264+ sname = selName (undefined :: M1 _i s _f _p)
1068-- Parse an Option like a Maybe.
1266-- Parse an Option like a Maybe.
1069instance INCOHERENT_ (Selector s, FromJSON a) =>
1267instance INCOHERENT_ (Selector s, FromJSON a) =>
1070− FromRecord arity (S1 s (K1 i (Semigroup.Option a))) where
1268+ RecordFromJSON arity (S1 s (K1 i (Semigroup.Option a))) where
1071− parseRecord opts fargs obj = wrap <$> parseRecord opts fargs obj
1269+ recordParseJSON p obj = wrap <$> recordParseJSON p obj
1073 wrap :: S1 s (K1 i (Maybe a)) p -> S1 s (K1 i (Semigroup.Option a)) p
1271 wrap :: S1 s (K1 i (Maybe a)) p -> S1 s (K1 i (Semigroup.Option a)) p
1074 wrap (M1 (K1 a)) = M1 (K1 (Semigroup.Option a))
1272 wrap (M1 (K1 a)) = M1 (K1 (Semigroup.Option a))
1076--------------------------------------------------------------------------------
1274--------------------------------------------------------------------------------
1277+ :: forall f arity a. (ProductFromJSON arity f, ProductSize f)
1278+ => ConName :* TypeName :* Options :* FromArgs arity a
1279+ -> Value -> Parser (f a)
1280+ -- Products are expected to be encoded to an array. Here we check whether we
1281+ -- got an array of the same size as the product, then parse each of the
1282+ -- product's elements using productParseJSON:
1283+productParseJSON0 p@(cname :* tname :* _ :* _) =
1284+ withArray (showCons cname tname) $ \arr ->
1285+ let lenArray = V.length arr
1286+ lenProduct = (unTagged2 :: Tagged2 f Int -> Int)
1288+ if lenArray == lenProduct
1289+ then productParseJSON p arr 0 lenProduct
1290+ else contextCons cname tname $
1291+ fail $ "expected an Array of length " ++ show lenProduct ++
1292+ ", but encountered an Array of length " ++ show lenArray
1078−class FromProduct arity f where
1296+class ProductFromJSON arity f where
1079− parseProduct :: Options -> FromArgs arity a
1297+ productParseJSON :: ConName :* TypeName :* Options :* FromArgs arity a
1080 -> Array -> Int -> Int
1298 -> Array -> Int -> Int
1081 -> Parser (f a)
1299 -> Parser (f a)
1083−instance ( FromProduct arity a
1301+instance ( ProductFromJSON arity a
1084− , FromProduct arity b
1302+ , ProductFromJSON arity b
1085− ) => FromProduct arity (a :*: b) where
1303+ ) => ProductFromJSON arity (a :*: b) where
1086− parseProduct opts fargs arr ix len =
1304+ productParseJSON p arr ix len =
1087− (:*:) <$> parseProduct opts fargs arr ix lenL
1305+ (:*:) <$> productParseJSON p arr ix lenL
1088− <*> parseProduct opts fargs arr ixR lenR
1306+ <*> productParseJSON p arr ixR lenR
1090 lenL = len `unsafeShiftR` 1
1308 lenL = len `unsafeShiftR` 1
1091 ixR = ix + lenL
1309 ixR = ix + lenL
1092 lenR = len - lenL
1310 lenR = len - lenL
1094−instance (GFromJSON arity a) => FromProduct arity (S1 s a) where
1312+instance (GFromJSON arity a) => ProductFromJSON arity (S1 s a) where
1095− parseProduct opts fargs arr ix _ =
1313+ productParseJSON (_ :* _ :* opts :* fargs) arr ix _ =
1096− gParseJSON opts fargs $ V.unsafeIndex arr ix
1314+ M1 <$> gParseJSON opts fargs (V.unsafeIndex arr ix) <?> Index ix
1098--------------------------------------------------------------------------------
1316--------------------------------------------------------------------------------
1100class FromPair arity f where
1318class FromPair arity f where
1319+ -- The first component of the parameter tuple is the tag to match.
1101− parsePair :: Options -> FromArgs arity a
1320+ parsePair :: Text :* TypeName :* Options :* FromArgs arity a
1102− -> Pair -> Maybe (Parser (f a))
1322+ -> Maybe (Parser (f a))
1104instance ( FromPair arity a
1324instance ( FromPair arity a
1105 , FromPair arity b
1325 , FromPair arity b
1106 ) => FromPair arity (a :+: b) where
1326 ) => FromPair arity (a :+: b) where
1107− parsePair opts fargs pair = (fmap L1 <$> parsePair opts fargs pair) <|>
1328+ (fmap L1 <$> parsePair p pair) <|>
1108− (fmap R1 <$> parsePair opts fargs pair)
1329+ (fmap R1 <$> parsePair p pair)
1110instance ( Constructor c
1331instance ( Constructor c
1111− , GFromJSON arity a
1112 , ConsFromJSON arity a
1332 , ConsFromJSON arity a
1113 ) => FromPair arity (C1 c a) where
1333 ) => FromPair arity (C1 c a) where
1114− parsePair opts fargs (tag, value)
1334+ parsePair (tag :* p@(_ :* opts :* _)) v
1115− | tag == tag' = Just $ gParseJSON opts fargs value
1335+ | tag == tag' = Just $ M1 <$> consParseJSON (cname :* p) v
1116 | otherwise = Nothing
1336 | otherwise = Nothing
1118− tag' = pack $ constructorTagModifier opts $
1338+ tag' = pack $ constructorTagModifier opts cname
1119− conName (undefined :: t c a p)
1339+ cname = conName (undefined :: M1 _i c _a _p)
1121--------------------------------------------------------------------------------
1341--------------------------------------------------------------------------------
1123class FromUntaggedValue arity f where
1343class FromUntaggedValue arity f where
1124− parseUntaggedValue :: Options -> FromArgs arity a
1344+ parseUntaggedValue :: TypeName :* Options :* FromArgs arity a
1125− -> Value -> Parser (f a)
1346+ -> Parser (f a)
1128 ( FromUntaggedValue arity a
1349 ( FromUntaggedValue arity a
1129 , FromUntaggedValue arity b
1350 , FromUntaggedValue arity b
1130 ) => FromUntaggedValue arity (a :+: b)
1351 ) => FromUntaggedValue arity (a :+: b)
1132− parseUntaggedValue opts fargs value =
1353+ parseUntaggedValue p value =
1133− L1 <$> parseUntaggedValue opts fargs value <|>
1354+ L1 <$> parseUntaggedValue p value <|>
1134− R1 <$> parseUntaggedValue opts fargs value
1355+ R1 <$> parseUntaggedValue p value
1136instance OVERLAPPABLE_
1357instance OVERLAPPABLE_
1137− ( GFromJSON arity a
1358+ ( ConsFromJSON arity a
1138− , ConsFromJSON arity a
1359+ , Constructor c
1139 ) => FromUntaggedValue arity (C1 c a)
1360 ) => FromUntaggedValue arity (C1 c a)
1141− parseUntaggedValue = gParseJSON
1362+ parseUntaggedValue p = fmap M1 . consParseJSON (cname :* p)
1364+ cname = conName (undefined :: M1 _i c _f _p)
1143instance OVERLAPPING_
1366instance OVERLAPPING_
1144 ( Constructor c )
1367 ( Constructor c )
1145 => FromUntaggedValue arity (C1 c U1)
1368 => FromUntaggedValue arity (C1 c U1)
1147− parseUntaggedValue opts _ (String s)
1370+ parseUntaggedValue (tname :* opts :* _) v =
1148− | s == pack (constructorTagModifier opts (conName (undefined :: t c U1 p))) =
1371+ contextCons cname tname $ case v of
1149− pure $ M1 U1
1373+ | tag == tag' -> pure $ M1 U1
1150− | otherwise =
1374+ | otherwise -> fail_ tag
1151− fail $ "Invalid tag: " ++ unpack s
1375+ _ -> typeMismatch "String" v
1152− parseUntaggedValue _ _ v = typeMismatch (conName (undefined :: t c U1 p)) v
1376+ where
1153−
1377+ tag' = pack $ constructorTagModifier opts cname
1154−
1378+ cname = conName (undefined :: M1 _i c _f _p)
1155−--------------------------------------------------------------------------------
1379+ fail_ tag = fail $
1156−
1380+ "expected tag " ++ show tag' ++ ", but found tag " ++ show tag
1157−notFound :: Text -> Parser a
1158−notFound key = fail $ "The key \"" ++ unpack key ++ "\" was not found"
1159−{-# INLINE notFound #-}
1161-------------------------------------------------------------------------------
1382-------------------------------------------------------------------------------
1162-- Instances
1383-- Instances
@@ -1219,14 +1440,15 @@ instance FromJSON Void where
1219 {-# INLINE parseJSON #-}
1440 {-# INLINE parseJSON #-}
1221instance FromJSON Bool where
1442instance FromJSON Bool where
1222− parseJSON = withBool "Bool" pure
1443+ parseJSON (Bool b) = pure b
1444+ parseJSON v = typeMismatch "Bool" v
1223 {-# INLINE parseJSON #-}
1445 {-# INLINE parseJSON #-}
1225instance FromJSONKey Bool where
1447instance FromJSONKey Bool where
1226 fromJSONKey = FromJSONKeyTextParser $ \t -> case t of
1448 fromJSONKey = FromJSONKeyTextParser $ \t -> case t of
1227 "true" -> pure True
1449 "true" -> pure True
1228 "false" -> pure False
1450 "false" -> pure False
1229− _ -> fail $ "Cannot parse key into Bool: " ++ T.unpack t
1451+ _ -> fail $ "cannot parse key " ++ show t ++ " into Bool"
1231instance FromJSON Ordering where
1453instance FromJSON Ordering where
1232 parseJSON = withText "Ordering" $ \s ->
1454 parseJSON = withText "Ordering" $ \s ->
@@ -1234,25 +1456,30 @@ instance FromJSON Ordering where
1234 "LT" -> return LT
1456 "LT" -> return LT
1235 "EQ" -> return EQ
1457 "EQ" -> return EQ
1236 "GT" -> return GT
1458 "GT" -> return GT
1459+ _ -> fail $ "parsing Ordering failed, unexpected " ++ show s ++
1237− _ -> fail "Parsing Ordering value failed: expected \"LT\", \"EQ\", or \"GT\""
1460+ " (expected \"LT\", \"EQ\", or \"GT\")"
1239instance FromJSON () where
1462instance FromJSON () where
1240 parseJSON = withArray "()" $ \v ->
1463 parseJSON = withArray "()" $ \v ->
1241 if V.null v
1464 if V.null v
1242 then pure ()
1465 then pure ()
1243− else fail "Expected an empty array"
1466+ else prependContext "()" $ fail "expected an empty array"
1244 {-# INLINE parseJSON #-}
1467 {-# INLINE parseJSON #-}
1246instance FromJSON Char where
1469instance FromJSON Char where
1247− parseJSON = withText "Char" $ \t ->
1470+ parseJSON = withText "Char" parseChar
1248− if T.compareLength t 1 == EQ
1249− then pure $ T.head t
1250− else fail "Expected a string of length 1"
1251 {-# INLINE parseJSON #-}
1471 {-# INLINE parseJSON #-}
1253− parseJSONList = withText "String" $ pure . T.unpack
1473+ parseJSONList (String s) = pure (T.unpack s)
1474+ parseJSONList v = typeMismatch "String" v
1254 {-# INLINE parseJSONList #-}
1475 {-# INLINE parseJSONList #-}
1477+parseChar :: Text -> Parser Char
1479+ if T.compareLength t 1 == EQ
1480+ then pure $ T.head t
1481+ else prependContext "Char" $ fail "expected a string of length 1"
1256instance FromJSON Double where
1483instance FromJSON Double where
1257 parseJSON = parseRealFloat "Double"
1484 parseJSON = parseRealFloat "Double"
1258 {-# INLINE parseJSON #-}
1485 {-# INLINE parseJSON #-}
@@ -1289,7 +1516,7 @@ instance (FromJSON a, Integral a) => FromJSON (Ratio a) where
1289-- newtype 'Scientific' and provide your own instance using
1516-- newtype 'Scientific' and provide your own instance using
1290-- 'withScientific' if you want to allow larger inputs.
1517-- 'withScientific' if you want to allow larger inputs.
1291instance HasResolution a => FromJSON (Fixed a) where
1518instance HasResolution a => FromJSON (Fixed a) where
1292− parseJSON = withBoundedScientific "Fixed" $ pure . realToFrac
1519+ parseJSON = prependContext "Fixed" . withBoundedScientific' (pure . realToFrac)
1293 {-# INLINE parseJSON #-}
1520 {-# INLINE parseJSON #-}
1295instance FromJSON Int where
1522instance FromJSON Int where
@@ -1312,19 +1539,20 @@ instance FromJSONKey Integer where
1313instance FromJSON Natural where
1540instance FromJSON Natural where
1314 parseJSON value = do
1541 parseJSON value = do
1315− integer :: Integer <- parseIntegral "Natural" value
1542+ integer <- parseIntegral "Natural" value
1316− if integer < 0 then
1543+ parseNatural integer
1317− fail $ "expected Natural, encountered negative number " <> show integer
1319− pure $ fromIntegral integer
1321instance FromJSONKey Natural where
1545instance FromJSONKey Natural where
1322 fromJSONKey = FromJSONKeyTextParser $ \text -> do
1546 fromJSONKey = FromJSONKeyTextParser $ \text -> do
1323− integer :: Integer <- parseIntegralText "Natural" text
1547+ integer <- parseIntegralText "Natural" text
1548+ parseNatural integer
1550+parseNatural :: Integer -> Parser Natural
1551+parseNatural integer =
1324− if integer < 0 then
1552+ if integer < 0 then
1325− fail $ "expected Natural, encountered negative number " <> show integer
1553+ fail $ "parsing Natural failed, unexpected negative number " <> show integer
1327− pure $ fromIntegral integer
1555+ pure $ fromIntegral integer
1329instance FromJSON Int8 where
1557instance FromJSON Int8 where
1330 parseJSON = parseBoundedIntegral "Int8"
1558 parseJSON = parseBoundedIntegral "Int8"
@@ -1421,17 +1649,17 @@ parseVersionText = go . readP_to_S parseVersion . unpack
1422 go [(v,[])] = return v
1650 go [(v,[])] = return v
1423 go (_ : xs) = go xs
1651 go (_ : xs) = go xs
1424− go _ = fail "could not parse Version"
1652+ go _ = fail "parsing Version failed"
1426-------------------------------------------------------------------------------
1654-------------------------------------------------------------------------------
1427-- semigroups NonEmpty
1655-- semigroups NonEmpty
1428-------------------------------------------------------------------------------
1656-------------------------------------------------------------------------------
1430instance FromJSON1 NonEmpty where
1658instance FromJSON1 NonEmpty where
1431− liftParseJSON p _ = withArray "NonEmpty a" $
1659+ liftParseJSON p _ = withArray "NonEmpty" $
1432 (>>= ne) . Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
1660 (>>= ne) . Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
1434− ne [] = fail "Expected a NonEmpty but got an empty list"
1662+ ne [] = fail "parsing NonEmpty failed, unpexpected empty list"
1435 ne (x:xs) = pure (x :| xs)
1663 ne (x:xs) = pure (x :| xs)
1436 {-# INLINE liftParseJSON #-}
1664 {-# INLINE liftParseJSON #-}
@@ -1452,7 +1680,7 @@ instance FromJSON Scientific where
1452-------------------------------------------------------------------------------
1680-------------------------------------------------------------------------------
1454instance FromJSON1 DList.DList where
1682instance FromJSON1 DList.DList where
1455− liftParseJSON p _ = withArray "DList a" $
1683+ liftParseJSON p _ = withArray "DList" $
1456 fmap DList.fromList .
1684 fmap DList.fromList .
1457 Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
1685 Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
1458 {-# INLINE liftParseJSON #-}
1686 {-# INLINE liftParseJSON #-}
@@ -1529,7 +1757,7 @@ instance (FromJSON1 f, FromJSON1 g) => FromJSON1 (Sum f g) where
1529 inr = "InR"
1757 inr = "InR"
1531 liftParseJSON _ _ _ = fail $
1759 liftParseJSON _ _ _ = fail $
1532− "expected an object with a single property " ++
1760+ "parsing Sum failed, expected an object with a single property " ++
1533 "where the property key should be either " ++
1761 "where the property key should be either " ++
1534 "\"InL\" or \"InR\""
1762 "\"InL\" or \"InR\""
1535 {-# INLINE liftParseJSON #-}
1763 {-# INLINE liftParseJSON #-}
@@ -1543,7 +1771,7 @@ instance (FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Sum f g a) where
1543-------------------------------------------------------------------------------
1771-------------------------------------------------------------------------------
1545instance FromJSON1 Seq.Seq where
1773instance FromJSON1 Seq.Seq where
1546− liftParseJSON p _ = withArray "Seq a" $
1774+ liftParseJSON p _ = withArray "Seq" $
1547 fmap Seq.fromList .
1775 fmap Seq.fromList .
1548 Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
1776 Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
1549 {-# INLINE liftParseJSON #-}
1777 {-# INLINE liftParseJSON #-}
@@ -1577,13 +1805,13 @@ instance FromJSON a => FromJSON (IntMap.IntMap a) where
1578instance (FromJSONKey k, Ord k) => FromJSON1 (M.Map k) where
1806instance (FromJSONKey k, Ord k) => FromJSON1 (M.Map k) where
1579 liftParseJSON p _ = case fromJSONKey of
1807 liftParseJSON p _ = case fromJSONKey of
1580− FromJSONKeyCoerce _-> withObject "Map k v" $
1808+ FromJSONKeyCoerce _ -> withObject "Map" $
1581 fmap (H.foldrWithKey (M.insert . unsafeCoerce) M.empty) . H.traverseWithKey (\k v -> p v <?> Key k)
1809 fmap (H.foldrWithKey (M.insert . unsafeCoerce) M.empty) . H.traverseWithKey (\k v -> p v <?> Key k)
1582− FromJSONKeyText f -> withObject "Map k v" $
1810+ FromJSONKeyText f -> withObject "Map" $
1583 fmap (H.foldrWithKey (M.insert . f) M.empty) . H.traverseWithKey (\k v -> p v <?> Key k)
1811 fmap (H.foldrWithKey (M.insert . f) M.empty) . H.traverseWithKey (\k v -> p v <?> Key k)
1584− FromJSONKeyTextParser f -> withObject "Map k v" $
1812+ FromJSONKeyTextParser f -> withObject "Map" $
1585 H.foldrWithKey (\k v m -> M.insert <$> f k <?> Key k <*> p v <?> Key k <*> m) (pure M.empty)
1813 H.foldrWithKey (\k v m -> M.insert <$> f k <?> Key k <*> p v <?> Key k <*> m) (pure M.empty)
1586− FromJSONKeyValue f -> withArray "Map k v" $ \arr ->
1814+ FromJSONKeyValue f -> withArray "Map" $ \arr ->
1587 fmap M.fromList . Tr.sequence .
1815 fmap M.fromList . Tr.sequence .
1588 zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr
1816 zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr
1589 {-# INLINE liftParseJSON #-}
1817 {-# INLINE liftParseJSON #-}
@@ -1611,18 +1839,18 @@ instance (FromJSON v) => FromJSON (Tree.Tree v) where
1612instance FromJSON UUID.UUID where
1840instance FromJSON UUID.UUID where
1613 parseJSON = withText "UUID" $
1841 parseJSON = withText "UUID" $
1614− maybe (fail "Invalid UUID") pure . UUID.fromText
1842+ maybe (fail "invalid UUID") pure . UUID.fromText
1616instance FromJSONKey UUID.UUID where
1844instance FromJSONKey UUID.UUID where
1617 fromJSONKey = FromJSONKeyTextParser $
1845 fromJSONKey = FromJSONKeyTextParser $
1618− maybe (fail "Invalid UUID") pure . UUID.fromText
1846+ maybe (fail "invalid UUID") pure . UUID.fromText
1620-------------------------------------------------------------------------------
1848-------------------------------------------------------------------------------
1621-- vector
1849-- vector
1622-------------------------------------------------------------------------------
1850-------------------------------------------------------------------------------
1624instance FromJSON1 Vector where
1852instance FromJSON1 Vector where
1625− liftParseJSON p _ = withArray "Vector a" $
1853+ liftParseJSON p _ = withArray "Vector" $
1626 V.mapM (uncurry $ parseIndexedJSON p) . V.indexed
1854 V.mapM (uncurry $ parseIndexedJSON p) . V.indexed
1627 {-# INLINE liftParseJSON #-}
1855 {-# INLINE liftParseJSON #-}
@@ -1636,14 +1864,14 @@ vectorParseJSON s = withArray s $ fmap V.convert . V.mapM (uncurry $ parseIndexe
1636{-# INLINE vectorParseJSON #-}
1864{-# INLINE vectorParseJSON #-}
1638instance (Storable a, FromJSON a) => FromJSON (VS.Vector a) where
1866instance (Storable a, FromJSON a) => FromJSON (VS.Vector a) where
1639− parseJSON = vectorParseJSON "Data.Vector.Storable.Vector a"
1867+ parseJSON = vectorParseJSON "Data.Vector.Storable.Vector"
1641instance (VP.Prim a, FromJSON a) => FromJSON (VP.Vector a) where
1869instance (VP.Prim a, FromJSON a) => FromJSON (VP.Vector a) where
1642− parseJSON = vectorParseJSON "Data.Vector.Primitive.Vector a"
1870+ parseJSON = vectorParseJSON "Data.Vector.Primitive.Vector"
1643 {-# INLINE parseJSON #-}
1871 {-# INLINE parseJSON #-}
1645instance (VG.Vector VU.Vector a, FromJSON a) => FromJSON (VU.Vector a) where
1873instance (VG.Vector VU.Vector a, FromJSON a) => FromJSON (VU.Vector a) where
1646− parseJSON = vectorParseJSON "Data.Vector.Unboxed.Vector a"
1874+ parseJSON = vectorParseJSON "Data.Vector.Unboxed.Vector"
1647 {-# INLINE parseJSON #-}
1875 {-# INLINE parseJSON #-}
1649-------------------------------------------------------------------------------
1877-------------------------------------------------------------------------------
@@ -1657,13 +1885,13 @@ instance (Eq a, Hashable a, FromJSON a) => FromJSON (HashSet.HashSet a) where
1658instance (FromJSONKey k, Eq k, Hashable k) => FromJSON1 (H.HashMap k) where
1886instance (FromJSONKey k, Eq k, Hashable k) => FromJSON1 (H.HashMap k) where
1659 liftParseJSON p _ = case fromJSONKey of
1887 liftParseJSON p _ = case fromJSONKey of
1660− FromJSONKeyCoerce _ -> withObject "HashMap ~Text v" $
1888+ FromJSONKeyCoerce _ -> withObject "HashMap ~Text" $
1661 uc . H.traverseWithKey (\k v -> p v <?> Key k)
1889 uc . H.traverseWithKey (\k v -> p v <?> Key k)
1662− FromJSONKeyText f -> withObject "HashMap k v" $
1890+ FromJSONKeyText f -> withObject "HashMap" $
1663 fmap (mapKey f) . H.traverseWithKey (\k v -> p v <?> Key k)
1891 fmap (mapKey f) . H.traverseWithKey (\k v -> p v <?> Key k)
1664− FromJSONKeyTextParser f -> withObject "HashMap k v" $
1892+ FromJSONKeyTextParser f -> withObject "HashMap" $
1665 H.foldrWithKey (\k v m -> H.insert <$> f k <?> Key k <*> p v <?> Key k <*> m) (pure H.empty)
1893 H.foldrWithKey (\k v m -> H.insert <$> f k <?> Key k <*> p v <?> Key k <*> m) (pure H.empty)
1666− FromJSONKeyValue f -> withArray "Map k v" $ \arr ->
1894+ FromJSONKeyValue f -> withArray "Map" $ \arr ->
1667 fmap H.fromList . Tr.sequence .
1895 fmap H.fromList . Tr.sequence .
1668 zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr
1896 zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr
@@ -1900,14 +2128,15 @@ instance FromJSON a => FromJSON (Semigroup.Option a) where
1901instance FromJSON1 Proxy where
2129instance FromJSON1 Proxy where
1902 {-# INLINE liftParseJSON #-}
2130 {-# INLINE liftParseJSON #-}
1903− liftParseJSON _ _ Null = pure Proxy
2131+ liftParseJSON _ _ = fromNull "Proxy" Proxy
1904− liftParseJSON _ _ v = typeMismatch "Proxy" v
1906instance FromJSON (Proxy a) where
2133instance FromJSON (Proxy a) where
1907 {-# INLINE parseJSON #-}
2134 {-# INLINE parseJSON #-}
1908− parseJSON Null = pure Proxy
2135+ parseJSON = fromNull "Proxy" Proxy
1909− parseJSON v = typeMismatch "Proxy" v
2137+fromNull :: String -> a -> Value -> Parser a
2138+fromNull _ a Null = pure a
2139+fromNull c _ v = prependContext c (typeMismatch "Null" v)
1912instance FromJSON2 Tagged where
2141instance FromJSON2 Tagged where
1913 liftParseJSON2 _ _ p _ = fmap Tagged . p
2142 liftParseJSON2 _ _ p _ = fmap Tagged . p
@@ -1934,10 +2163,7 @@ instance (FromJSON a, FromJSON b, FromJSON c) => FromJSONKey (a,b,c)
1934instance (FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSONKey (a,b,c,d)
2163instance (FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSONKey (a,b,c,d)
1936instance FromJSONKey Char where
2165instance FromJSONKey Char where
1937− fromJSONKey = FromJSONKeyTextParser $ \t ->
2166+ fromJSONKey = FromJSONKeyTextParser parseChar
1939− then return (T.index t 0)
1940− else typeMismatch "Expected Char but String didn't contain exactly one character" (String t)
1941 fromJSONKeyList = FromJSONKeyText T.unpack
2167 fromJSONKeyList = FromJSONKeyText T.unpack
1943instance (FromJSONKey a, FromJSON a) => FromJSONKey [a] where
2169instance (FromJSONKey a, FromJSON a) => FromJSONKey [a] where