@@ -5,19 +5,16 @@
55{-# LANGUAGE FlexibleInstances #-}
66{-# LANGUAGE GADTs #-}
77{-# LANGUAGE MultiParamTypeClasses #-}
8−{-# LANGUAGE NamedFieldPuns #-}
8+{-# LANGUAGE NoImplicitPrelude #-}
99{-# LANGUAGE OverloadedStrings #-}
10+{-# LANGUAGE PolyKinds #-}
1011{-# LANGUAGE RecordWildCards #-}
1112{-# LANGUAGE ScopedTypeVariables #-}
1213{-# LANGUAGE TypeOperators #-}
13−{-# LANGUAGE TypeSynonymInstances #-}
14+{-# LANGUAGE TupleSections #-}
1415{-# LANGUAGE UndecidableInstances #-}
1516{-# LANGUAGE ViewPatterns #-}
1617
17−#if __GLASGOW_HASKELL__ >= 706
18−{-# LANGUAGE PolyKinds #-}
19−#endif
20−
2118#include "incoherent-compat.h"
2219#include "overlapping-compat.h"
2320
@@ -45,6 +42,9 @@ module Data.Aeson.Types.FromJSON
4542 , coerceFromJSONKeyFunction
4643 , mapFromJSONKeyFunction
4744
45+ , GFromJSONKey()
46+ , genericFromJSONKey
47+
4848 -- * List functions
4949 , listParser
5050
@@ -60,12 +60,14 @@ module Data.Aeson.Types.FromJSON
6060 , fromJSON
6161 , ifromJSON
6262 , typeMismatch
63+ , unexpected
6364 , parseField
6465 , parseFieldMaybe
6566 , parseFieldMaybe'
6667 , explicitParseField
6768 , explicitParseFieldMaybe
6869 , explicitParseFieldMaybe'
70+ , parseIndexedJSON
6971 -- ** Operators
7072 , (.:)
7173 , (.:?)
@@ -76,17 +78,16 @@ module Data.Aeson.Types.FromJSON
7678 , parseOptionalFieldWith
7779 ) where
7880
79−import Prelude ()
8081import Prelude.Compat
8182
82−import Control.Applicative ((<|>), Const(..))
83−import Control.Monad ((<=<), zipWithM)
83+import Control.Applicative ((<|>), Const(..), liftA2)
84+import Control.Monad (zipWithM)
8485import Data.Aeson.Internal.Functions (mapKey)
8586import Data.Aeson.Parser.Internal (eitherDecodeWith, jsonEOF)
8687import Data.Aeson.Types.Generic
8788import Data.Aeson.Types.Internal
8889import Data.Bits (unsafeShiftR)
89−import Data.Fixed (Fixed, HasResolution)
90+import Data.Fixed (Fixed, HasResolution (resolution), Nano)
9091import Data.Functor.Compose (Compose(..))
9192import Data.Functor.Identity (Identity(..))
9293import Data.Functor.Product (Product(..))
@@ -102,11 +103,14 @@ import Data.Scientific (Scientific, base10Exponent)
102103import Data.Tagged (Tagged(..))
103104import Data.Text (Text, pack, unpack)
104105import Data.Time (Day, DiffTime, LocalTime, NominalDiffTime, TimeOfDay, UTCTime, ZonedTime)
105−import Data.Time.Format (parseTime)
106−import Data.Time.Locale.Compat (defaultTimeLocale)
106+import Data.Time.Calendar.Compat (CalendarDiffDays (..), DayOfWeek (..))
107+import Data.Time.LocalTime.Compat (CalendarDiffTime (..))
108+import Data.Time.Clock.System.Compat (SystemTime (..))
109+import Data.Time.Format.Compat (parseTimeM, defaultTimeLocale)
107110import Data.Traversable as Tr (sequence)
108111import Data.Vector (Vector)
109112import Data.Version (Version, parseVersion)
113+import Data.Void (Void)
110114import Data.Word (Word16, Word32, Word64, Word8)
111115import Foreign.Storable (Storable)
112116import Foreign.C.Types (CTime (..))
@@ -114,9 +118,9 @@ import GHC.Generics
114118import Numeric.Natural (Natural)
115119import Text.ParserCombinators.ReadP (readP_to_S)
116120import Unsafe.Coerce (unsafeCoerce)
117−import qualified Data.Aeson.Compat as Compat
118121import qualified Data.Aeson.Parser.Time as Time
119122import qualified Data.Attoparsec.ByteString.Char8 as A (endOfInput, parseOnly, scientific)
123+import qualified Data.ByteString.Lazy as L
120124import qualified Data.DList as DList
121125import qualified Data.HashMap.Strict as H
122126import qualified Data.HashSet as HashSet
@@ -144,23 +148,15 @@ import qualified Data.Primitive.Array as PM
144148import qualified Data.Primitive.SmallArray as PM
145149import qualified Data.Primitive.Types as PM
146150
147−#if (MIN_VERSION_primitive(0,6,4))
151+#if MIN_VERSION_primitive(0,6,4)
152+#if !MIN_VERSION_primitive(0,7,0)
148153import qualified Data.Primitive.UnliftedArray as PM
154+#endif
149155import qualified Data.Primitive.PrimArray as PM
150156#endif
151157
152−#ifndef HAS_COERCIBLE
153−#define HAS_COERCIBLE (__GLASGOW_HASKELL__ >= 707)
154−#endif
155158
156−#if HAS_COERCIBLE
157159import Data.Coerce (Coercible, coerce)
158−coerce' :: Coercible a b => a -> b
159−coerce' = coerce
160−#else
161−coerce' :: a -> b
162−coerce' = unsafeCoerce
163−#endif
164160
165161parseIndexedJSON :: (Value -> Parser a) -> Int -> Value -> Parser a
166162parseIndexedJSON p idx value = p value <?> Index idx
@@ -169,7 +165,7 @@ parseIndexedJSON p idx value = p value <?> Index idx
169165parseIndexedJSONPair :: (Value -> Parser a) -> (Value -> Parser b) -> Int -> Value -> Parser (a, b)
170166parseIndexedJSONPair keyParser valParser idx value = p value <?> Index idx
171167 where
172− p = withArray "(k,v)" $ \ab ->
168+ p = withArray "(k, v)" $ \ab ->
173169 let n = V.length ab
174170 in if n == 2
175171 then (,) <$> parseJSONElemAtIndex keyParser 0 ab
@@ -182,33 +178,33 @@ parseJSONElemAtIndex :: (Value -> Parser a) -> Int -> V.Vector Value -> Parser a
182178parseJSONElemAtIndex p idx ary = p (V.unsafeIndex ary idx) <?> Index idx
183179
184180parseRealFloat :: RealFloat a => String -> Value -> Parser a
185−parseRealFloat _ (Number s) = pure $ Scientific.toRealFloat s
186−parseRealFloat _ Null = pure (0/0)
187−parseRealFloat expected v = typeMismatch expected v
181+parseRealFloat _ (Number s) = pure $ Scientific.toRealFloat s
182+parseRealFloat _ Null = pure (0/0)
183+parseRealFloat name v = prependContext name (unexpected v)
188184{-# INLINE parseRealFloat #-}
189185
190−parseIntegralFromScientific :: forall a. Integral a => String -> Scientific -> Parser a
191−parseIntegralFromScientific expected s =
186+parseIntegralFromScientific :: forall a. Integral a => Scientific -> Parser a
187+parseIntegralFromScientific s =
192188 case Scientific.floatingOrInteger s :: Either Double a of
193189 Right x -> pure x
194− Left _ -> fail $ "expected " ++ expected ++ ", encountered floating number " ++ show s
190+ Left _ -> fail $ "unexpected floating number " ++ show s
195191{-# INLINE parseIntegralFromScientific #-}
196192
197193parseIntegral :: Integral a => String -> Value -> Parser a
198−parseIntegral expected =
199− withBoundedScientific expected $ parseIntegralFromScientific expected
194+parseIntegral name =
195+ prependContext name . withBoundedScientific' parseIntegralFromScientific
200196{-# INLINE parseIntegral #-}
201197
202−parseBoundedIntegralFromScientific :: (Bounded a, Integral a) => String -> Scientific -> Parser a
203−parseBoundedIntegralFromScientific expected s = maybe
204− (fail $ expected ++ " is either floating or will cause over or underflow: " ++ show s)
198+parseBoundedIntegralFromScientific :: (Bounded a, Integral a) => Scientific -> Parser a
199+parseBoundedIntegralFromScientific s = maybe
200+ (fail $ "value is either floating or will cause over or underflow " ++ show s)
205201 pure
206202 (Scientific.toBoundedInteger s)
207203{-# INLINE parseBoundedIntegralFromScientific #-}
208204
209205parseBoundedIntegral :: (Bounded a, Integral a) => String -> Value -> Parser a
210−parseBoundedIntegral expected =
211− withScientific expected $ parseBoundedIntegralFromScientific expected
206+parseBoundedIntegral name =
207+ prependContext name . withScientific' parseBoundedIntegralFromScientific
212208{-# INLINE parseBoundedIntegral #-}
213209
214210parseScientificText :: Text -> Parser Scientific
@@ -218,18 +214,20 @@ parseScientificText
218214 . T.encodeUtf8
219215
220216parseIntegralText :: Integral a => String -> Text -> Parser a
221−parseIntegralText expected t
222− = parseScientificText t
223− >>= rejectLargeExponent
224− >>= parseIntegralFromScientific expected
217+parseIntegralText name t =
218+ prependContext name $
219+ parseScientificText t
220+ >>= rejectLargeExponent
221+ >>= parseIntegralFromScientific
225222 where
226223 rejectLargeExponent :: Scientific -> Parser Scientific
227− rejectLargeExponent s = withBoundedScientific expected pure (Number s)
224+ rejectLargeExponent s = withBoundedScientific' pure (Number s)
228225{-# INLINE parseIntegralText #-}
229226
230227parseBoundedIntegralText :: (Bounded a, Integral a) => String -> Text -> Parser a
231−parseBoundedIntegralText expected t =
232− parseScientificText t >>= parseBoundedIntegralFromScientific expected
228+parseBoundedIntegralText name t =
229+ prependContext name $
230+ parseScientificText t >>= parseBoundedIntegralFromScientific
233231
234232parseOptionalFieldWith :: (Value -> Parser (Maybe a))
235233 -> Object -> Text -> Parser (Maybe a)
@@ -289,14 +287,21 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
289287--
290288-- The basic ways to signal a failed conversion are as follows:
291289--
292−-- * 'empty' and 'mzero' work, but are terse and uninformative;
290+-- * 'fail' yields a custom error message: it is the recommended way of
291+-- reporting a failure;
293292--
294−-- * 'fail' yields a custom error message;
293+-- * 'Control.Applicative.empty' (or 'Control.Monad.mzero') is uninformative:
294+-- use it when the error is meant to be caught by some @('<|>')@;
295295--
296−-- * 'typeMismatch' produces an informative message for cases when the
297−-- value encountered is not of the expected type.
296+-- * 'typeMismatch' can be used to report a failure when the encountered value
297+-- is not of the expected JSON type; 'unexpected' is an appropriate alternative
298+-- when more than one type may be expected, or to keep the expected type
299+-- implicit.
298300--
299−-- An example type and instance using 'typeMismatch':
301+-- 'prependFailure' (or 'modifyFailure') add more information to a parser's
302+-- error messages.
303+--
304+-- An example type and instance using 'typeMismatch' and 'prependFailure':
300305--
301306-- @
302307-- \-- Allow ourselves to write 'Text' literals.
@@ -310,13 +315,15 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
310315-- '<*>' v '.:' \"y\"
311316--
312317-- \-- We do not expect a non-'Object' value here.
313−-- \-- We could use 'mzero' to fail, but 'typeMismatch'
318+-- \-- We could use 'Control.Applicative.empty' to fail, but 'typeMismatch'
314319-- \-- gives a much more informative error message.
315−-- 'parseJSON' invalid = 'typeMismatch' \"Coord\" invalid
320+-- 'parseJSON' invalid =
321+-- 'prependFailure' "parsing Coord failed, "
322+-- ('typeMismatch' \"Object\" invalid)
316323-- @
317324--
318325-- For this common case of only being concerned with a single
319−-- type of JSON value, the functions 'withObject', 'withNumber', etc.
326+-- type of JSON value, the functions 'withObject', 'withScientific', etc.
320327-- are provided. Their use is to be preferred when possible, since
321328-- they are more terse. Using 'withObject', we can rewrite the above instance
322329-- (assuming the same language extension and data type) as:
@@ -355,7 +362,7 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
355362-- @
356363--
357364-- The default implementation will be equivalent to
358−-- @parseJSON = 'genericParseJSON' 'defaultOptions'@; If you need different
365+-- @parseJSON = 'genericParseJSON' 'defaultOptions'@; if you need different
359366-- options, you can customize the generic decoding by defining:
360367--
361368-- @
@@ -373,13 +380,11 @@ class FromJSON a where
373380 parseJSON = genericParseJSON defaultOptions
374381
375382 parseJSONList :: Value -> Parser [a]
376− parseJSONList (Array a)
377− = zipWithM (parseIndexedJSON parseJSON) [0..]
383+ parseJSONList = withArray "[]" $ \a ->
384+ zipWithM (parseIndexedJSON parseJSON) [0..]
378385 . V.toList
379386 $ a
380387
381− parseJSONList v = typeMismatch "[a]" v
382−
383388-------------------------------------------------------------------------------
384389-- Classes and types for map keys
385390-------------------------------------------------------------------------------
@@ -391,6 +396,16 @@ class FromJSON a where
391396-- > newtype SomeId = SomeId { getSomeId :: Text }
392397-- > deriving (Eq,Ord,Hashable,FromJSONKey)
393398--
399+-- If you have a sum of nullary constructors, you may use the generic
400+-- implementation:
401+--
402+-- @
403+-- data Color = Red | Green | Blue
404+-- deriving Generic
405+--
406+-- instance 'FromJSONKey' Color where
407+-- 'fromJSONKey' = 'genericFromJSONKey' 'defaultJSONKeyOptions'
408+-- @
394409class FromJSONKey a where
395410 -- | Strategy for parsing the key of a map-like container.
396411 fromJSONKey :: FromJSONKeyFunction a
@@ -413,11 +428,7 @@ class FromJSONKey a where
413428-- At the moment this type is intentionally not exported. 'FromJSONKeyFunction'
414429-- can be inspected, but cannot be constructed.
415430data CoerceText a where
416−#if HAS_COERCIBLE
417431 CoerceText :: Coercible Text a => CoerceText a
418−#else
419− CoerceText :: CoerceText a
420−#endif
421432
422433-- | This type is related to 'ToJSONKeyFunction'. If 'FromJSONKeyValue' is used in the
423434-- 'FromJSONKey' instance, then 'ToJSONKeyValue' should be used in the 'ToJSONKey'
@@ -437,7 +448,7 @@ data FromJSONKeyFunction a
437448
438449-- | Only law abiding up to interpretation
439450instance Functor FromJSONKeyFunction where
440− fmap h (FromJSONKeyCoerce CoerceText) = FromJSONKeyText (h . coerce')
451+ fmap h (FromJSONKeyCoerce CoerceText) = FromJSONKeyText (h . coerce)
441452 fmap h (FromJSONKeyText f) = FromJSONKeyText (h . f)
442453 fmap h (FromJSONKeyTextParser f) = FromJSONKeyTextParser (fmap h . f)
443454 fmap h (FromJSONKeyValue f) = FromJSONKeyValue (fmap h . f)
@@ -451,9 +462,7 @@ instance Functor FromJSONKeyFunction where
451462--
452463-- On pre GHC 7.8 this is unconstrainted function.
453464fromJSONKeyCoerce ::
454−#if HAS_COERCIBLE
455465 Coercible Text a =>
456−#endif
457466 FromJSONKeyFunction a
458467fromJSONKeyCoerce = FromJSONKeyCoerce CoerceText
459468
@@ -461,60 +470,91 @@ fromJSONKeyCoerce = FromJSONKeyCoerce CoerceText
461470--
462471-- See note on 'fromJSONKeyCoerce'.
463472coerceFromJSONKeyFunction ::
464−#if HAS_COERCIBLE
465473 Coercible a b =>
466−#endif
467474 FromJSONKeyFunction a -> FromJSONKeyFunction b
468−#if HAS_COERCIBLE
469475coerceFromJSONKeyFunction = coerce
470−#else
471−coerceFromJSONKeyFunction (FromJSONKeyCoerce CoerceText) = FromJSONKeyCoerce CoerceText
472−coerceFromJSONKeyFunction (FromJSONKeyText f) = FromJSONKeyText (coerce' . f)
473−coerceFromJSONKeyFunction (FromJSONKeyTextParser f) = FromJSONKeyTextParser (fmap coerce' . f)
474−coerceFromJSONKeyFunction (FromJSONKeyValue f) = FromJSONKeyValue (fmap coerce' . f)
475−#endif
476476
477477{-# RULES
478478 "FromJSONKeyCoerce: fmap id" forall (x :: FromJSONKeyFunction a).
479479 fmap id x = x
480480 #-}
481−#if HAS_COERCIBLE
482481{-# RULES
483482 "FromJSONKeyCoerce: fmap coerce" forall x .
484483 fmap coerce x = coerceFromJSONKeyFunction x
485484 #-}
486−#endif
487485
488486-- | Same as 'fmap'. Provided for the consistency with 'ToJSONKeyFunction'.
489487mapFromJSONKeyFunction :: (a -> b) -> FromJSONKeyFunction a -> FromJSONKeyFunction b
490488mapFromJSONKeyFunction = fmap
491489
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.
493+--
494+-- See also 'genericToJSONKey'.
495+--
496+-- === __Example__
497+--
498+-- @
499+-- data Color = Red | Green | Blue
500+-- deriving 'Generic'
501+--
502+-- instance 'FromJSONKey' Color where
503+-- 'fromJSONKey' = 'genericFromJSONKey' 'defaultJSONKeyOptions'
504+-- @
505+genericFromJSONKey :: forall a. (Generic a, GFromJSONKey (Rep a))
506+ => JSONKeyOptions
507+ -> FromJSONKeyFunction a
508+genericFromJSONKey opts = FromJSONKeyTextParser $ \t ->
509+ case parseSumFromString (keyModifier opts) t of
510+ Nothing -> fail $
511+ "invalid key " ++ show t ++ ", expected one of " ++ show cnames
512+ Just k -> pure (to k)
513+ where
514+ cnames = unTagged2 (constructorTags (keyModifier opts) :: Tagged2 (Rep a) [String])
515+
516+class (ConstructorNames f, SumFromString f) => GFromJSONKey f where
517+instance (ConstructorNames f, SumFromString f) => GFromJSONKey f where
518+
492519-------------------------------------------------------------------------------
493520-- Functions needed for documentation
494521-------------------------------------------------------------------------------
495522
496523-- | Fail parsing due to a type mismatch, with a descriptive message.
497524--
498−-- Example usage:
525+-- The following wrappers should generally be prefered:
526+-- 'withObject', 'withArray', 'withText', 'withBool'.
499527--
500−-- @
501−-- instance FromJSON Coord where
502−-- parseJSON ('Object' v) = {- type matches, life is good -}
503−-- parseJSON wat = 'typeMismatch' \"Coord\" wat
504−-- @
505−typeMismatch :: String -- ^ The name of the type you are trying to parse.
528+-- ==== Error message example
529+--
530+-- > typeMismatch "Object" (String "oops")
531+-- > -- Error: "expected Object, but encountered String"
532+typeMismatch :: String -- ^ The name of the JSON type being parsed
533+ -- (@\"Object\"@, @\"Array\"@, @\"String\"@, @\"Number\"@,
534+ -- @\"Boolean\"@, or @\"Null\"@).
506535 -> Value -- ^ The actual value encountered.
507536 -> Parser a
508537typeMismatch expected actual =
509− fail $ "expected " ++ expected ++ ", encountered " ++ name
510− where
511− name = case actual of
512− Object _ -> "Object"
513− Array _ -> "Array"
514− String _ -> "String"
515− Number _ -> "Number"
516− Bool _ -> "Boolean"
517− Null -> "Null"
538+ fail $ "expected " ++ expected ++ ", but encountered " ++ typeOf actual
539+
540+-- | Fail parsing due to a type mismatch, when the expected types are implicit.
541+--
542+-- ==== Error message example
543+--
544+-- > unexpected (String "oops")
545+-- > -- Error: "unexpected String"
546+unexpected :: Value -> Parser a
547+unexpected actual = fail $ "unexpected " ++ typeOf actual
548+
549+-- | JSON type of a value, name of the head constructor.
550+typeOf :: Value -> String
551+typeOf v = case v of
552+ Object _ -> "Object"
553+ Array _ -> "Array"
554+ String _ -> "String"
555+ Number _ -> "Number"
556+ Bool _ -> "Boolean"
557+ Null -> "Null"
518558
519559-------------------------------------------------------------------------------
520560-- Lifings of FromJSON and ToJSON to unary and binary type constructors
@@ -595,9 +635,8 @@ class FromJSON2 f where
595635 -> (Value -> Parser b)
596636 -> (Value -> Parser [b])
597637 -> Value -> Parser [f a b]
598− liftParseJSONList2 fa ga fb gb v = case v of
599− Array vals -> fmap V.toList (V.mapM (liftParseJSON2 fa ga fb gb) vals)
600− _ -> typeMismatch "[a]" v
638+ liftParseJSONList2 fa ga fb gb = withArray "[]" $ \vals ->
639+ fmap V.toList (V.mapM (liftParseJSON2 fa ga fb gb) vals)
601640
602641-- | Lift the standard 'parseJSON' function through the type constructor.
603642parseJSON2 :: (FromJSON2 f, FromJSON a, FromJSON b) => Value -> Parser (f a b)
@@ -611,7 +650,7 @@ parseJSON2 = liftParseJSON2 parseJSON parseJSONList parseJSON parseJSONList
611650-- | Helper function to use with 'liftParseJSON'. See 'Data.Aeson.ToJSON.listEncoding'.
612651listParser :: (Value -> Parser a) -> Value -> Parser [a]
613652listParser f (Array xs) = fmap V.toList (V.mapM f xs)
614−listParser _ v = typeMismatch "[a]" v
653+listParser _ v = typeMismatch "Array" v
615654{-# INLINE listParser #-}
616655
617656-------------------------------------------------------------------------------
@@ -629,69 +668,137 @@ instance (FromJSON a) => FromJSON [a] where
629668-- Functions
630669-------------------------------------------------------------------------------
631670
632−-- | @'withObject' expected f value@ applies @f@ to the 'Object' when @value@
633−-- is an 'Object' and fails using @'typeMismatch' expected@ otherwise.
671+-- | Add context to a failure message, indicating the name of the structure
672+-- being parsed.
673+--
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, ")
678+
679+-- | @'withObject' name f value@ applies @f@ to the 'Object' when @value@
680+-- is an 'Data.Aeson.Object' and fails otherwise.
681+--
682+-- ==== Error message example
683+--
684+-- > withObject "MyType" f (String "oops")
685+-- > -- Error: "parsing MyType failed, expected Object, but encountered String"
634686withObject :: String -> (Object -> Parser a) -> Value -> Parser a
635−withObject _ f (Object obj) = f obj
636−withObject expected _ v = typeMismatch expected v
687+withObject _ f (Object obj) = f obj
688+withObject name _ v = prependContext name (typeMismatch "Object" v)
637689{-# INLINE withObject #-}
638690
639−-- | @'withText' expected f value@ applies @f@ to the 'Text' when @value@ is a
640−-- 'String' and fails using @'typeMismatch' expected@ otherwise.
691+-- | @'withText' name f value@ applies @f@ to the 'Text' when @value@ is a
692+-- 'Data.Aeson.String' and fails otherwise.
693+--
694+-- ==== Error message example
695+--
696+-- > withText "MyType" f Null
697+-- > -- Error: "parsing MyType failed, expected String, but encountered Null"
641698withText :: String -> (Text -> Parser a) -> Value -> Parser a
642−withText _ f (String txt) = f txt
643−withText expected _ v = typeMismatch expected v
699+withText _ f (String txt) = f txt
700+withText name _ v = prependContext name (typeMismatch "String" v)
644701{-# INLINE withText #-}
645702
646703-- | @'withArray' expected f value@ applies @f@ to the 'Array' when @value@ is
647−-- an 'Array' and fails using @'typeMismatch' expected@ otherwise.
704+-- an 'Data.Aeson.Array' and fails otherwise.
705+--
706+-- ==== Error message example
707+--
708+-- > withArray "MyType" f (String "oops")
709+-- > -- Error: "parsing MyType failed, expected Array, but encountered String"
648710withArray :: String -> (Array -> Parser a) -> Value -> Parser a
649−withArray _ f (Array arr) = f arr
650−withArray expected _ v = typeMismatch expected v
711+withArray _ f (Array arr) = f arr
712+withArray name _ v = prependContext name (typeMismatch "Array" v)
651713{-# INLINE withArray #-}
652714
653−-- | @'withScientific' expected f value@ applies @f@ to the 'Scientific' number
654−-- when @value@ is a 'Number' and fails using @'typeMismatch' expected@
715+-- | @'withScientific' name f value@ applies @f@ to the 'Scientific' number
716+-- when @value@ is a 'Data.Aeson.Number' and fails using 'typeMismatch'
655717-- otherwise.
656−-- .
718+--
657719-- /Warning/: If you are converting from a scientific to an unbounded
658720-- type such as 'Integer' you may want to add a restriction on the
659721-- size of the exponent (see 'withBoundedScientific') to prevent
660722-- malicious input from filling up the memory of the target system.
723+--
724+-- ==== Error message example
725+--
726+-- > withScientific "MyType" f (String "oops")
727+-- > -- Error: "parsing MyType failed, expected Number, but encountered String"
661728withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
662−withScientific _ f (Number scientific) = f scientific
663−withScientific expected _ v = typeMismatch expected v
729+withScientific _ f (Number scientific) = f scientific
730+withScientific name _ v = prependContext name (typeMismatch "Number" v)
664731{-# INLINE withScientific #-}
665732
666−-- | @'withBoundedScientific' expected f value@ applies @f@ to the 'Scientific' number
667−-- when @value@ is a 'Number' and fails using @'typeMismatch' expected@
668−-- otherwise.
733+-- | A variant of 'withScientific' which doesn't use 'prependContext', so that
734+-- such context can be added separately in a way that also applies when the
735+-- continuation @f :: Scientific -> Parser a@ fails.
736+--
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.
669741--
670−-- The conversion will also fail wyth a @'typeMismatch' if the
671−-- 'Scientific' exponent is larger than 1024.
742+-- ==== Error message examples
743+--
744+-- > withScientific' f (String "oops")
745+-- > -- Error: "unexpected String"
746+-- >
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
751+ Number n -> f n
752+ _ -> typeMismatch "Number" v
753+{-# INLINE withScientific' #-}
754+
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.
672757withBoundedScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
673−withBoundedScientific _ f v@(Number scientific) =
674− if base10Exponent scientific > 1024
675− then typeMismatch "a number with exponent <= 1024" v
676− else f scientific
677−withBoundedScientific expected _ v = typeMismatch expected v
758+withBoundedScientific name f v = withBoundedScientific_ (prependContext name) f v
678759{-# INLINE withBoundedScientific #-}
679760
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' #-}
767+
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) =
772+ if exp10 > 1024
773+ then whenFail (fail msg)
774+ else f scientific
775+ where
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_ #-}
781+
680782-- | @'withBool' expected f value@ applies @f@ to the 'Bool' when @value@ is a
681−-- 'Bool' and fails using @'typeMismatch' expected@ otherwise.
783+-- 'Boolean' and fails otherwise.
784+--
785+-- ==== Error message example
786+--
787+-- > withBool "MyType" f (String "oops")
788+-- > -- Error: "parsing MyType failed, expected Boolean, but encountered String"
682789withBool :: String -> (Bool -> Parser a) -> Value -> Parser a
683−withBool _ f (Bool arr) = f arr
684−withBool expected _ v = typeMismatch expected v
790+withBool _ f (Bool arr) = f arr
791+withBool name _ v = prependContext name (typeMismatch "Boolean" v)
685792{-# INLINE withBool #-}
686793
687794-- | Decode a nested JSON-encoded string.
688795withEmbeddedJSON :: String -> (Value -> Parser a) -> Value -> Parser a
689796withEmbeddedJSON _ innerParser (String txt) =
690− either fail innerParser $ eitherDecode (Compat.fromStrict $ T.encodeUtf8 txt)
797+ either fail innerParser $ eitherDecode (L.fromStrict $ T.encodeUtf8 txt)
691798 where
692799 eitherDecode = eitherFormatError . eitherDecodeWith jsonEOF ifromJSON
693800 eitherFormatError = either (Left . uncurry formatError) Right
694−withEmbeddedJSON name _ v = typeMismatch name v
801+withEmbeddedJSON name _ v = prependContext name (typeMismatch "String" v)
695802{-# INLINE withEmbeddedJSON #-}
696803
697804-- | Convert a value from JSON, failing if the types do not match.
@@ -756,7 +863,7 @@ parseFieldMaybe' = (.:!)
756863-- E.g. @'explicitParseField' 'parseJSON1' :: ('FromJSON1' f, 'FromJSON' a) -> 'Object' -> 'Text' -> 'Parser' (f a)@
757864explicitParseField :: (Value -> Parser a) -> Object -> Text -> Parser a
758865explicitParseField p obj key = case H.lookup key obj of
759− Nothing -> fail $ "key " ++ show key ++ " not present"
866+ Nothing -> fail $ "key " ++ show key ++ " not found"
760867 Just v -> p v <?> Key key
761868{-# INLINE explicitParseField #-}
762869
@@ -796,11 +903,47 @@ pmval .!= val = fromMaybe val <$> pmval
796903-- Generic parseJSON
797904-------------------------------------------------------------------------------
798905
906+instance GFromJSON arity V1 where
907+ -- Whereof we cannot format, thereof we cannot parse:
908+ gParseJSON _ _ _ = fail "Attempted to parse empty type"
909+
910+
799911instance OVERLAPPABLE_ (GFromJSON arity a) => GFromJSON arity (M1 i c a) where
800912 -- Meta-information, which is not handled elsewhere, is just added to the
801913 -- parsed value:
802914 gParseJSON opts fargs = fmap M1 . gParseJSON opts fargs
803915
916+-- Information for error messages
917+
918+type TypeName = String
919+type ConName = String
920+
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
924+
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 ++ ", ")
934+
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)
938+
939+-- | Render a constructor as @\"MyType(MyConstructor)\"@.
940+showCons :: ConName -> TypeName -> String
941+showCons cname tname = tname ++ "(" ++ cname ++ ")"
942+
943+--------------------------------------------------------------------------------
944+
945+-- Parsing single fields
946+
804947instance (FromJSON a) => GFromJSON arity (K1 i a) where
805948 -- Constant values are decoded using their FromJSON instance:
806949 gParseJSON _opts _ = fmap K1 . parseJSON
@@ -815,342 +958,499 @@ instance (FromJSON1 f) => GFromJSON One (Rec1 f) where
815958 -- FromJSON1 instance:
816959 gParseJSON _opts (From1Args pj pjl) = fmap Rec1 . liftParseJSON pj pjl
817960
818−instance GFromJSON arity U1 where
819− -- Empty constructors are expected to be encoded as an empty array:
820− gParseJSON _opts _ v
821− | isEmptyArray v = pure U1
822− | otherwise = typeMismatch "unit constructor (U1)" v
961+instance (FromJSON1 f, GFromJSON One g) => GFromJSON One (f :.: g) where
962+ -- 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
964+ -- instance to generically decode the innermost type:
965+ gParseJSON opts fargs =
966+ let gpj = gParseJSON opts fargs in
967+ fmap Comp1 . liftParseJSON gpj (listParser gpj)
968+
969+--------------------------------------------------------------------------------
823970
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
973+ -- parsed value:
974+ gParseJSON opts fargs = fmap M1 . gParseJSON' (tname :* opts :* fargs)
975+ where
976+ tname = moduleName proxy ++ "." ++ datatypeName proxy
977+ proxy = undefined :: M1 _i d _f _p
978+
979+-- | 'GFromJSON', after unwrapping the 'D1' constructor, now carrying the data
980+-- type's name.
981+class GFromJSON' arity f where
982+ gParseJSON' :: TypeName :* Options :* FromArgs arity a
983+ -> Value
984+ -> Parser (f a)
985+
986+-- | Single constructor.
824987instance ( ConsFromJSON arity a
825988 , AllNullary (C1 c a) allNullary
826989 , ParseSum arity (C1 c a) allNullary
827− ) => GFromJSON arity (D1 d (C1 c a)) where
990+ , Constructor c
991+ ) => GFromJSON' arity (C1 c a) where
828992 -- The option 'tagSingleConstructors' determines whether to wrap
829993 -- a single-constructor type.
830− gParseJSON opts fargs
994+ gParseJSON' p@(_ :* opts :* _)
831995 | tagSingleConstructors opts
832− = fmap M1
833− . (unTagged :: Tagged allNullary (Parser (C1 c a p)) -> Parser (C1 c a p))
834− . parseSum opts fargs
835− | otherwise = fmap M1 . fmap M1 . consParseJSON opts fargs
836−
837−instance (ConsFromJSON arity a) => GFromJSON arity (C1 c a) where
838− -- Constructors need to be decoded differently depending on whether they're
839− -- a record or not. This distinction is made by consParseJSON:
840− gParseJSON opts fargs = fmap M1 . consParseJSON opts fargs
841−
842−instance ( FromProduct arity a, FromProduct arity b
843− , ProductSize a, ProductSize b
844− ) => GFromJSON arity (a :*: b) where
845− -- Products are expected to be encoded to an array. Here we check whether we
846− -- got an array of the same size as the product, then parse each of the
847− -- product's elements using parseProduct:
848− gParseJSON opts fargs = withArray "product (:*:)" $ \arr ->
849− let lenArray = V.length arr
850− lenProduct = (unTagged2 :: Tagged2 (a :*: b) Int -> Int)
851− productSize in
852− if lenArray == lenProduct
853− then parseProduct opts fargs arr 0 lenProduct
854− else fail $ "When expecting a product of " ++ show lenProduct ++
855− " values, encountered an Array of " ++ show lenArray ++
856− " elements instead"
857−
858−instance ( AllNullary (a :+: b) allNullary
859− , ParseSum arity (a :+: b) allNullary
860− ) => GFromJSON arity (a :+: b) where
996+ = (unTagged :: Tagged allNullary (Parser (C1 c a p)) -> Parser (C1 c a p))
997+ . parseSum p
998+ | otherwise = fmap M1 . consParseJSON (cname :* p)
999+ where
1000+ cname = conName (undefined :: M1 _i c _f _p)
1001+
1002+-- | Multiple constructors.
1003+instance ( AllNullary (a :+: b) allNullary
1004+ , ParseSum arity (a :+: b) allNullary
1005+ ) => GFromJSON' arity (a :+: b) where
8611006 -- If all constructors of a sum datatype are nullary and the
8621007 -- 'allNullaryToStringTag' option is set they are expected to be
8631008 -- encoded as strings. This distinction is made by 'parseSum':
864− gParseJSON opts fargs =
865− (unTagged :: Tagged allNullary (Parser ((a :+: b) d)) ->
866− Parser ((a :+: b) d))
867− . parseSum opts fargs
868−
869−instance (FromJSON1 f, GFromJSON One g) => GFromJSON One (f :.: g) where
870− -- If an occurrence of the last type parameter is nested inside two
871− -- composed types, it is decoded by using the outermost type's FromJSON1
872− -- instance to generically decode the innermost type:
873− gParseJSON opts fargs =
874− let gpj = gParseJSON opts fargs in
875− fmap Comp1 . liftParseJSON gpj (listParser gpj)
1009+ gParseJSON' p =
1010+ (unTagged :: Tagged allNullary (Parser ((a :+: b) _d)) ->
1011+ Parser ((a :+: b) _d))
1012+ . parseSum p
8761013
8771014--------------------------------------------------------------------------------
8781015
8791016class ParseSum arity f allNullary where
880− parseSum :: Options -> FromArgs arity a
881− -> Value -> Tagged allNullary (Parser (f a))
1017+ parseSum :: TypeName :* Options :* FromArgs arity a
1018+ -> Value
1019+ -> Tagged allNullary (Parser (f a))
8821020
883−instance ( SumFromString f
1021+instance ( ConstructorNames f
1022+ , SumFromString f
8841023 , FromPair arity f
8851024 , FromTaggedObject arity f
8861025 , FromUntaggedValue arity f
8871026 ) => ParseSum arity f True where
888− parseSum opts fargs
889− | allNullaryToStringTag opts = Tagged . parseAllNullarySum opts
890− | otherwise = Tagged . parseNonAllNullarySum opts fargs
1027+ parseSum p@(tname :* opts :* _)
1028+ | allNullaryToStringTag opts = Tagged . parseAllNullarySum tname opts
1029+ | otherwise = Tagged . parseNonAllNullarySum p
8911030
892−instance ( FromPair arity f
1031+instance ( ConstructorNames f
1032+ , FromPair arity f
8931033 , FromTaggedObject arity f
8941034 , FromUntaggedValue arity f
8951035 ) => ParseSum arity f False where
896− parseSum opts fargs = Tagged . parseNonAllNullarySum opts fargs
1036+ parseSum p = Tagged . parseNonAllNullarySum p
8971037
8981038--------------------------------------------------------------------------------
8991039
900−parseAllNullarySum :: SumFromString f => Options -> Value -> Parser (f a)
901−parseAllNullarySum opts = withText "Text" $ \key ->
902− maybe (notFound key) return $
903− parseSumFromString opts key
1040+parseAllNullarySum :: (SumFromString f, ConstructorNames f)
1041+ => TypeName -> Options -> Value -> Parser (f a)
1042+parseAllNullarySum tname opts =
1043+ withText tname $ \tag ->
1044+ maybe (badTag tag) return $
1045+ parseSumFromString modifier tag
1046+ where
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
1051+
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.
1055+failWithCTags
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
1060+ where
1061+ cnames = unTagged2 (constructorTags modifier :: Tagged2 f [t])
9041062
9051063class SumFromString f where
906− parseSumFromString :: Options -> Text -> Maybe (f a)
1064+ parseSumFromString :: (String -> String) -> Text -> Maybe (f a)
9071065
9081066instance (SumFromString a, SumFromString b) => SumFromString (a :+: b) where
9091067 parseSumFromString opts key = (L1 <$> parseSumFromString opts key) <|>
9101068 (R1 <$> parseSumFromString opts key)
9111069
9121070instance (Constructor c) => SumFromString (C1 c U1) where
913− parseSumFromString opts key | key == name = Just $ M1 U1
914− | otherwise = Nothing
915− where
916− name = pack $ constructorTagModifier opts $
917− conName (undefined :: t c U1 p)
1071+ parseSumFromString modifier key
1072+ | key == name = Just $ M1 U1
1073+ | otherwise = Nothing
1074+ where
1075+ name = pack $ modifier $ conName (undefined :: M1 _i c _f _p)
9181076
919−--------------------------------------------------------------------------------
1077+-- For genericFromJSONKey
1078+instance SumFromString a => SumFromString (D1 d a) where
1079+ parseSumFromString modifier key = M1 <$> parseSumFromString modifier key
1080+
1081+-- | List of all constructor tags.
1082+constructorTags :: ConstructorNames a => (String -> t) -> Tagged2 a [t]
1083+constructorTags modifier =
1084+ fmap DList.toList (constructorNames' modifier)
9201085
921−parseNonAllNullarySum :: ( FromPair arity f
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)
1090+
1091+instance (ConstructorNames a, ConstructorNames b) => ConstructorNames (a :+: b) where
1092+ constructorNames' = liftA2 append constructorNames' constructorNames'
1093+ where
1094+ append
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)
1099+
1100+instance Constructor c => ConstructorNames (C1 c a) where
1101+ constructorNames' f = Tagged2 (pure (f cname))
1102+ where
1103+ cname = conName (undefined :: M1 _i c _f _p)
1104+
1105+-- For genericFromJSONKey
1106+instance ConstructorNames a => ConstructorNames (D1 d a) where
1107+ constructorNames' = retag . constructorNames'
1108+ where
1109+ retag :: Tagged2 a u -> Tagged2 (D1 d a) u
1110+ retag (Tagged2 x) = Tagged2 x
1111+
1112+--------------------------------------------------------------------------------
1113+parseNonAllNullarySum :: forall f c arity.
1114+ ( FromPair arity f
9221115 , FromTaggedObject arity f
9231116 , FromUntaggedValue arity f
924− ) => Options -> FromArgs arity c
1117+ , ConstructorNames f
1118+ ) => TypeName :* Options :* FromArgs arity c
9251119 -> Value -> Parser (f c)
926−parseNonAllNullarySum opts fargs =
1120+parseNonAllNullarySum p@(tname :* opts :* _) =
9271121 case sumEncoding opts of
9281122 TaggedObject{..} ->
929− withObject "Object" $ \obj -> do
930− tag <- obj .: pack tagFieldName
931− fromMaybe (notFound tag) $
932− parseFromTaggedObject opts fargs contentsFieldName obj tag
1123+ withObject tname $ \obj -> do
1124+ tag <- contextType tname . contextTag tagKey cnames_ $ obj .: tagKey
1125+ fromMaybe (badTag tag <?> Key tagKey) $
1126+ parseFromTaggedObject (tag :* contentsFieldName :* p) obj
1127+ where
1128+ tagKey = pack tagFieldName
1129+ badTag tag = failWith_ $ \cnames ->
1130+ "expected tag field to be one of " ++ show cnames ++
1131+ ", but found tag " ++ show tag
1132+ cnames_ = unTagged2 (constructorTags (constructorTagModifier opts) :: Tagged2 f [String])
9331133
9341134 ObjectWithSingleField ->
935− withObject "Object" $ \obj ->
936− case H.toList obj of
937− [pair@(tag, _)] -> fromMaybe (notFound tag) $
938− parsePair opts fargs pair
939− _ -> fail "Object doesn't have a single field"
1135+ withObject tname $ \obj -> case H.toList obj of
1136+ [(tag, v)] -> maybe (badTag tag) (<?> Key tag) $
1137+ parsePair (tag :* p) v
1138+ _ -> contextType tname . fail $
1139+ "expected an Object with a single pair, but found " ++
1140+ show (H.size obj) ++ " pairs"
1141+ where
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
9401145
9411146 TwoElemArray ->
942− withArray "Array" $ \arr ->
943− if V.length arr == 2
944− then case V.unsafeIndex arr 0 of
945− String tag -> fromMaybe (notFound tag) $
946− parsePair opts fargs (tag, V.unsafeIndex arr 1)
947− _ -> fail "First element is not a String"
948− else fail "Array doesn't have 2 elements"
1147+ withArray tname $ \arr -> case V.length arr of
1148+ 2 | String tag <- V.unsafeIndex arr 0 ->
1149+ maybe (badTag tag <?> Index 0) (<?> Index 1) $
1150+ parsePair (tag :* p) (V.unsafeIndex arr 1)
1151+ | otherwise ->
1152+ contextType tname $
1153+ fail "tag element is not a String" <?> Index 0
1154+ len -> contextType tname . fail $
1155+ "expected a 2-element Array, but encountered an Array of length " ++
1156+ show len
1157+ where
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
9491161
950− UntaggedValue -> parseUntaggedValue opts fargs
1162+ UntaggedValue -> parseUntaggedValue p
1163+ where
1164+ failWith_ = failWithCTags tname (constructorTagModifier opts)
9511165
9521166--------------------------------------------------------------------------------
9531167
9541168class FromTaggedObject arity f where
955− parseFromTaggedObject :: Options -> FromArgs arity a
956− -> String -> Object
957− -> Text -> Maybe (Parser (f a))
1169+ -- The first two components of the parameter tuple are: the constructor tag
1170+ -- to match against, and the contents field name.
1171+ parseFromTaggedObject
1172+ :: Text :* String :* TypeName :* Options :* FromArgs arity a
1173+ -> Object
1174+ -> Maybe (Parser (f a))
9581175
9591176instance ( FromTaggedObject arity a, FromTaggedObject arity b) =>
9601177 FromTaggedObject arity (a :+: b) where
961− parseFromTaggedObject opts fargs contentsFieldName obj tag =
962− (fmap L1 <$> parseFromTaggedObject opts fargs contentsFieldName obj tag) <|>
963− (fmap R1 <$> parseFromTaggedObject opts fargs contentsFieldName obj tag)
1178+ parseFromTaggedObject p obj =
1179+ (fmap L1 <$> parseFromTaggedObject p obj) <|>
1180+ (fmap R1 <$> parseFromTaggedObject p obj)
9641181
965−instance ( FromTaggedObject' arity f
1182+instance ( IsRecord f isRecord
1183+ , FromTaggedObject' arity f isRecord
9661184 , Constructor c
9671185 ) => FromTaggedObject arity (C1 c f) where
968− parseFromTaggedObject opts fargs contentsFieldName obj tag
969− | tag == name = Just $ M1 <$> parseFromTaggedObject'
970− opts fargs contentsFieldName obj
971− | otherwise = Nothing
972− where
973− name = pack $ constructorTagModifier opts $
974− conName (undefined :: t c f p)
1186+ parseFromTaggedObject (tag :* contentsFieldName :* p@(_ :* opts :* _))
1187+ | tag == tag'
1188+ = Just . fmap M1 .
1189+ (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a)) .
1190+ parseFromTaggedObject' (contentsFieldName :* cname :* p)
1191+ | otherwise = const Nothing
1192+ where
1193+ tag' = pack $ constructorTagModifier opts cname
1194+ cname = conName (undefined :: M1 _i c _f _p)
9751195
9761196--------------------------------------------------------------------------------
9771197
978−class FromTaggedObject' arity f where
979− parseFromTaggedObject' :: Options -> FromArgs arity a -> String
980− -> Object -> Parser (f a)
981−
982−class FromTaggedObject'' arity f isRecord where
983− parseFromTaggedObject'' :: Options -> FromArgs arity a -> String
984− -> Object -> Tagged isRecord (Parser (f a))
985−
986−instance ( IsRecord f isRecord
987− , FromTaggedObject'' arity f isRecord
988− ) => FromTaggedObject' arity f where
989− parseFromTaggedObject' opts fargs contentsFieldName =
990− (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a)) .
991− parseFromTaggedObject'' opts fargs contentsFieldName
992−
993−instance (FromRecord arity f) => FromTaggedObject'' arity f True where
994− parseFromTaggedObject'' opts fargs _ =
995− Tagged . parseRecord opts fargs
996−
997−instance (GFromJSON arity f) => FromTaggedObject'' arity f False where
998− parseFromTaggedObject'' opts fargs contentsFieldName = Tagged .
999− (gParseJSON opts fargs <=< (.: pack contentsFieldName))
1198+class FromTaggedObject' arity f isRecord where
1199+ -- The first component of the parameter tuple is the contents field name.
1200+ parseFromTaggedObject'
1201+ :: String :* ConName :* TypeName :* Options :* FromArgs arity a
1202+ -> Object -> Tagged isRecord (Parser (f a))
1203+
1204+instance (RecordFromJSON arity f, FieldNames f) => FromTaggedObject' arity f True where
1205+ -- Records are unpacked in the tagged object
1206+ parseFromTaggedObject' (_ :* p) = Tagged . recordParseJSON (True :* p)
1207+
1208+instance (ConsFromJSON arity f) => FromTaggedObject' arity f False where
1209+ -- Nonnullary nonrecords are encoded in the contents field
1210+ parseFromTaggedObject' p obj = Tagged $ do
1211+ contents <- contextCons cname tname (obj .: key)
1212+ consParseJSON p' contents <?> Key key
1213+ where
1214+ key = pack contentsFieldName
1215+ contentsFieldName :* p'@(cname :* tname :* _) = p
10001216
1001−instance OVERLAPPING_ FromTaggedObject'' arity U1 False where
1002− parseFromTaggedObject'' _ _ _ _ = Tagged (pure U1)
1217+instance OVERLAPPING_ FromTaggedObject' arity U1 False where
1218+ -- Nullary constructors don't need a contents field
1219+ parseFromTaggedObject' _ _ = Tagged (pure U1)
10031220
10041221--------------------------------------------------------------------------------
10051222
1223+-- | Constructors need to be decoded differently depending on whether they're
1224+-- a record or not. This distinction is made by 'ConsParseJSON'.
10061225class ConsFromJSON arity f where
1007− consParseJSON :: Options -> FromArgs arity a
1008− -> Value -> Parser (f a)
1226+ consParseJSON
1227+ :: ConName :* TypeName :* Options :* FromArgs arity a
1228+ -> Value -> Parser (f a)
10091229
10101230class ConsFromJSON' arity f isRecord where
1011− consParseJSON' :: Options -> FromArgs arity a
1012− -> Value -> Tagged isRecord (Parser (f a))
1231+ consParseJSON'
1232+ :: ConName :* TypeName :* Options :* FromArgs arity a
1233+ -> Value -> Tagged isRecord (Parser (f a))
10131234
10141235instance ( IsRecord f isRecord
10151236 , ConsFromJSON' arity f isRecord
10161237 ) => ConsFromJSON arity f where
1017− consParseJSON opts fargs =
1238+ consParseJSON p =
10181239 (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a))
1019− . consParseJSON' opts fargs
1240+ . consParseJSON' p
10201241
10211242instance OVERLAPPING_
1022− ( GFromJSON arity a, FromRecord arity (S1 s a)
1243+ ( GFromJSON arity a, RecordFromJSON arity (S1 s a)
10231244 ) => ConsFromJSON' arity (S1 s a) True where
1024− consParseJSON' opts fargs
1025− | unwrapUnaryRecords opts = Tagged . gParseJSON opts fargs
1026− | otherwise = Tagged . withObject "unary record" (parseRecord opts fargs)
1245+ consParseJSON' p@(cname :* tname :* opts :* fargs)
1246+ | unwrapUnaryRecords opts = Tagged . fmap M1 . gParseJSON opts fargs
1247+ | otherwise = Tagged . withObject (showCons cname tname) (recordParseJSON (False :* p))
1248+
1249+instance RecordFromJSON arity f => ConsFromJSON' arity f True where
1250+ consParseJSON' p@(cname :* tname :* _) =
1251+ Tagged . withObject (showCons cname tname) (recordParseJSON (False :* p))
10271252
1028−instance FromRecord arity f => ConsFromJSON' arity f True where
1029− consParseJSON' opts fargs =
1030− Tagged . withObject "record (:*:)" (parseRecord opts fargs)
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
1261+ where
1262+ fail_ a = fail $
1263+ "expected an empty Array, but encountered an Array of length " ++
1264+ show (V.length a)
1265+
1266+instance OVERLAPPING_
1267+ GFromJSON arity f => ConsFromJSON' arity (S1 s f) False where
1268+ consParseJSON' (_ :* _ :* opts :* fargs) =
1269+ Tagged . fmap M1 . gParseJSON opts fargs
10311270
1032−instance GFromJSON arity f => ConsFromJSON' arity f False where
1033− consParseJSON' opts fargs = Tagged . gParseJSON opts fargs
1271+instance (ProductFromJSON arity f, ProductSize f
1272+ ) => ConsFromJSON' arity f False where
1273+ consParseJSON' p = Tagged . productParseJSON0 p
10341274
10351275--------------------------------------------------------------------------------
10361276
1037−class FromRecord arity f where
1038− parseRecord :: Options -> FromArgs arity a
1039− -> Object -> Parser (f a)
1277+class FieldNames f where
1278+ fieldNames :: f a -> [Text] -> [Text]
10401279
1041−instance ( FromRecord arity a
1042− , FromRecord arity b
1043− ) => FromRecord arity (a :*: b) where
1044− parseRecord opts fargs obj =
1045− (:*:) <$> parseRecord opts fargs obj
1046− <*> parseRecord opts fargs obj
1280+instance (FieldNames a, FieldNames b) => FieldNames (a :*: b) where
1281+ fieldNames _ =
1282+ fieldNames (undefined :: a x) .
1283+ fieldNames (undefined :: b y)
10471284
1048−instance OVERLAPPABLE_ (Selector s, GFromJSON arity a) =>
1049− FromRecord arity (S1 s a) where
1050− parseRecord opts fargs =
1051− (<?> Key label) . gParseJSON opts fargs <=< (.: label)
1285+instance (Selector s) => FieldNames (S1 s f) where
1286+ fieldNames _ = (pack (selName (undefined :: M1 _i s _f _p)) :)
1287+
1288+class RecordFromJSON arity f where
1289+ recordParseJSON
1290+ :: Bool :* ConName :* TypeName :* Options :* FromArgs arity a
1291+ -> Object -> Parser (f a)
1292+
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
10521298 where
1053− label = pack . fieldLabelModifier opts $ selName (undefined :: t s a p)
1299+ knownFields :: H.HashMap Text ()
1300+ knownFields = H.fromList $ map (,()) $
1301+ fieldNames (undefined :: f a)
1302+ [pack (tagFieldName (sumEncoding opts)) | fromTaggedSum]
1303+ checkUnknown =
1304+ if not (rejectUnknownFields opts)
1305+ then \_ -> return ()
1306+ else \obj -> case H.keys (H.difference obj knownFields) of
1307+ [] -> return ()
1308+ unknownFields -> contextCons cname tname $
1309+ fail ("unknown fields: " ++ show unknownFields)
1310+
1311+class RecordFromJSON' arity f where
1312+ recordParseJSON'
1313+ :: ConName :* TypeName :* Options :* FromArgs arity a
1314+ -> Object -> Parser (f a)
1315+
1316+instance ( RecordFromJSON' arity a
1317+ , RecordFromJSON' arity b
1318+ ) => RecordFromJSON' arity (a :*: b) where
1319+ recordParseJSON' p obj =
1320+ (:*:) <$> recordParseJSON' p obj
1321+ <*> recordParseJSON' p obj
1322+
1323+instance OVERLAPPABLE_ (Selector s, GFromJSON arity a) =>
1324+ RecordFromJSON' arity (S1 s a) where
1325+ recordParseJSON' (cname :* tname :* opts :* fargs) obj = do
1326+ fv <- contextCons cname tname (obj .: label)
1327+ M1 <$> gParseJSON opts fargs fv <?> Key label
1328+ where
1329+ label = pack $ fieldLabelModifier opts sname
1330+ sname = selName (undefined :: M1 _i s _f _p)
10541331
10551332instance INCOHERENT_ (Selector s, FromJSON a) =>
1056− FromRecord arity (S1 s (K1 i (Maybe a))) where
1057− parseRecord opts _ obj = M1 . K1 <$> obj .:? pack label
1058− where
1059− label = fieldLabelModifier opts $
1060− selName (undefined :: t s (K1 i (Maybe a)) p)
1333+ RecordFromJSON' arity (S1 s (K1 i (Maybe a))) where
1334+ recordParseJSON' (_ :* _ :* opts :* _) obj = M1 . K1 <$> obj .:? pack label
1335+ where
1336+ label = fieldLabelModifier opts sname
1337+ sname = selName (undefined :: M1 _i s _f _p)
10611338
10621339-- Parse an Option like a Maybe.
10631340instance INCOHERENT_ (Selector s, FromJSON a) =>
1064− FromRecord arity (S1 s (K1 i (Semigroup.Option a))) where
1065− parseRecord opts fargs obj = wrap <$> parseRecord opts fargs obj
1341+ RecordFromJSON' arity (S1 s (K1 i (Semigroup.Option a))) where
1342+ recordParseJSON' p obj = wrap <$> recordParseJSON' p obj
10661343 where
10671344 wrap :: S1 s (K1 i (Maybe a)) p -> S1 s (K1 i (Semigroup.Option a)) p
10681345 wrap (M1 (K1 a)) = M1 (K1 (Semigroup.Option a))
10691346
10701347--------------------------------------------------------------------------------
10711348
1072−class FromProduct arity f where
1073− parseProduct :: Options -> FromArgs arity a
1349+productParseJSON0
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)
1360+ productSize in
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
1366+
1367+--
1368+
1369+class ProductFromJSON arity f where
1370+ productParseJSON :: ConName :* TypeName :* Options :* FromArgs arity a
10741371 -> Array -> Int -> Int
10751372 -> Parser (f a)
10761373
1077−instance ( FromProduct arity a
1078− , FromProduct arity b
1079− ) => FromProduct arity (a :*: b) where
1080− parseProduct opts fargs arr ix len =
1081− (:*:) <$> parseProduct opts fargs arr ix lenL
1082− <*> parseProduct opts fargs arr ixR lenR
1374+instance ( ProductFromJSON arity a
1375+ , ProductFromJSON arity b
1376+ ) => ProductFromJSON arity (a :*: b) where
1377+ productParseJSON p arr ix len =
1378+ (:*:) <$> productParseJSON p arr ix lenL
1379+ <*> productParseJSON p arr ixR lenR
10831380 where
10841381 lenL = len `unsafeShiftR` 1
10851382 ixR = ix + lenL
10861383 lenR = len - lenL
10871384
1088−instance (GFromJSON arity a) => FromProduct arity (S1 s a) where
1089− parseProduct opts fargs arr ix _ =
1090− gParseJSON opts fargs $ V.unsafeIndex arr ix
1385+instance (GFromJSON arity a) => ProductFromJSON arity (S1 s a) where
1386+ productParseJSON (_ :* _ :* opts :* fargs) arr ix _ =
1387+ M1 <$> gParseJSON opts fargs (V.unsafeIndex arr ix) <?> Index ix
10911388
10921389--------------------------------------------------------------------------------
10931390
10941391class FromPair arity f where
1095− parsePair :: Options -> FromArgs arity a
1096− -> Pair -> Maybe (Parser (f a))
1392+ -- The first component of the parameter tuple is the tag to match.
1393+ parsePair :: Text :* TypeName :* Options :* FromArgs arity a
1394+ -> Value
1395+ -> Maybe (Parser (f a))
10971396
10981397instance ( FromPair arity a
10991398 , FromPair arity b
11001399 ) => FromPair arity (a :+: b) where
1101− parsePair opts fargs pair = (fmap L1 <$> parsePair opts fargs pair) <|>
1102− (fmap R1 <$> parsePair opts fargs pair)
1400+ parsePair p pair =
1401+ (fmap L1 <$> parsePair p pair) <|>
1402+ (fmap R1 <$> parsePair p pair)
11031403
11041404instance ( Constructor c
1105− , GFromJSON arity a
11061405 , ConsFromJSON arity a
11071406 ) => FromPair arity (C1 c a) where
1108− parsePair opts fargs (tag, value)
1109− | tag == tag' = Just $ gParseJSON opts fargs value
1407+ parsePair (tag :* p@(_ :* opts :* _)) v
1408+ | tag == tag' = Just $ M1 <$> consParseJSON (cname :* p) v
11101409 | otherwise = Nothing
1111− where
1112− tag' = pack $ constructorTagModifier opts $
1113− conName (undefined :: t c a p)
1410+ where
1411+ tag' = pack $ constructorTagModifier opts cname
1412+ cname = conName (undefined :: M1 _i c _a _p)
11141413
11151414--------------------------------------------------------------------------------
11161415
11171416class FromUntaggedValue arity f where
1118− parseUntaggedValue :: Options -> FromArgs arity a
1119− -> Value -> Parser (f a)
1417+ parseUntaggedValue :: TypeName :* Options :* FromArgs arity a
1418+ -> Value
1419+ -> Parser (f a)
11201420
11211421instance
11221422 ( FromUntaggedValue arity a
11231423 , FromUntaggedValue arity b
11241424 ) => FromUntaggedValue arity (a :+: b)
11251425 where
1126− parseUntaggedValue opts fargs value =
1127− L1 <$> parseUntaggedValue opts fargs value <|>
1128− R1 <$> parseUntaggedValue opts fargs value
1426+ parseUntaggedValue p value =
1427+ L1 <$> parseUntaggedValue p value <|>
1428+ R1 <$> parseUntaggedValue p value
11291429
11301430instance OVERLAPPABLE_
1131− ( GFromJSON arity a
1132− , ConsFromJSON arity a
1431+ ( ConsFromJSON arity a
1432+ , Constructor c
11331433 ) => FromUntaggedValue arity (C1 c a)
11341434 where
1135− parseUntaggedValue = gParseJSON
1435+ parseUntaggedValue p = fmap M1 . consParseJSON (cname :* p)
1436+ where
1437+ cname = conName (undefined :: M1 _i c _f _p)
11361438
11371439instance OVERLAPPING_
11381440 ( Constructor c )
11391441 => FromUntaggedValue arity (C1 c U1)
11401442 where
1141− parseUntaggedValue opts _ (String s)
1142− | s == pack (constructorTagModifier opts (conName (undefined :: t c U1 p))) =
1143− pure $ M1 U1
1144− | otherwise =
1145− fail $ "Invalid tag: " ++ unpack s
1146− parseUntaggedValue _ _ v = typeMismatch (conName (undefined :: t c U1 p)) v
1147−
1148−
1149−--------------------------------------------------------------------------------
1150−
1151−notFound :: Text -> Parser a
1152−notFound key = fail $ "The key \"" ++ unpack key ++ "\" was not found"
1153−{-# INLINE notFound #-}
1443+ parseUntaggedValue (tname :* opts :* _) v =
1444+ contextCons cname tname $ case v of
1445+ String tag
1446+ | tag == tag' -> pure $ M1 U1
1447+ | otherwise -> fail_ tag
1448+ _ -> typeMismatch "String" v
1449+ where
1450+ tag' = pack $ constructorTagModifier opts cname
1451+ cname = conName (undefined :: M1 _i c _f _p)
1452+ fail_ tag = fail $
1453+ "expected tag " ++ show tag' ++ ", but found tag " ++ show tag
11541454
11551455-------------------------------------------------------------------------------
11561456-- Instances
@@ -1208,17 +1508,20 @@ instance (FromJSON a, FromJSON b) => FromJSON (Either a b) where
12081508 parseJSON = parseJSON2
12091509 {-# INLINE parseJSON #-}
12101510
1211−
1511+instance FromJSON Void where
1512+ parseJSON _ = fail "Cannot parse Void"
1513+ {-# INLINE parseJSON #-}
12121514
12131515instance FromJSON Bool where
1214− parseJSON = withBool "Bool" pure
1516+ parseJSON (Bool b) = pure b
1517+ parseJSON v = typeMismatch "Bool" v
12151518 {-# INLINE parseJSON #-}
12161519
12171520instance FromJSONKey Bool where
12181521 fromJSONKey = FromJSONKeyTextParser $ \t -> case t of
12191522 "true" -> pure True
12201523 "false" -> pure False
1221− _ -> fail $ "Cannot parse key into Bool: " ++ T.unpack t
1524+ _ -> fail $ "cannot parse key " ++ show t ++ " into Bool"
12221525
12231526instance FromJSON Ordering where
12241527 parseJSON = withText "Ordering" $ \s ->
@@ -1226,25 +1529,30 @@ instance FromJSON Ordering where
12261529 "LT" -> return LT
12271530 "EQ" -> return EQ
12281531 "GT" -> return GT
1229− _ -> fail "Parsing Ordering value failed: expected \"LT\", \"EQ\", or \"GT\""
1532+ _ -> fail $ "parsing Ordering failed, unexpected " ++ show s ++
1533+ " (expected \"LT\", \"EQ\", or \"GT\")"
12301534
12311535instance FromJSON () where
12321536 parseJSON = withArray "()" $ \v ->
12331537 if V.null v
12341538 then pure ()
1235− else fail "Expected an empty array"
1539+ else prependContext "()" $ fail "expected an empty array"
12361540 {-# INLINE parseJSON #-}
12371541
12381542instance FromJSON Char where
1239− parseJSON = withText "Char" $ \t ->
1240− if T.compareLength t 1 == EQ
1241− then pure $ T.head t
1242− else fail "Expected a string of length 1"
1543+ parseJSON = withText "Char" parseChar
12431544 {-# INLINE parseJSON #-}
12441545
1245− parseJSONList = withText "String" $ pure . T.unpack
1546+ parseJSONList (String s) = pure (T.unpack s)
1547+ parseJSONList v = typeMismatch "String" v
12461548 {-# INLINE parseJSONList #-}
12471549
1550+parseChar :: Text -> Parser Char
1551+parseChar t =
1552+ if T.compareLength t 1 == EQ
1553+ then pure $ T.head t
1554+ else prependContext "Char" $ fail "expected a string of length 1"
1555+
12481556instance FromJSON Double where
12491557 parseJSON = parseRealFloat "Double"
12501558 {-# INLINE parseJSON #-}
@@ -1268,12 +1576,22 @@ instance FromJSONKey Float where
12681576 _ -> Scientific.toRealFloat <$> parseScientificText t
12691577
12701578instance (FromJSON a, Integral a) => FromJSON (Ratio a) where
1271− parseJSON = withObject "Rational" $ \obj -> do
1272− numerator <- obj .: "numerator"
1273− denominator <- obj .: "denominator"
1274− if denominator == 0
1275− then fail "Ratio denominator was 0"
1276− else pure $ numerator % denominator
1579+ parseJSON (Number x)
1580+ | exp10 <= 1024
1581+ , exp10 >= -1024 = return $! realToFrac x
1582+ | otherwise = prependContext "Ratio" $ fail msg
1583+ where
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
1588+ where
1589+ objParser = withObject "Rational" $ \obj -> do
1590+ numerator <- obj .: "numerator"
1591+ denominator <- obj .: "denominator"
1592+ if denominator == 0
1593+ then fail "Ratio denominator was 0"
1594+ else pure $ numerator % denominator
12771595 {-# INLINE parseJSON #-}
12781596
12791597-- | This instance includes a bounds check to prevent maliciously
@@ -1281,7 +1599,7 @@ instance (FromJSON a, Integral a) => FromJSON (Ratio a) where
12811599-- newtype 'Scientific' and provide your own instance using
12821600-- 'withScientific' if you want to allow larger inputs.
12831601instance HasResolution a => FromJSON (Fixed a) where
1284− parseJSON = withBoundedScientific "Fixed" $ pure . realToFrac
1602+ parseJSON = prependContext "Fixed" . withBoundedScientific' (pure . realToFrac)
12851603 {-# INLINE parseJSON #-}
12861604
12871605instance FromJSON Int where
@@ -1304,19 +1622,20 @@ instance FromJSONKey Integer where
13041622
13051623instance FromJSON Natural where
13061624 parseJSON value = do
1307− integer :: Integer <- parseIntegral "Natural" value
1308− if integer < 0 then
1309− fail $ "expected Natural, encountered negative number " <> show integer
1310− else
1311− pure $ fromIntegral integer
1625+ integer <- parseIntegral "Natural" value
1626+ parseNatural integer
13121627
13131628instance FromJSONKey Natural where
13141629 fromJSONKey = FromJSONKeyTextParser $ \text -> do
1315− integer :: Integer <- parseIntegralText "Natural" text
1316− if integer < 0 then
1317− fail $ "expected Natural, encountered negative number " <> show integer
1318− else
1319− pure $ fromIntegral integer
1630+ integer <- parseIntegralText "Natural" text
1631+ parseNatural integer
1632+
1633+parseNatural :: Integer -> Parser Natural
1634+parseNatural integer =
1635+ if integer < 0 then
1636+ fail $ "parsing Natural failed, unexpected negative number " <> show integer
1637+ else
1638+ pure $ fromIntegral integer
13201639
13211640instance FromJSON Int8 where
13221641 parseJSON = parseBoundedIntegral "Int8"
@@ -1413,17 +1732,17 @@ parseVersionText = go . readP_to_S parseVersion . unpack
14131732 where
14141733 go [(v,[])] = return v
14151734 go (_ : xs) = go xs
1416− go _ = fail "could not parse Version"
1735+ go _ = fail "parsing Version failed"
14171736
14181737-------------------------------------------------------------------------------
14191738-- semigroups NonEmpty
14201739-------------------------------------------------------------------------------
14211740
14221741instance FromJSON1 NonEmpty where
1423− liftParseJSON p _ = withArray "NonEmpty a" $
1742+ liftParseJSON p _ = withArray "NonEmpty" $
14241743 (>>= ne) . Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
14251744 where
1426− ne [] = fail "Expected a NonEmpty but got an empty list"
1745+ ne [] = fail "parsing NonEmpty failed, unexpected empty list"
14271746 ne (x:xs) = pure (x :| xs)
14281747 {-# INLINE liftParseJSON #-}
14291748
@@ -1444,7 +1763,7 @@ instance FromJSON Scientific where
14441763-------------------------------------------------------------------------------
14451764
14461765instance FromJSON1 DList.DList where
1447− liftParseJSON p _ = withArray "DList a" $
1766+ liftParseJSON p _ = withArray "DList" $
14481767 fmap DList.fromList .
14491768 Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
14501769 {-# INLINE liftParseJSON #-}
@@ -1521,7 +1840,7 @@ instance (FromJSON1 f, FromJSON1 g) => FromJSON1 (Sum f g) where
15211840 inr = "InR"
15221841
15231842 liftParseJSON _ _ _ = fail $
1524− "expected an object with a single property " ++
1843+ "parsing Sum failed, expected an object with a single property " ++
15251844 "where the property key should be either " ++
15261845 "\"InL\" or \"InR\""
15271846 {-# INLINE liftParseJSON #-}
@@ -1535,7 +1854,7 @@ instance (FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Sum f g a) where
15351854-------------------------------------------------------------------------------
15361855
15371856instance FromJSON1 Seq.Seq where
1538− liftParseJSON p _ = withArray "Seq a" $
1857+ liftParseJSON p _ = withArray "Seq" $
15391858 fmap Seq.fromList .
15401859 Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
15411860 {-# INLINE liftParseJSON #-}
@@ -1569,13 +1888,13 @@ instance FromJSON a => FromJSON (IntMap.IntMap a) where
15691888
15701889instance (FromJSONKey k, Ord k) => FromJSON1 (M.Map k) where
15711890 liftParseJSON p _ = case fromJSONKey of
1572− FromJSONKeyCoerce _-> withObject "Map k v" $
1891+ FromJSONKeyCoerce _ -> withObject "Map" $
15731892 fmap (H.foldrWithKey (M.insert . unsafeCoerce) M.empty) . H.traverseWithKey (\k v -> p v <?> Key k)
1574− FromJSONKeyText f -> withObject "Map k v" $
1893+ FromJSONKeyText f -> withObject "Map" $
15751894 fmap (H.foldrWithKey (M.insert . f) M.empty) . H.traverseWithKey (\k v -> p v <?> Key k)
1576− FromJSONKeyTextParser f -> withObject "Map k v" $
1895+ FromJSONKeyTextParser f -> withObject "Map" $
15771896 H.foldrWithKey (\k v m -> M.insert <$> f k <?> Key k <*> p v <?> Key k <*> m) (pure M.empty)
1578− FromJSONKeyValue f -> withArray "Map k v" $ \arr ->
1897+ FromJSONKeyValue f -> withArray "Map" $ \arr ->
15791898 fmap M.fromList . Tr.sequence .
15801899 zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr
15811900 {-# INLINE liftParseJSON #-}
@@ -1603,18 +1922,18 @@ instance (FromJSON v) => FromJSON (Tree.Tree v) where
16031922
16041923instance FromJSON UUID.UUID where
16051924 parseJSON = withText "UUID" $
1606− maybe (fail "Invalid UUID") pure . UUID.fromText
1925+ maybe (fail "invalid UUID") pure . UUID.fromText
16071926
16081927instance FromJSONKey UUID.UUID where
16091928 fromJSONKey = FromJSONKeyTextParser $
1610− maybe (fail "Invalid UUID") pure . UUID.fromText
1929+ maybe (fail "invalid UUID") pure . UUID.fromText
16111930
16121931-------------------------------------------------------------------------------
16131932-- vector
16141933-------------------------------------------------------------------------------
16151934
16161935instance FromJSON1 Vector where
1617− liftParseJSON p _ = withArray "Vector a" $
1936+ liftParseJSON p _ = withArray "Vector" $
16181937 V.mapM (uncurry $ parseIndexedJSON p) . V.indexed
16191938 {-# INLINE liftParseJSON #-}
16201939
@@ -1628,14 +1947,14 @@ vectorParseJSON s = withArray s $ fmap V.convert . V.mapM (uncurry $ parseIndexe
16281947{-# INLINE vectorParseJSON #-}
16291948
16301949instance (Storable a, FromJSON a) => FromJSON (VS.Vector a) where
1631− parseJSON = vectorParseJSON "Data.Vector.Storable.Vector a"
1950+ parseJSON = vectorParseJSON "Data.Vector.Storable.Vector"
16321951
16331952instance (VP.Prim a, FromJSON a) => FromJSON (VP.Vector a) where
1634− parseJSON = vectorParseJSON "Data.Vector.Primitive.Vector a"
1953+ parseJSON = vectorParseJSON "Data.Vector.Primitive.Vector"
16351954 {-# INLINE parseJSON #-}
16361955
16371956instance (VG.Vector VU.Vector a, FromJSON a) => FromJSON (VU.Vector a) where
1638− parseJSON = vectorParseJSON "Data.Vector.Unboxed.Vector a"
1957+ parseJSON = vectorParseJSON "Data.Vector.Unboxed.Vector"
16391958 {-# INLINE parseJSON #-}
16401959
16411960-------------------------------------------------------------------------------
@@ -1649,13 +1968,13 @@ instance (Eq a, Hashable a, FromJSON a) => FromJSON (HashSet.HashSet a) where
16491968
16501969instance (FromJSONKey k, Eq k, Hashable k) => FromJSON1 (H.HashMap k) where
16511970 liftParseJSON p _ = case fromJSONKey of
1652− FromJSONKeyCoerce _ -> withObject "HashMap ~Text v" $
1971+ FromJSONKeyCoerce _ -> withObject "HashMap ~Text" $
16531972 uc . H.traverseWithKey (\k v -> p v <?> Key k)
1654− FromJSONKeyText f -> withObject "HashMap k v" $
1973+ FromJSONKeyText f -> withObject "HashMap" $
16551974 fmap (mapKey f) . H.traverseWithKey (\k v -> p v <?> Key k)
1656− FromJSONKeyTextParser f -> withObject "HashMap k v" $
1975+ FromJSONKeyTextParser f -> withObject "HashMap" $
16571976 H.foldrWithKey (\k v m -> H.insert <$> f k <?> Key k <*> p v <?> Key k <*> m) (pure H.empty)
1658− FromJSONKeyValue f -> withArray "Map k v" $ \arr ->
1977+ FromJSONKeyValue f -> withArray "Map" $ \arr ->
16591978 fmap H.fromList . Tr.sequence .
16601979 zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr
16611980 where
@@ -1678,7 +1997,7 @@ instance FromJSON DotNetTime where
16781997 parseJSON = withText "DotNetTime" $ \t ->
16791998 let (s,m) = T.splitAt (T.length t - 5) t
16801999 t' = T.concat [s,".",m]
1681− in case parseTime defaultTimeLocale "/Date(%s%Q)/" (unpack t') of
2000+ in case parseTimeM True defaultTimeLocale "/Date(%s%Q)/" (unpack t') of
16822001 Just d -> pure (DotNetTime d)
16832002 _ -> fail "could not parse .NET time"
16842003 {-# INLINE parseJSON #-}
@@ -1687,7 +2006,6 @@ instance FromJSON DotNetTime where
16872006-- primitive
16882007-------------------------------------------------------------------------------
16892008
1690−#if (MIN_VERSION_base(0,4,7))
16912009instance FromJSON a => FromJSON (PM.Array a) where
16922010 -- note: we could do better than this if vector exposed the data
16932011 -- constructor in Data.Vector.
@@ -1696,10 +2014,11 @@ instance FromJSON a => FromJSON (PM.Array a) where
16962014instance FromJSON a => FromJSON (PM.SmallArray a) where
16972015 parseJSON = fmap Exts.fromList . parseJSON
16982016
1699−#if (MIN_VERSION_primitive(0,6,4))
2017+#if MIN_VERSION_primitive(0,6,4)
17002018instance (PM.Prim a,FromJSON a) => FromJSON (PM.PrimArray a) where
17012019 parseJSON = fmap Exts.fromList . parseJSON
17022020
2021+#if !MIN_VERSION_primitive(0,7,0)
17032022instance (PM.PrimUnlifted a,FromJSON a) => FromJSON (PM.UnliftedArray a) where
17042023 parseJSON = fmap Exts.fromList . parseJSON
17052024#endif
@@ -1772,6 +2091,40 @@ instance FromJSON DiffTime where
17722091 parseJSON = withBoundedScientific "DiffTime" $ pure . realToFrac
17732092 {-# INLINE parseJSON #-}
17742093
2094+instance FromJSON SystemTime where
2095+ parseJSON v = prependContext "SystemTime" $ do
2096+ n <- parseJSON v
2097+ let n' = floor (n * fromInteger (resolution n) :: Nano)
2098+ let (secs, nano) = n' `divMod` resolution n
2099+ return (MkSystemTime (fromInteger secs) (fromInteger nano))
2100+
2101+instance FromJSON CalendarDiffTime where
2102+ parseJSON = withObject "CalendarDiffTime" $ \obj -> CalendarDiffTime
2103+ <$> obj .: "months"
2104+ <*> obj .: "time"
2105+
2106+instance FromJSON CalendarDiffDays where
2107+ parseJSON = withObject "CalendarDiffDays" $ \obj -> CalendarDiffDays
2108+ <$> obj .: "months"
2109+ <*> obj .: "days"
2110+
2111+instance FromJSON DayOfWeek where
2112+ parseJSON = withText "DaysOfWeek" parseDayOfWeek
2113+
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"
2124+
2125+instance FromJSONKey DayOfWeek where
2126+ fromJSONKey = FromJSONKeyTextParser parseDayOfWeek
2127+
17752128-------------------------------------------------------------------------------
17762129-- base Monoid/Semigroup
17772130-------------------------------------------------------------------------------
@@ -1892,14 +2245,15 @@ instance FromJSON a => FromJSON (Semigroup.Option a) where
18922245
18932246instance FromJSON1 Proxy where
18942247 {-# INLINE liftParseJSON #-}
1895− liftParseJSON _ _ Null = pure Proxy
1896− liftParseJSON _ _ v = typeMismatch "Proxy" v
2248+ liftParseJSON _ _ = fromNull "Proxy" Proxy
18972249
18982250instance FromJSON (Proxy a) where
18992251 {-# INLINE parseJSON #-}
1900− parseJSON Null = pure Proxy
1901− parseJSON v = typeMismatch "Proxy" v
2252+ parseJSON = fromNull "Proxy" Proxy
19022253
2254+fromNull :: String -> a -> Value -> Parser a
2255+fromNull _ a Null = pure a
2256+fromNull c _ v = prependContext c (typeMismatch "Null" v)
19032257
19042258instance FromJSON2 Tagged where
19052259 liftParseJSON2 _ _ p _ = fmap Tagged . p
@@ -1926,10 +2280,7 @@ instance (FromJSON a, FromJSON b, FromJSON c) => FromJSONKey (a,b,c)
19262280instance (FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSONKey (a,b,c,d)
19272281
19282282instance FromJSONKey Char where
1929− fromJSONKey = FromJSONKeyTextParser $ \t ->
1930− if T.length t == 1
1931− then return (T.index t 0)
1932− else typeMismatch "Expected Char but String didn't contain exactly one character" (String t)
2283+ fromJSONKey = FromJSONKeyTextParser parseChar
19332284 fromJSONKeyList = FromJSONKeyText T.unpack
19342285
19352286instance (FromJSONKey a, FromJSON a) => FromJSONKey [a] where