@@ -5,16 +5,19 @@
55{-# LANGUAGE FlexibleInstances #-}
66{-# LANGUAGE GADTs #-}
77{-# LANGUAGE MultiParamTypeClasses #-}
8−{-# LANGUAGE NoImplicitPrelude #-}
8+{-# LANGUAGE NamedFieldPuns #-}
99{-# LANGUAGE OverloadedStrings #-}
10−{-# LANGUAGE PolyKinds #-}
1110{-# LANGUAGE RecordWildCards #-}
1211{-# LANGUAGE ScopedTypeVariables #-}
1312{-# LANGUAGE TypeOperators #-}
14−{-# LANGUAGE TupleSections #-}
13+{-# LANGUAGE TypeSynonymInstances #-}
1514{-# LANGUAGE UndecidableInstances #-}
1615{-# LANGUAGE ViewPatterns #-}
1716
17+#if __GLASGOW_HASKELL__ >= 706
18+{-# LANGUAGE PolyKinds #-}
19+#endif
20+
1821#include "incoherent-compat.h"
1922#include "overlapping-compat.h"
2023
@@ -42,9 +45,6 @@ module Data.Aeson.Types.FromJSON
4245 , coerceFromJSONKeyFunction
4346 , mapFromJSONKeyFunction
4447
45− , GFromJSONKey()
46− , genericFromJSONKey
47−
4848 -- * List functions
4949 , listParser
5050
@@ -60,14 +60,12 @@ module Data.Aeson.Types.FromJSON
6060 , fromJSON
6161 , ifromJSON
6262 , typeMismatch
63− , unexpected
6463 , parseField
6564 , parseFieldMaybe
6665 , parseFieldMaybe'
6766 , explicitParseField
6867 , explicitParseFieldMaybe
6968 , explicitParseFieldMaybe'
70− , parseIndexedJSON
7169 -- ** Operators
7270 , (.:)
7371 , (.:?)
@@ -78,16 +76,17 @@ module Data.Aeson.Types.FromJSON
7876 , parseOptionalFieldWith
7977 ) where
8078
79+import Prelude ()
8180import Prelude.Compat
8281
83−import Control.Applicative ((<|>), Const(..), liftA2)
84−import Control.Monad (zipWithM)
82+import Control.Applicative ((<|>), Const(..))
83+import Control.Monad ((<=<), zipWithM)
8584import Data.Aeson.Internal.Functions (mapKey)
8685import Data.Aeson.Parser.Internal (eitherDecodeWith, jsonEOF)
8786import Data.Aeson.Types.Generic
8887import Data.Aeson.Types.Internal
8988import Data.Bits (unsafeShiftR)
90−import Data.Fixed (Fixed, HasResolution (resolution), Nano)
89+import Data.Fixed (Fixed, HasResolution)
9190import Data.Functor.Compose (Compose(..))
9291import Data.Functor.Identity (Identity(..))
9392import Data.Functor.Product (Product(..))
@@ -103,14 +102,11 @@ import Data.Scientific (Scientific, base10Exponent)
103102import Data.Tagged (Tagged(..))
104103import Data.Text (Text, pack, unpack)
105104import Data.Time (Day, DiffTime, LocalTime, NominalDiffTime, TimeOfDay, UTCTime, ZonedTime)
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)
105+import Data.Time.Format (parseTime)
106+import Data.Time.Locale.Compat (defaultTimeLocale)
110107import Data.Traversable as Tr (sequence)
111108import Data.Vector (Vector)
112109import Data.Version (Version, parseVersion)
113−import Data.Void (Void)
114110import Data.Word (Word16, Word32, Word64, Word8)
115111import Foreign.Storable (Storable)
116112import Foreign.C.Types (CTime (..))
@@ -118,9 +114,9 @@ import GHC.Generics
118114import Numeric.Natural (Natural)
119115import Text.ParserCombinators.ReadP (readP_to_S)
120116import Unsafe.Coerce (unsafeCoerce)
117+import qualified Data.Aeson.Compat as Compat
121118import qualified Data.Aeson.Parser.Time as Time
122119import qualified Data.Attoparsec.ByteString.Char8 as A (endOfInput, parseOnly, scientific)
123−import qualified Data.ByteString.Lazy as L
124120import qualified Data.DList as DList
125121import qualified Data.HashMap.Strict as H
126122import qualified Data.HashSet as HashSet
@@ -148,15 +144,23 @@ import qualified Data.Primitive.Array as PM
148144import qualified Data.Primitive.SmallArray as PM
149145import qualified Data.Primitive.Types as PM
150146
151−#if MIN_VERSION_primitive(0,6,4)
152−#if !MIN_VERSION_primitive(0,7,0)
147+#if (MIN_VERSION_primitive(0,6,4))
153148import qualified Data.Primitive.UnliftedArray as PM
154−#endif
155149import qualified Data.Primitive.PrimArray as PM
156150#endif
157151
152+#ifndef HAS_COERCIBLE
153+#define HAS_COERCIBLE (__GLASGOW_HASKELL__ >= 707)
154+#endif
158155
156+#if HAS_COERCIBLE
159157import 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
160164
161165parseIndexedJSON :: (Value -> Parser a) -> Int -> Value -> Parser a
162166parseIndexedJSON p idx value = p value <?> Index idx
@@ -165,7 +169,7 @@ parseIndexedJSON p idx value = p value <?> Index idx
165169parseIndexedJSONPair :: (Value -> Parser a) -> (Value -> Parser b) -> Int -> Value -> Parser (a, b)
166170parseIndexedJSONPair keyParser valParser idx value = p value <?> Index idx
167171 where
168− p = withArray "(k, v)" $ \ab ->
172+ p = withArray "(k,v)" $ \ab ->
169173 let n = V.length ab
170174 in if n == 2
171175 then (,) <$> parseJSONElemAtIndex keyParser 0 ab
@@ -178,33 +182,33 @@ parseJSONElemAtIndex :: (Value -> Parser a) -> Int -> V.Vector Value -> Parser a
178182parseJSONElemAtIndex p idx ary = p (V.unsafeIndex ary idx) <?> Index idx
179183
180184parseRealFloat :: RealFloat a => String -> Value -> Parser a
181−parseRealFloat _ (Number s) = pure $ Scientific.toRealFloat s
182−parseRealFloat _ Null = pure (0/0)
183−parseRealFloat name v = prependContext name (unexpected v)
185+parseRealFloat _ (Number s) = pure $ Scientific.toRealFloat s
186+parseRealFloat _ Null = pure (0/0)
187+parseRealFloat expected v = typeMismatch expected v
184188{-# INLINE parseRealFloat #-}
185189
186−parseIntegralFromScientific :: forall a. Integral a => Scientific -> Parser a
187−parseIntegralFromScientific s =
190+parseIntegralFromScientific :: forall a. Integral a => String -> Scientific -> Parser a
191+parseIntegralFromScientific expected s =
188192 case Scientific.floatingOrInteger s :: Either Double a of
189193 Right x -> pure x
190− Left _ -> fail $ "unexpected floating number " ++ show s
194+ Left _ -> fail $ "expected " ++ expected ++ ", encountered floating number " ++ show s
191195{-# INLINE parseIntegralFromScientific #-}
192196
193197parseIntegral :: Integral a => String -> Value -> Parser a
194−parseIntegral name =
195− prependContext name . withBoundedScientific' parseIntegralFromScientific
198+parseIntegral expected =
199+ withBoundedScientific expected $ parseIntegralFromScientific expected
196200{-# INLINE parseIntegral #-}
197201
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)
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)
201205 pure
202206 (Scientific.toBoundedInteger s)
203207{-# INLINE parseBoundedIntegralFromScientific #-}
204208
205209parseBoundedIntegral :: (Bounded a, Integral a) => String -> Value -> Parser a
206−parseBoundedIntegral name =
207− prependContext name . withScientific' parseBoundedIntegralFromScientific
210+parseBoundedIntegral expected =
211+ withScientific expected $ parseBoundedIntegralFromScientific expected
208212{-# INLINE parseBoundedIntegral #-}
209213
210214parseScientificText :: Text -> Parser Scientific
@@ -214,20 +218,18 @@ parseScientificText
214218 . T.encodeUtf8
215219
216220parseIntegralText :: Integral a => String -> Text -> Parser a
217−parseIntegralText name t =
218− prependContext name $
219− parseScientificText t
220− >>= rejectLargeExponent
221− >>= parseIntegralFromScientific
221+parseIntegralText expected t
222+ = parseScientificText t
223+ >>= rejectLargeExponent
224+ >>= parseIntegralFromScientific expected
222225 where
223226 rejectLargeExponent :: Scientific -> Parser Scientific
224− rejectLargeExponent s = withBoundedScientific' pure (Number s)
227+ rejectLargeExponent s = withBoundedScientific expected pure (Number s)
225228{-# INLINE parseIntegralText #-}
226229
227230parseBoundedIntegralText :: (Bounded a, Integral a) => String -> Text -> Parser a
228−parseBoundedIntegralText name t =
229− prependContext name $
230− parseScientificText t >>= parseBoundedIntegralFromScientific
231+parseBoundedIntegralText expected t =
232+ parseScientificText t >>= parseBoundedIntegralFromScientific expected
231233
232234parseOptionalFieldWith :: (Value -> Parser (Maybe a))
233235 -> Object -> Text -> Parser (Maybe a)
@@ -287,21 +289,14 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
287289--
288290-- The basic ways to signal a failed conversion are as follows:
289291--
290−-- * 'fail' yields a custom error message: it is the recommended way of
291−-- reporting a failure;
292+-- * 'empty' and 'mzero' work, but are terse and uninformative;
292293--
293−-- * 'Control.Applicative.empty' (or 'Control.Monad.mzero') is uninformative:
294−-- use it when the error is meant to be caught by some @('<|>')@;
294+-- * 'fail' yields a custom error message;
295295--
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.
296+-- * 'typeMismatch' produces an informative message for cases when the
297+-- value encountered is not of the expected type.
300298--
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':
299+-- An example type and instance using 'typeMismatch':
305300--
306301-- @
307302-- \-- Allow ourselves to write 'Text' literals.
@@ -315,15 +310,13 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
315310-- '<*>' v '.:' \"y\"
316311--
317312-- \-- We do not expect a non-'Object' value here.
318−-- \-- We could use 'Control.Applicative.empty' to fail, but 'typeMismatch'
313+-- \-- We could use 'mzero' to fail, but 'typeMismatch'
319314-- \-- gives a much more informative error message.
320−-- 'parseJSON' invalid =
321−-- 'prependFailure' "parsing Coord failed, "
322−-- ('typeMismatch' \"Object\" invalid)
315+-- 'parseJSON' invalid = 'typeMismatch' \"Coord\" invalid
323316-- @
324317--
325318-- For this common case of only being concerned with a single
326−-- type of JSON value, the functions 'withObject', 'withScientific', etc.
319+-- type of JSON value, the functions 'withObject', 'withNumber', etc.
327320-- are provided. Their use is to be preferred when possible, since
328321-- they are more terse. Using 'withObject', we can rewrite the above instance
329322-- (assuming the same language extension and data type) as:
@@ -362,7 +355,7 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
362355-- @
363356--
364357-- The default implementation will be equivalent to
365−-- @parseJSON = 'genericParseJSON' 'defaultOptions'@; if you need different
358+-- @parseJSON = 'genericParseJSON' 'defaultOptions'@; If you need different
366359-- options, you can customize the generic decoding by defining:
367360--
368361-- @
@@ -380,11 +373,13 @@ class FromJSON a where
380373 parseJSON = genericParseJSON defaultOptions
381374
382375 parseJSONList :: Value -> Parser [a]
383− parseJSONList = withArray "[]" $ \a ->
384− zipWithM (parseIndexedJSON parseJSON) [0..]
376+ parseJSONList (Array a)
377+ = zipWithM (parseIndexedJSON parseJSON) [0..]
385378 . V.toList
386379 $ a
387380
381+ parseJSONList v = typeMismatch "[a]" v
382+
388383-------------------------------------------------------------------------------
389384-- Classes and types for map keys
390385-------------------------------------------------------------------------------
@@ -396,16 +391,6 @@ class FromJSON a where
396391-- > newtype SomeId = SomeId { getSomeId :: Text }
397392-- > deriving (Eq,Ord,Hashable,FromJSONKey)
398393--
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−-- @
409394class FromJSONKey a where
410395 -- | Strategy for parsing the key of a map-like container.
411396 fromJSONKey :: FromJSONKeyFunction a
@@ -428,7 +413,11 @@ class FromJSONKey a where
428413-- At the moment this type is intentionally not exported. 'FromJSONKeyFunction'
429414-- can be inspected, but cannot be constructed.
430415data CoerceText a where
416+#if HAS_COERCIBLE
431417 CoerceText :: Coercible Text a => CoerceText a
418+#else
419+ CoerceText :: CoerceText a
420+#endif
432421
433422-- | This type is related to 'ToJSONKeyFunction'. If 'FromJSONKeyValue' is used in the
434423-- 'FromJSONKey' instance, then 'ToJSONKeyValue' should be used in the 'ToJSONKey'
@@ -448,7 +437,7 @@ data FromJSONKeyFunction a
448437
449438-- | Only law abiding up to interpretation
450439instance Functor FromJSONKeyFunction where
451− fmap h (FromJSONKeyCoerce CoerceText) = FromJSONKeyText (h . coerce)
440+ fmap h (FromJSONKeyCoerce CoerceText) = FromJSONKeyText (h . coerce')
452441 fmap h (FromJSONKeyText f) = FromJSONKeyText (h . f)
453442 fmap h (FromJSONKeyTextParser f) = FromJSONKeyTextParser (fmap h . f)
454443 fmap h (FromJSONKeyValue f) = FromJSONKeyValue (fmap h . f)
@@ -462,7 +451,9 @@ instance Functor FromJSONKeyFunction where
462451--
463452-- On pre GHC 7.8 this is unconstrainted function.
464453fromJSONKeyCoerce ::
454+#if HAS_COERCIBLE
465455 Coercible Text a =>
456+#endif
466457 FromJSONKeyFunction a
467458fromJSONKeyCoerce = FromJSONKeyCoerce CoerceText
468459
@@ -470,91 +461,60 @@ fromJSONKeyCoerce = FromJSONKeyCoerce CoerceText
470461--
471462-- See note on 'fromJSONKeyCoerce'.
472463coerceFromJSONKeyFunction ::
464+#if HAS_COERCIBLE
473465 Coercible a b =>
466+#endif
474467 FromJSONKeyFunction a -> FromJSONKeyFunction b
468+#if HAS_COERCIBLE
475469coerceFromJSONKeyFunction = 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
481482{-# RULES
482483 "FromJSONKeyCoerce: fmap coerce" forall x .
483484 fmap coerce x = coerceFromJSONKeyFunction x
484485 #-}
486+#endif
485487
486488-- | Same as 'fmap'. Provided for the consistency with 'ToJSONKeyFunction'.
487489mapFromJSONKeyFunction :: (a -> b) -> FromJSONKeyFunction a -> FromJSONKeyFunction b
488490mapFromJSONKeyFunction = fmap
489491
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−
519492-------------------------------------------------------------------------------
520493-- Functions needed for documentation
521494-------------------------------------------------------------------------------
522495
523496-- | Fail parsing due to a type mismatch, with a descriptive message.
524497--
525−-- The following wrappers should generally be prefered:
526−-- 'withObject', 'withArray', 'withText', 'withBool'.
527−--
528−-- ==== Error message example
498+-- Example usage:
529499--
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\"@).
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.
535506 -> Value -- ^ The actual value encountered.
536507 -> Parser a
537508typeMismatch expected actual =
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"
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"
558518
559519-------------------------------------------------------------------------------
560520-- Lifings of FromJSON and ToJSON to unary and binary type constructors
@@ -635,8 +595,9 @@ class FromJSON2 f where
635595 -> (Value -> Parser b)
636596 -> (Value -> Parser [b])
637597 -> Value -> Parser [f a b]
638− liftParseJSONList2 fa ga fb gb = withArray "[]" $ \vals ->
639− fmap V.toList (V.mapM (liftParseJSON2 fa ga fb gb) vals)
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
640601
641602-- | Lift the standard 'parseJSON' function through the type constructor.
642603parseJSON2 :: (FromJSON2 f, FromJSON a, FromJSON b) => Value -> Parser (f a b)
@@ -650,7 +611,7 @@ parseJSON2 = liftParseJSON2 parseJSON parseJSONList parseJSON parseJSONList
650611-- | Helper function to use with 'liftParseJSON'. See 'Data.Aeson.ToJSON.listEncoding'.
651612listParser :: (Value -> Parser a) -> Value -> Parser [a]
652613listParser f (Array xs) = fmap V.toList (V.mapM f xs)
653−listParser _ v = typeMismatch "Array" v
614+listParser _ v = typeMismatch "[a]" v
654615{-# INLINE listParser #-}
655616
656617-------------------------------------------------------------------------------
@@ -668,137 +629,69 @@ instance (FromJSON a) => FromJSON [a] where
668629-- Functions
669630-------------------------------------------------------------------------------
670631
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"
632+-- | @'withObject' expected f value@ applies @f@ to the 'Object' when @value@
633+-- is an 'Object' and fails using @'typeMismatch' expected@ otherwise.
686634withObject :: String -> (Object -> Parser a) -> Value -> Parser a
687−withObject _ f (Object obj) = f obj
688−withObject name _ v = prependContext name (typeMismatch "Object" v)
635+withObject _ f (Object obj) = f obj
636+withObject expected _ v = typeMismatch expected v
689637{-# INLINE withObject #-}
690638
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"
639+-- | @'withText' expected f value@ applies @f@ to the 'Text' when @value@ is a
640+-- 'String' and fails using @'typeMismatch' expected@ otherwise.
698641withText :: String -> (Text -> Parser a) -> Value -> Parser a
699−withText _ f (String txt) = f txt
700−withText name _ v = prependContext name (typeMismatch "String" v)
642+withText _ f (String txt) = f txt
643+withText expected _ v = typeMismatch expected v
701644{-# INLINE withText #-}
702645
703646-- | @'withArray' expected f value@ applies @f@ to the 'Array' when @value@ is
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"
647+-- an 'Array' and fails using @'typeMismatch' expected@ otherwise.
710648withArray :: String -> (Array -> Parser a) -> Value -> Parser a
711−withArray _ f (Array arr) = f arr
712−withArray name _ v = prependContext name (typeMismatch "Array" v)
649+withArray _ f (Array arr) = f arr
650+withArray expected _ v = typeMismatch expected v
713651{-# INLINE withArray #-}
714652
715−-- | @'withScientific' name f value@ applies @f@ to the 'Scientific' number
716−-- when @value@ is a 'Data.Aeson.Number' and fails using 'typeMismatch'
653+-- | @'withScientific' expected f value@ applies @f@ to the 'Scientific' number
654+-- when @value@ is a 'Number' and fails using @'typeMismatch' expected@
717655-- otherwise.
718−--
656+-- .
719657-- /Warning/: If you are converting from a scientific to an unbounded
720658-- type such as 'Integer' you may want to add a restriction on the
721659-- size of the exponent (see 'withBoundedScientific') to prevent
722660-- 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"
728661withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
729−withScientific _ f (Number scientific) = f scientific
730−withScientific name _ v = prependContext name (typeMismatch "Number" v)
662+withScientific _ f (Number scientific) = f scientific
663+withScientific expected _ v = typeMismatch expected v
731664{-# INLINE withScientific #-}
732665
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.
741−--
742−-- ==== Error message examples
666+-- | @'withBoundedScientific' expected f value@ applies @f@ to the 'Scientific' number
667+-- when @value@ is a 'Number' and fails using @'typeMismatch' expected@
668+-- otherwise.
743669--
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.
670+-- The conversion will also fail wyth a @'typeMismatch' if the
671+-- 'Scientific' exponent is larger than 1024.
757672withBoundedScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
758−withBoundedScientific name f v = withBoundedScientific_ (prependContext name) f v
759−{-# INLINE withBoundedScientific #-}
760−
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)
673+withBoundedScientific _ f v@(Number scientific) =
674+ if base10Exponent scientific > 1024
675+ then typeMismatch "a number with exponent <= 1024" v
774676 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_ #-}
677+withBoundedScientific expected _ v = typeMismatch expected v
678+{-# INLINE withBoundedScientific #-}
781679
782680-- | @'withBool' expected f value@ applies @f@ to the 'Bool' when @value@ is a
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"
681+-- 'Bool' and fails using @'typeMismatch' expected@ otherwise.
789682withBool :: String -> (Bool -> Parser a) -> Value -> Parser a
790−withBool _ f (Bool arr) = f arr
791−withBool name _ v = prependContext name (typeMismatch "Boolean" v)
683+withBool _ f (Bool arr) = f arr
684+withBool expected _ v = typeMismatch expected v
792685{-# INLINE withBool #-}
793686
794687-- | Decode a nested JSON-encoded string.
795688withEmbeddedJSON :: String -> (Value -> Parser a) -> Value -> Parser a
796689withEmbeddedJSON _ innerParser (String txt) =
797− either fail innerParser $ eitherDecode (L.fromStrict $ T.encodeUtf8 txt)
690+ either fail innerParser $ eitherDecode (Compat.fromStrict $ T.encodeUtf8 txt)
798691 where
799692 eitherDecode = eitherFormatError . eitherDecodeWith jsonEOF ifromJSON
800693 eitherFormatError = either (Left . uncurry formatError) Right
801−withEmbeddedJSON name _ v = prependContext name (typeMismatch "String" v)
694+withEmbeddedJSON name _ v = typeMismatch name v
802695{-# INLINE withEmbeddedJSON #-}
803696
804697-- | Convert a value from JSON, failing if the types do not match.
@@ -863,7 +756,7 @@ parseFieldMaybe' = (.:!)
863756-- E.g. @'explicitParseField' 'parseJSON1' :: ('FromJSON1' f, 'FromJSON' a) -> 'Object' -> 'Text' -> 'Parser' (f a)@
864757explicitParseField :: (Value -> Parser a) -> Object -> Text -> Parser a
865758explicitParseField p obj key = case H.lookup key obj of
866− Nothing -> fail $ "key " ++ show key ++ " not found"
759+ Nothing -> fail $ "key " ++ show key ++ " not present"
867760 Just v -> p v <?> Key key
868761{-# INLINE explicitParseField #-}
869762
@@ -903,47 +796,11 @@ pmval .!= val = fromMaybe val <$> pmval
903796-- Generic parseJSON
904797-------------------------------------------------------------------------------
905798
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−
911799instance OVERLAPPABLE_ (GFromJSON arity a) => GFromJSON arity (M1 i c a) where
912800 -- Meta-information, which is not handled elsewhere, is just added to the
913801 -- parsed value:
914802 gParseJSON opts fargs = fmap M1 . gParseJSON opts fargs
915803
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−
947804instance (FromJSON a) => GFromJSON arity (K1 i a) where
948805 -- Constant values are decoded using their FromJSON instance:
949806 gParseJSON _opts _ = fmap K1 . parseJSON
@@ -958,499 +815,342 @@ instance (FromJSON1 f) => GFromJSON One (Rec1 f) where
958815 -- FromJSON1 instance:
959816 gParseJSON _opts (From1Args pj pjl) = fmap Rec1 . liftParseJSON pj pjl
960817
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−--------------------------------------------------------------------------------
970−
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)
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
985823
986−-- | Single constructor.
987824instance ( ConsFromJSON arity a
988825 , AllNullary (C1 c a) allNullary
989826 , ParseSum arity (C1 c a) allNullary
990− , Constructor c
991− ) => GFromJSON' arity (C1 c a) where
827+ ) => GFromJSON arity (D1 d (C1 c a)) where
992828 -- The option 'tagSingleConstructors' determines whether to wrap
993829 -- a single-constructor type.
994− gParseJSON' p@(_ :* opts :* _)
830+ gParseJSON opts fargs
995831 | tagSingleConstructors opts
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
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
1006861 -- If all constructors of a sum datatype are nullary and the
1007862 -- 'allNullaryToStringTag' option is set they are expected to be
1008863 -- encoded as strings. This distinction is made by 'parseSum':
1009− gParseJSON' p =
1010− (unTagged :: Tagged allNullary (Parser ((a :+: b) _d)) ->
1011− Parser ((a :+: b) _d))
1012− . parseSum p
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)
1013876
1014877--------------------------------------------------------------------------------
1015878
1016879class ParseSum arity f allNullary where
1017− parseSum :: TypeName :* Options :* FromArgs arity a
1018− -> Value
1019− -> Tagged allNullary (Parser (f a))
880+ parseSum :: Options -> FromArgs arity a
881+ -> Value -> Tagged allNullary (Parser (f a))
1020882
1021−instance ( ConstructorNames f
1022− , SumFromString f
883+instance ( SumFromString f
1023884 , FromPair arity f
1024885 , FromTaggedObject arity f
1025886 , FromUntaggedValue arity f
1026887 ) => ParseSum arity f True where
1027− parseSum p@(tname :* opts :* _)
1028− | allNullaryToStringTag opts = Tagged . parseAllNullarySum tname opts
1029− | otherwise = Tagged . parseNonAllNullarySum p
888+ parseSum opts fargs
889+ | allNullaryToStringTag opts = Tagged . parseAllNullarySum opts
890+ | otherwise = Tagged . parseNonAllNullarySum opts fargs
1030891
1031−instance ( ConstructorNames f
1032− , FromPair arity f
892+instance ( FromPair arity f
1033893 , FromTaggedObject arity f
1034894 , FromUntaggedValue arity f
1035895 ) => ParseSum arity f False where
1036− parseSum p = Tagged . parseNonAllNullarySum p
896+ parseSum opts fargs = Tagged . parseNonAllNullarySum opts fargs
1037897
1038898--------------------------------------------------------------------------------
1039899
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])
900+parseAllNullarySum :: SumFromString f => Options -> Value -> Parser (f a)
901+parseAllNullarySum opts = withText "Text" $ \key ->
902+ maybe (notFound key) return $
903+ parseSumFromString opts key
1062904
1063905class SumFromString f where
1064− parseSumFromString :: (String -> String) -> Text -> Maybe (f a)
906+ parseSumFromString :: Options -> Text -> Maybe (f a)
1065907
1066908instance (SumFromString a, SumFromString b) => SumFromString (a :+: b) where
1067909 parseSumFromString opts key = (L1 <$> parseSumFromString opts key) <|>
1068910 (R1 <$> parseSumFromString opts key)
1069911
1070912instance (Constructor c) => SumFromString (C1 c U1) where
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)
1076−
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)
1085−
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
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)
1111918
1112919--------------------------------------------------------------------------------
1113−parseNonAllNullarySum :: forall f c arity.
1114− ( FromPair arity f
920+
921+parseNonAllNullarySum :: ( FromPair arity f
1115922 , FromTaggedObject arity f
1116923 , FromUntaggedValue arity f
1117− , ConstructorNames f
1118− ) => TypeName :* Options :* FromArgs arity c
924+ ) => Options -> FromArgs arity c
1119925 -> Value -> Parser (f c)
1120−parseNonAllNullarySum p@(tname :* opts :* _) =
926+parseNonAllNullarySum opts fargs =
1121927 case sumEncoding opts of
1122928 TaggedObject{..} ->
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])
929+ withObject "Object" $ \obj -> do
930+ tag <- obj .: pack tagFieldName
931+ fromMaybe (notFound tag) $
932+ parseFromTaggedObject opts fargs contentsFieldName obj tag
1133933
1134934 ObjectWithSingleField ->
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
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"
1145940
1146941 TwoElemArray ->
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
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"
1161949
1162− UntaggedValue -> parseUntaggedValue p
1163− where
1164− failWith_ = failWithCTags tname (constructorTagModifier opts)
950+ UntaggedValue -> parseUntaggedValue opts fargs
1165951
1166952--------------------------------------------------------------------------------
1167953
1168954class FromTaggedObject arity f where
1169− -- The first two components of the parameter tuple are: the constructor tag
1170− -- to match against, and the contents field name.
1171− parseFromTaggedObject
1172− :: Text :* String :* TypeName :* Options :* FromArgs arity a
1173− -> Object
1174− -> Maybe (Parser (f a))
955+ parseFromTaggedObject :: Options -> FromArgs arity a
956+ -> String -> Object
957+ -> Text -> Maybe (Parser (f a))
1175958
1176959instance ( FromTaggedObject arity a, FromTaggedObject arity b) =>
1177960 FromTaggedObject arity (a :+: b) where
1178− parseFromTaggedObject p obj =
1179− (fmap L1 <$> parseFromTaggedObject p obj) <|>
1180− (fmap R1 <$> parseFromTaggedObject p obj)
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)
1181964
1182−instance ( IsRecord f isRecord
1183− , FromTaggedObject' arity f isRecord
965+instance ( FromTaggedObject' arity f
1184966 , Constructor c
1185967 ) => FromTaggedObject arity (C1 c f) where
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)
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)
1195975
1196976--------------------------------------------------------------------------------
1197977
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
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))
1216985
1217−instance OVERLAPPING_ FromTaggedObject' arity U1 False where
1218− -- Nullary constructors don't need a contents field
1219− parseFromTaggedObject' _ _ = Tagged (pure U1)
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))
1000+
1001+instance OVERLAPPING_ FromTaggedObject'' arity U1 False where
1002+ parseFromTaggedObject'' _ _ _ _ = Tagged (pure U1)
12201003
12211004--------------------------------------------------------------------------------
12221005
1223−-- | Constructors need to be decoded differently depending on whether they're
1224−-- a record or not. This distinction is made by 'ConsParseJSON'.
12251006class ConsFromJSON arity f where
1226− consParseJSON
1227− :: ConName :* TypeName :* Options :* FromArgs arity a
1228− -> Value -> Parser (f a)
1007+ consParseJSON :: Options -> FromArgs arity a
1008+ -> Value -> Parser (f a)
12291009
12301010class ConsFromJSON' arity f isRecord where
1231− consParseJSON'
1232− :: ConName :* TypeName :* Options :* FromArgs arity a
1233− -> Value -> Tagged isRecord (Parser (f a))
1011+ consParseJSON' :: Options -> FromArgs arity a
1012+ -> Value -> Tagged isRecord (Parser (f a))
12341013
12351014instance ( IsRecord f isRecord
12361015 , ConsFromJSON' arity f isRecord
12371016 ) => ConsFromJSON arity f where
1238− consParseJSON p =
1017+ consParseJSON opts fargs =
12391018 (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a))
1240− . consParseJSON' p
1019+ . consParseJSON' opts fargs
12411020
12421021instance OVERLAPPING_
1243− ( GFromJSON arity a, RecordFromJSON arity (S1 s a)
1022+ ( GFromJSON arity a, FromRecord arity (S1 s a)
12441023 ) => ConsFromJSON' arity (S1 s a) True where
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))
1252−
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)
1024+ consParseJSON' opts fargs
1025+ | unwrapUnaryRecords opts = Tagged . gParseJSON opts fargs
1026+ | otherwise = Tagged . withObject "unary record" (parseRecord opts fargs)
12651027
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
1028+instance FromRecord arity f => ConsFromJSON' arity f True where
1029+ consParseJSON' opts fargs =
1030+ Tagged . withObject "record (:*:)" (parseRecord opts fargs)
12701031
1271−instance (ProductFromJSON arity f, ProductSize f
1272− ) => ConsFromJSON' arity f False where
1273− consParseJSON' p = Tagged . productParseJSON0 p
1032+instance GFromJSON arity f => ConsFromJSON' arity f False where
1033+ consParseJSON' opts fargs = Tagged . gParseJSON opts fargs
12741034
12751035--------------------------------------------------------------------------------
12761036
1277−class FieldNames f where
1278− fieldNames :: f a -> [Text] -> [Text]
1279−
1280−instance (FieldNames a, FieldNames b) => FieldNames (a :*: b) where
1281− fieldNames _ =
1282− fieldNames (undefined :: a x) .
1283− fieldNames (undefined :: b y)
1037+class FromRecord arity f where
1038+ parseRecord :: Options -> FromArgs arity a
1039+ -> Object -> Parser (f a)
12841040
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
1298− where
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
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
13221047
13231048instance 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)
1049+ FromRecord arity (S1 s a) where
1050+ parseRecord opts fargs =
1051+ (<?> Key label) . gParseJSON opts fargs <=< (.: label)
1052+ where
1053+ label = pack . fieldLabelModifier opts $ selName (undefined :: t s a p)
13311054
13321055instance INCOHERENT_ (Selector s, FromJSON a) =>
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)
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)
13381061
13391062-- Parse an Option like a Maybe.
13401063instance INCOHERENT_ (Selector s, FromJSON a) =>
1341− RecordFromJSON' arity (S1 s (K1 i (Semigroup.Option a))) where
1342− recordParseJSON' p obj = wrap <$> recordParseJSON' p obj
1064+ FromRecord arity (S1 s (K1 i (Semigroup.Option a))) where
1065+ parseRecord opts fargs obj = wrap <$> parseRecord opts fargs obj
13431066 where
13441067 wrap :: S1 s (K1 i (Maybe a)) p -> S1 s (K1 i (Semigroup.Option a)) p
13451068 wrap (M1 (K1 a)) = M1 (K1 (Semigroup.Option a))
13461069
13471070--------------------------------------------------------------------------------
13481071
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
1072+class FromProduct arity f where
1073+ parseProduct :: Options -> FromArgs arity a
13711074 -> Array -> Int -> Int
13721075 -> Parser (f a)
13731076
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
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
13801083 where
13811084 lenL = len `unsafeShiftR` 1
13821085 ixR = ix + lenL
13831086 lenR = len - lenL
13841087
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
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
13881091
13891092--------------------------------------------------------------------------------
13901093
13911094class FromPair arity f where
1392− -- The first component of the parameter tuple is the tag to match.
1393− parsePair :: Text :* TypeName :* Options :* FromArgs arity a
1394− -> Value
1395− -> Maybe (Parser (f a))
1095+ parsePair :: Options -> FromArgs arity a
1096+ -> Pair -> Maybe (Parser (f a))
13961097
13971098instance ( FromPair arity a
13981099 , FromPair arity b
13991100 ) => FromPair arity (a :+: b) where
1400− parsePair p pair =
1401− (fmap L1 <$> parsePair p pair) <|>
1402− (fmap R1 <$> parsePair p pair)
1101+ parsePair opts fargs pair = (fmap L1 <$> parsePair opts fargs pair) <|>
1102+ (fmap R1 <$> parsePair opts fargs pair)
14031103
14041104instance ( Constructor c
1105+ , GFromJSON arity a
14051106 , ConsFromJSON arity a
14061107 ) => FromPair arity (C1 c a) where
1407− parsePair (tag :* p@(_ :* opts :* _)) v
1408− | tag == tag' = Just $ M1 <$> consParseJSON (cname :* p) v
1108+ parsePair opts fargs (tag, value)
1109+ | tag == tag' = Just $ gParseJSON opts fargs value
14091110 | otherwise = Nothing
1410− where
1411− tag' = pack $ constructorTagModifier opts cname
1412− cname = conName (undefined :: M1 _i c _a _p)
1111+ where
1112+ tag' = pack $ constructorTagModifier opts $
1113+ conName (undefined :: t c a p)
14131114
14141115--------------------------------------------------------------------------------
14151116
14161117class FromUntaggedValue arity f where
1417− parseUntaggedValue :: TypeName :* Options :* FromArgs arity a
1418− -> Value
1419− -> Parser (f a)
1118+ parseUntaggedValue :: Options -> FromArgs arity a
1119+ -> Value -> Parser (f a)
14201120
14211121instance
14221122 ( FromUntaggedValue arity a
14231123 , FromUntaggedValue arity b
14241124 ) => FromUntaggedValue arity (a :+: b)
14251125 where
1426− parseUntaggedValue p value =
1427− L1 <$> parseUntaggedValue p value <|>
1428− R1 <$> parseUntaggedValue p value
1126+ parseUntaggedValue opts fargs value =
1127+ L1 <$> parseUntaggedValue opts fargs value <|>
1128+ R1 <$> parseUntaggedValue opts fargs value
14291129
14301130instance OVERLAPPABLE_
1431− ( ConsFromJSON arity a
1432− , Constructor c
1131+ ( GFromJSON arity a
1132+ , ConsFromJSON arity a
14331133 ) => FromUntaggedValue arity (C1 c a)
14341134 where
1435− parseUntaggedValue p = fmap M1 . consParseJSON (cname :* p)
1436− where
1437− cname = conName (undefined :: M1 _i c _f _p)
1135+ parseUntaggedValue = gParseJSON
14381136
14391137instance OVERLAPPING_
14401138 ( Constructor c )
14411139 => FromUntaggedValue arity (C1 c U1)
14421140 where
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
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 #-}
14541154
14551155-------------------------------------------------------------------------------
14561156-- Instances
@@ -1508,20 +1208,17 @@ instance (FromJSON a, FromJSON b) => FromJSON (Either a b) where
15081208 parseJSON = parseJSON2
15091209 {-# INLINE parseJSON #-}
15101210
1511−instance FromJSON Void where
1512− parseJSON _ = fail "Cannot parse Void"
1513− {-# INLINE parseJSON #-}
1211+
15141212
15151213instance FromJSON Bool where
1516− parseJSON (Bool b) = pure b
1517− parseJSON v = typeMismatch "Bool" v
1214+ parseJSON = withBool "Bool" pure
15181215 {-# INLINE parseJSON #-}
15191216
15201217instance FromJSONKey Bool where
15211218 fromJSONKey = FromJSONKeyTextParser $ \t -> case t of
15221219 "true" -> pure True
15231220 "false" -> pure False
1524− _ -> fail $ "cannot parse key " ++ show t ++ " into Bool"
1221+ _ -> fail $ "Cannot parse key into Bool: " ++ T.unpack t
15251222
15261223instance FromJSON Ordering where
15271224 parseJSON = withText "Ordering" $ \s ->
@@ -1529,30 +1226,25 @@ instance FromJSON Ordering where
15291226 "LT" -> return LT
15301227 "EQ" -> return EQ
15311228 "GT" -> return GT
1532− _ -> fail $ "parsing Ordering failed, unexpected " ++ show s ++
1533− " (expected \"LT\", \"EQ\", or \"GT\")"
1229+ _ -> fail "Parsing Ordering value failed: expected \"LT\", \"EQ\", or \"GT\""
15341230
15351231instance FromJSON () where
15361232 parseJSON = withArray "()" $ \v ->
15371233 if V.null v
15381234 then pure ()
1539− else prependContext "()" $ fail "expected an empty array"
1235+ else fail "Expected an empty array"
15401236 {-# INLINE parseJSON #-}
15411237
15421238instance FromJSON Char where
1543− parseJSON = withText "Char" parseChar
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"
15441243 {-# INLINE parseJSON #-}
15451244
1546− parseJSONList (String s) = pure (T.unpack s)
1547− parseJSONList v = typeMismatch "String" v
1245+ parseJSONList = withText "String" $ pure . T.unpack
15481246 {-# INLINE parseJSONList #-}
15491247
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−
15561248instance FromJSON Double where
15571249 parseJSON = parseRealFloat "Double"
15581250 {-# INLINE parseJSON #-}
@@ -1576,22 +1268,12 @@ instance FromJSONKey Float where
15761268 _ -> Scientific.toRealFloat <$> parseScientificText t
15771269
15781270instance (FromJSON a, Integral a) => FromJSON (Ratio a) where
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
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
15951277 {-# INLINE parseJSON #-}
15961278
15971279-- | This instance includes a bounds check to prevent maliciously
@@ -1599,7 +1281,7 @@ instance (FromJSON a, Integral a) => FromJSON (Ratio a) where
15991281-- newtype 'Scientific' and provide your own instance using
16001282-- 'withScientific' if you want to allow larger inputs.
16011283instance HasResolution a => FromJSON (Fixed a) where
1602− parseJSON = prependContext "Fixed" . withBoundedScientific' (pure . realToFrac)
1284+ parseJSON = withBoundedScientific "Fixed" $ pure . realToFrac
16031285 {-# INLINE parseJSON #-}
16041286
16051287instance FromJSON Int where
@@ -1622,20 +1304,19 @@ instance FromJSONKey Integer where
16221304
16231305instance FromJSON Natural where
16241306 parseJSON value = do
1625− integer <- parseIntegral "Natural" value
1626− parseNatural integer
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
16271312
16281313instance FromJSONKey Natural where
16291314 fromJSONKey = FromJSONKeyTextParser $ \text -> do
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
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
16391320
16401321instance FromJSON Int8 where
16411322 parseJSON = parseBoundedIntegral "Int8"
@@ -1732,17 +1413,17 @@ parseVersionText = go . readP_to_S parseVersion . unpack
17321413 where
17331414 go [(v,[])] = return v
17341415 go (_ : xs) = go xs
1735− go _ = fail "parsing Version failed"
1416+ go _ = fail "could not parse Version"
17361417
17371418-------------------------------------------------------------------------------
17381419-- semigroups NonEmpty
17391420-------------------------------------------------------------------------------
17401421
17411422instance FromJSON1 NonEmpty where
1742− liftParseJSON p _ = withArray "NonEmpty" $
1423+ liftParseJSON p _ = withArray "NonEmpty a" $
17431424 (>>= ne) . Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
17441425 where
1745− ne [] = fail "parsing NonEmpty failed, unexpected empty list"
1426+ ne [] = fail "Expected a NonEmpty but got an empty list"
17461427 ne (x:xs) = pure (x :| xs)
17471428 {-# INLINE liftParseJSON #-}
17481429
@@ -1763,7 +1444,7 @@ instance FromJSON Scientific where
17631444-------------------------------------------------------------------------------
17641445
17651446instance FromJSON1 DList.DList where
1766− liftParseJSON p _ = withArray "DList" $
1447+ liftParseJSON p _ = withArray "DList a" $
17671448 fmap DList.fromList .
17681449 Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
17691450 {-# INLINE liftParseJSON #-}
@@ -1840,7 +1521,7 @@ instance (FromJSON1 f, FromJSON1 g) => FromJSON1 (Sum f g) where
18401521 inr = "InR"
18411522
18421523 liftParseJSON _ _ _ = fail $
1843− "parsing Sum failed, expected an object with a single property " ++
1524+ "expected an object with a single property " ++
18441525 "where the property key should be either " ++
18451526 "\"InL\" or \"InR\""
18461527 {-# INLINE liftParseJSON #-}
@@ -1854,7 +1535,7 @@ instance (FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Sum f g a) where
18541535-------------------------------------------------------------------------------
18551536
18561537instance FromJSON1 Seq.Seq where
1857− liftParseJSON p _ = withArray "Seq" $
1538+ liftParseJSON p _ = withArray "Seq a" $
18581539 fmap Seq.fromList .
18591540 Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
18601541 {-# INLINE liftParseJSON #-}
@@ -1888,13 +1569,13 @@ instance FromJSON a => FromJSON (IntMap.IntMap a) where
18881569
18891570instance (FromJSONKey k, Ord k) => FromJSON1 (M.Map k) where
18901571 liftParseJSON p _ = case fromJSONKey of
1891− FromJSONKeyCoerce _ -> withObject "Map" $
1572+ FromJSONKeyCoerce _-> withObject "Map k v" $
18921573 fmap (H.foldrWithKey (M.insert . unsafeCoerce) M.empty) . H.traverseWithKey (\k v -> p v <?> Key k)
1893− FromJSONKeyText f -> withObject "Map" $
1574+ FromJSONKeyText f -> withObject "Map k v" $
18941575 fmap (H.foldrWithKey (M.insert . f) M.empty) . H.traverseWithKey (\k v -> p v <?> Key k)
1895− FromJSONKeyTextParser f -> withObject "Map" $
1576+ FromJSONKeyTextParser f -> withObject "Map k v" $
18961577 H.foldrWithKey (\k v m -> M.insert <$> f k <?> Key k <*> p v <?> Key k <*> m) (pure M.empty)
1897− FromJSONKeyValue f -> withArray "Map" $ \arr ->
1578+ FromJSONKeyValue f -> withArray "Map k v" $ \arr ->
18981579 fmap M.fromList . Tr.sequence .
18991580 zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr
19001581 {-# INLINE liftParseJSON #-}
@@ -1922,18 +1603,18 @@ instance (FromJSON v) => FromJSON (Tree.Tree v) where
19221603
19231604instance FromJSON UUID.UUID where
19241605 parseJSON = withText "UUID" $
1925− maybe (fail "invalid UUID") pure . UUID.fromText
1606+ maybe (fail "Invalid UUID") pure . UUID.fromText
19261607
19271608instance FromJSONKey UUID.UUID where
19281609 fromJSONKey = FromJSONKeyTextParser $
1929− maybe (fail "invalid UUID") pure . UUID.fromText
1610+ maybe (fail "Invalid UUID") pure . UUID.fromText
19301611
19311612-------------------------------------------------------------------------------
19321613-- vector
19331614-------------------------------------------------------------------------------
19341615
19351616instance FromJSON1 Vector where
1936− liftParseJSON p _ = withArray "Vector" $
1617+ liftParseJSON p _ = withArray "Vector a" $
19371618 V.mapM (uncurry $ parseIndexedJSON p) . V.indexed
19381619 {-# INLINE liftParseJSON #-}
19391620
@@ -1947,14 +1628,14 @@ vectorParseJSON s = withArray s $ fmap V.convert . V.mapM (uncurry $ parseIndexe
19471628{-# INLINE vectorParseJSON #-}
19481629
19491630instance (Storable a, FromJSON a) => FromJSON (VS.Vector a) where
1950− parseJSON = vectorParseJSON "Data.Vector.Storable.Vector"
1631+ parseJSON = vectorParseJSON "Data.Vector.Storable.Vector a"
19511632
19521633instance (VP.Prim a, FromJSON a) => FromJSON (VP.Vector a) where
1953− parseJSON = vectorParseJSON "Data.Vector.Primitive.Vector"
1634+ parseJSON = vectorParseJSON "Data.Vector.Primitive.Vector a"
19541635 {-# INLINE parseJSON #-}
19551636
19561637instance (VG.Vector VU.Vector a, FromJSON a) => FromJSON (VU.Vector a) where
1957− parseJSON = vectorParseJSON "Data.Vector.Unboxed.Vector"
1638+ parseJSON = vectorParseJSON "Data.Vector.Unboxed.Vector a"
19581639 {-# INLINE parseJSON #-}
19591640
19601641-------------------------------------------------------------------------------
@@ -1968,13 +1649,13 @@ instance (Eq a, Hashable a, FromJSON a) => FromJSON (HashSet.HashSet a) where
19681649
19691650instance (FromJSONKey k, Eq k, Hashable k) => FromJSON1 (H.HashMap k) where
19701651 liftParseJSON p _ = case fromJSONKey of
1971− FromJSONKeyCoerce _ -> withObject "HashMap ~Text" $
1652+ FromJSONKeyCoerce _ -> withObject "HashMap ~Text v" $
19721653 uc . H.traverseWithKey (\k v -> p v <?> Key k)
1973− FromJSONKeyText f -> withObject "HashMap" $
1654+ FromJSONKeyText f -> withObject "HashMap k v" $
19741655 fmap (mapKey f) . H.traverseWithKey (\k v -> p v <?> Key k)
1975− FromJSONKeyTextParser f -> withObject "HashMap" $
1656+ FromJSONKeyTextParser f -> withObject "HashMap k v" $
19761657 H.foldrWithKey (\k v m -> H.insert <$> f k <?> Key k <*> p v <?> Key k <*> m) (pure H.empty)
1977− FromJSONKeyValue f -> withArray "Map" $ \arr ->
1658+ FromJSONKeyValue f -> withArray "Map k v" $ \arr ->
19781659 fmap H.fromList . Tr.sequence .
19791660 zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr
19801661 where
@@ -1997,7 +1678,7 @@ instance FromJSON DotNetTime where
19971678 parseJSON = withText "DotNetTime" $ \t ->
19981679 let (s,m) = T.splitAt (T.length t - 5) t
19991680 t' = T.concat [s,".",m]
2000− in case parseTimeM True defaultTimeLocale "/Date(%s%Q)/" (unpack t') of
1681+ in case parseTime defaultTimeLocale "/Date(%s%Q)/" (unpack t') of
20011682 Just d -> pure (DotNetTime d)
20021683 _ -> fail "could not parse .NET time"
20031684 {-# INLINE parseJSON #-}
@@ -2014,15 +1695,13 @@ instance FromJSON a => FromJSON (PM.Array a) where
20141695instance FromJSON a => FromJSON (PM.SmallArray a) where
20151696 parseJSON = fmap Exts.fromList . parseJSON
20161697
2017−#if MIN_VERSION_primitive(0,6,4)
1698+#if (MIN_VERSION_primitive(0,6,4))
20181699instance (PM.Prim a,FromJSON a) => FromJSON (PM.PrimArray a) where
20191700 parseJSON = fmap Exts.fromList . parseJSON
20201701
2021−#if !MIN_VERSION_primitive(0,7,0)
20221702instance (PM.PrimUnlifted a,FromJSON a) => FromJSON (PM.UnliftedArray a) where
20231703 parseJSON = fmap Exts.fromList . parseJSON
20241704#endif
2025−#endif
20261705
20271706-------------------------------------------------------------------------------
20281707-- time
@@ -2091,40 +1770,6 @@ instance FromJSON DiffTime where
20911770 parseJSON = withBoundedScientific "DiffTime" $ pure . realToFrac
20921771 {-# INLINE parseJSON #-}
20931772
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−
21281773-------------------------------------------------------------------------------
21291774-- base Monoid/Semigroup
21301775-------------------------------------------------------------------------------
@@ -2245,15 +1890,14 @@ instance FromJSON a => FromJSON (Semigroup.Option a) where
22451890
22461891instance FromJSON1 Proxy where
22471892 {-# INLINE liftParseJSON #-}
2248− liftParseJSON _ _ = fromNull "Proxy" Proxy
1893+ liftParseJSON _ _ Null = pure Proxy
1894+ liftParseJSON _ _ v = typeMismatch "Proxy" v
22491895
22501896instance FromJSON (Proxy a) where
22511897 {-# INLINE parseJSON #-}
2252− parseJSON = fromNull "Proxy" Proxy
1898+ parseJSON Null = pure Proxy
1899+ parseJSON v = typeMismatch "Proxy" v
22531900
2254−fromNull :: String -> a -> Value -> Parser a
2255−fromNull _ a Null = pure a
2256−fromNull c _ v = prependContext c (typeMismatch "Null" v)
22571901
22581902instance FromJSON2 Tagged where
22591903 liftParseJSON2 _ _ p _ = fmap Tagged . p
@@ -2280,7 +1924,10 @@ instance (FromJSON a, FromJSON b, FromJSON c) => FromJSONKey (a,b,c)
22801924instance (FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSONKey (a,b,c,d)
22811925
22821926instance FromJSONKey Char where
2283− fromJSONKey = FromJSONKeyTextParser parseChar
1927+ fromJSONKey = FromJSONKeyTextParser $ \t ->
1928+ if T.length t == 1
1929+ then return (T.index t 0)
1930+ else typeMismatch "Expected Char but String didn't contain exactly one character" (String t)
22841931 fromJSONKeyList = FromJSONKeyText T.unpack
22851932
22861933instance (FromJSONKey a, FromJSON a) => FromJSONKey [a] where