@@ -1,29 +1,28 @@
1−{-# LANGUAGE CPP #-}
1+{-# LANGUAGE CPP #-}
2−{-# LANGUAGE DataKinds #-}
2+{-# LANGUAGE DataKinds #-}
3−{-# LANGUAGE DefaultSignatures #-}
3+{-# LANGUAGE DefaultSignatures #-}
4−{-# LANGUAGE FlexibleContexts #-}
4+{-# LANGUAGE FlexibleContexts #-}
5−{-# LANGUAGE FlexibleInstances #-}
5+{-# LANGUAGE FlexibleInstances #-}
6−{-# LANGUAGE GADTs #-}
6+{-# LANGUAGE GADTs #-}
7{-# LANGUAGE MultiParamTypeClasses #-}
7{-# LANGUAGE MultiParamTypeClasses #-}
8−{-# LANGUAGE NamedFieldPuns #-}
8+{-# LANGUAGE NoImplicitPrelude #-}
9−{-# LANGUAGE OverloadedStrings #-}
9+{-# LANGUAGE OverloadedStrings #-}
10+{-# LANGUAGE PolyKinds #-}
10−{-# LANGUAGE RecordWildCards #-}
11+{-# LANGUAGE RecordWildCards #-}
11−{-# LANGUAGE ScopedTypeVariables #-}
12+{-# LANGUAGE ScopedTypeVariables #-}
12−{-# LANGUAGE TypeOperators #-}
13+{-# LANGUAGE TypeOperators #-}
13−{-# LANGUAGE TypeSynonymInstances #-}
14+{-# LANGUAGE TupleSections #-}
14−{-# LANGUAGE UndecidableInstances #-}
15+{-# LANGUAGE UndecidableInstances #-}
15−{-# LANGUAGE ViewPatterns #-}
16+{-# LANGUAGE ViewPatterns #-}
17−#if __GLASGOW_HASKELL__ >= 706
18+#include "incoherent-compat.h"
18−{-# LANGUAGE PolyKinds #-}
21#include "overlapping-compat.h"
19#include "overlapping-compat.h"
23-- TODO: Drop this when we remove support for Data.Attoparsec.Number
21-- TODO: Drop this when we remove support for Data.Attoparsec.Number
24{-# OPTIONS_GHC -fno-warn-deprecations #-}
22{-# OPTIONS_GHC -fno-warn-deprecations #-}
26−module Data.Aeson.Types.FromJSON (
24+module Data.Aeson.Types.FromJSON
27 -- * Core JSON classes
26 -- * Core JSON classes
28 FromJSON(..)
27 FromJSON(..)
29 -- * Liftings to unary and binary type constructors
28 -- * Liftings to unary and binary type constructors
@@ -33,6 +32,7 @@ module Data.Aeson.Types.FromJSON (
33 , parseJSON2
32 , parseJSON2
34 -- * Generic JSON classes
33 -- * Generic JSON classes
35 , GFromJSON(..)
34 , GFromJSON(..)
36 , genericParseJSON
36 , genericParseJSON
37 , genericLiftParseJSON
37 , genericLiftParseJSON
38 -- * Classes and types for map keys
38 -- * Classes and types for map keys
@@ -42,106 +42,121 @@ module Data.Aeson.Types.FromJSON (
42 , coerceFromJSONKeyFunction
42 , coerceFromJSONKeyFunction
43 , mapFromJSONKeyFunction
43 , mapFromJSONKeyFunction
45 -- * List functions
48 -- * List functions
46 , listParser
49 , listParser
48− -- * Inspecting @'Value's@
51+ -- * Inspecting @'Value's@
49 , withObject
52 , withObject
50 , withText
53 , withText
51 , withArray
54 , withArray
53 , withScientific
55 , withScientific
54 , withBool
56 , withBool
56 -- * Functions
59 -- * Functions
57 , fromJSON
60 , fromJSON
58 , ifromJSON
61 , ifromJSON
68+ , explicitParseFieldMaybe
69+ , explicitParseFieldMaybe'
65 -- * Internal
77 -- * Internal
66 , parseOptionalFieldWith
78 , parseOptionalFieldWith
69−import Prelude ()
81+import Prelude.Compat
70−import Prelude.Compat hiding (foldr)
83+import Control.Applicative ((<|>), Const(..), liftA2)
84+import Control.Monad (zipWithM)
72import Data.Aeson.Internal.Functions (mapKey)
85import Data.Aeson.Internal.Functions (mapKey)
86+import Data.Aeson.Parser.Internal (eitherDecodeWith, jsonEOF)
73import Data.Aeson.Types.Generic
87import Data.Aeson.Types.Generic
74import Data.Aeson.Types.Internal
88import Data.Aeson.Types.Internal
76−import qualified Data.Aeson.Parser.Time as Time
77−import qualified Data.Attoparsec.ByteString.Char8 as A (endOfInput, parseOnly,
80−import Control.Applicative (Const (..), (<|>))
81−import Control.Monad ((<=<))
82−import Data.Attoparsec.Number (Number (..))
83−import Data.Bits (unsafeShiftR)
89+import Data.Bits (unsafeShiftR)
84−import Data.Fixed (Fixed, HasResolution)
90+import Data.Fixed (Fixed, HasResolution (resolution), Nano)
85−import Data.Functor.Compose (Compose (..))
91+import Data.Functor.Compose (Compose(..))
86−import Data.Functor.Identity (Identity (..))
92+import Data.Functor.Identity (Identity(..))
87−import Data.Functor.Product (Product (..))
93+import Data.Functor.Product (Product(..))
88−import Data.Functor.Sum (Sum (..))
94+import Data.Functor.Sum (Sum(..))
89−import Data.Hashable (Hashable (..))
95+import Data.Hashable (Hashable(..))
90−import Data.Int (Int16, Int32, Int64, Int8)
96+import Data.Int (Int16, Int32, Int64, Int8)
91−import Data.List.NonEmpty (NonEmpty (..))
97+import Data.List.NonEmpty (NonEmpty(..))
92−import Data.Maybe (fromMaybe)
98+import Data.Maybe (fromMaybe)
93−import Data.Monoid (Dual (..), First (..), Last (..), (<>))
99+import Data.Semigroup ((<>))
94−import Data.Proxy (Proxy (..))
100+import Data.Proxy (Proxy(..))
95−import Data.Ratio (Ratio, (%))
101+import Data.Ratio ((%), Ratio)
96−import Data.Scientific (Scientific)
102+import Data.Scientific (Scientific, base10Exponent)
97−import Data.Tagged (Tagged (..))
103+import Data.Tagged (Tagged(..))
98−import Data.Text (Text, pack, unpack)
104+import Data.Text (Text, pack, unpack)
99−import Data.Time (Day, LocalTime, NominalDiffTime, TimeOfDay,
105+import Data.Time (Day, DiffTime, LocalTime, NominalDiffTime, TimeOfDay, UTCTime, ZonedTime)
100− UTCTime, ZonedTime)
106+import Data.Time.Calendar.Compat (CalendarDiffDays (..), DayOfWeek (..))
101−import Data.Time.Format (parseTime)
107+import Data.Time.LocalTime.Compat (CalendarDiffTime (..))
108+import Data.Time.Clock.System.Compat (SystemTime (..))
102−import Data.Time.Locale.Compat (defaultTimeLocale)
109+import Data.Time.Format.Compat (parseTimeM, defaultTimeLocale)
103−import Data.Traversable as Tr (sequence)
110+import Data.Traversable as Tr (sequence)
104−import Data.Vector (Vector)
111+import Data.Vector (Vector)
105−import Data.Version (Version, parseVersion)
112+import Data.Version (Version, parseVersion)
113+import Data.Void (Void)
106−import Data.Word (Word16, Word32, Word64, Word8)
114+import Data.Word (Word16, Word32, Word64, Word8)
107−import Foreign.Storable (Storable)
115+import Foreign.Storable (Storable)
116+import Foreign.C.Types (CTime (..))
108import GHC.Generics
117import GHC.Generics
109−import Numeric.Natural (Natural)
118+import Numeric.Natural (Natural)
110import Text.ParserCombinators.ReadP (readP_to_S)
119import Text.ParserCombinators.ReadP (readP_to_S)
111−
120+import Unsafe.Coerce (unsafeCoerce)
112−import qualified Data.DList as DList
121+import qualified Data.Aeson.Parser.Time as Time
122+import qualified Data.Attoparsec.ByteString.Char8 as A (endOfInput, parseOnly, scientific)
123+import qualified Data.ByteString.Lazy as L
124+import qualified Data.DList as DList
113−import qualified Data.HashMap.Strict as H
125+import qualified Data.HashMap.Strict as H
114−import qualified Data.HashSet as HashSet
126+import qualified Data.HashSet as HashSet
115−import qualified Data.IntMap as IntMap
127+import qualified Data.IntMap as IntMap
116−import qualified Data.IntSet as IntSet
128+import qualified Data.IntSet as IntSet
117−import qualified Data.Map as M
129+import qualified Data.Map as M
130+import qualified Data.Monoid as Monoid
118−import qualified Data.Scientific as Scientific
131+import qualified Data.Scientific as Scientific
119−import qualified Data.Sequence as Seq
132+import qualified Data.Semigroup as Semigroup
133+import qualified Data.Sequence as Seq
120−import qualified Data.Set as Set
134+import qualified Data.Set as Set
121−import qualified Data.Text as T
135+import qualified Data.Text as T
122−import qualified Data.Text.Encoding as T
136+import qualified Data.Text.Encoding as T
123−import qualified Data.Text.Lazy as LT
137+import qualified Data.Text.Lazy as LT
124−import qualified Data.Tree as Tree
138+import qualified Data.Tree as Tree
125−import qualified Data.Vector as V
139+import qualified Data.UUID.Types as UUID
140+import qualified Data.Vector as V
126−import qualified Data.Vector.Generic as VG
141+import qualified Data.Vector.Generic as VG
127import qualified Data.Vector.Primitive as VP
142import qualified Data.Vector.Primitive as VP
128−import qualified Data.Vector.Storable as VS
143+import qualified Data.Vector.Storable as VS
129−import qualified Data.Vector.Unboxed as VU
144+import qualified Data.Vector.Unboxed as VU
131−import Unsafe.Coerce (unsafeCoerce)
146+import qualified GHC.Exts as Exts
147+import qualified Data.Primitive.Array as PM
148+import qualified Data.Primitive.SmallArray as PM
149+import qualified Data.Primitive.Types as PM
133−#ifndef HAS_COERCIBLE
151+#if MIN_VERSION_primitive(0,6,4)
134−#define HAS_COERCIBLE (__GLASGOW_HASKELL__ >= 707)
152+#if !MIN_VERSION_primitive(0,7,0)
153+import qualified Data.Primitive.UnliftedArray as PM
155+import qualified Data.Primitive.PrimArray as PM
138import Data.Coerce (Coercible, coerce)
159import Data.Coerce (Coercible, coerce)
139−coerce' :: Coercible a b => a -> b
143−coerce' = unsafeCoerce
146parseIndexedJSON :: (Value -> Parser a) -> Int -> Value -> Parser a
161parseIndexedJSON :: (Value -> Parser a) -> Int -> Value -> Parser a
147parseIndexedJSON p idx value = p value <?> Index idx
162parseIndexedJSON p idx value = p value <?> Index idx
@@ -150,7 +165,7 @@ parseIndexedJSON p idx value = p value <?> Index idx
150parseIndexedJSONPair :: (Value -> Parser a) -> (Value -> Parser b) -> Int -> Value -> Parser (a, b)
165parseIndexedJSONPair :: (Value -> Parser a) -> (Value -> Parser b) -> Int -> Value -> Parser (a, b)
151parseIndexedJSONPair keyParser valParser idx value = p value <?> Index idx
166parseIndexedJSONPair keyParser valParser idx value = p value <?> Index idx
153− p = withArray "(k,v)" $ \ab ->
168+ p = withArray "(k, v)" $ \ab ->
154 let n = V.length ab
169 let n = V.length ab
155 in if n == 2
170 in if n == 2
156 then (,) <$> parseJSONElemAtIndex keyParser 0 ab
171 then (,) <$> parseJSONElemAtIndex keyParser 0 ab
@@ -162,33 +177,57 @@ parseIndexedJSONPair keyParser valParser idx value = p value <?> Index idx
162parseJSONElemAtIndex :: (Value -> Parser a) -> Int -> V.Vector Value -> Parser a
177parseJSONElemAtIndex :: (Value -> Parser a) -> Int -> V.Vector Value -> Parser a
163parseJSONElemAtIndex p idx ary = p (V.unsafeIndex ary idx) <?> Index idx
178parseJSONElemAtIndex p idx ary = p (V.unsafeIndex ary idx) <?> Index idx
165−scientificToNumber :: Scientific -> Number
167− | e < 0 = D $ Scientific.toRealFloat s
168− | otherwise = I $ c * 10 ^ e
170− e = Scientific.base10Exponent s
171− c = Scientific.coefficient s
172−{-# INLINE scientificToNumber #-}
174parseRealFloat :: RealFloat a => String -> Value -> Parser a
180parseRealFloat :: RealFloat a => String -> Value -> Parser a
175−parseRealFloat _ (Number s) = pure $ Scientific.toRealFloat s
181+parseRealFloat _ (Number s) = pure $ Scientific.toRealFloat s
176−parseRealFloat _ Null = pure (0/0)
182+parseRealFloat _ Null = pure (0/0)
177−parseRealFloat expected v = typeMismatch expected v
183+parseRealFloat name v = prependContext name (unexpected v)
178{-# INLINE parseRealFloat #-}
184{-# INLINE parseRealFloat #-}
186+parseIntegralFromScientific :: forall a. Integral a => Scientific -> Parser a
187+parseIntegralFromScientific s =
188+ case Scientific.floatingOrInteger s :: Either Double a of
190+ Left _ -> fail $ "unexpected floating number " ++ show s
191+{-# INLINE parseIntegralFromScientific #-}
180parseIntegral :: Integral a => String -> Value -> Parser a
193parseIntegral :: Integral a => String -> Value -> Parser a
181−parseIntegral expected = withScientific expected $ pure . truncate
194+parseIntegral name =
195+ prependContext name . withBoundedScientific' parseIntegralFromScientific
182{-# INLINE parseIntegral #-}
196{-# INLINE parseIntegral #-}
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+ (Scientific.toBoundedInteger s)
203+{-# INLINE parseBoundedIntegralFromScientific #-}
205+parseBoundedIntegral :: (Bounded a, Integral a) => String -> Value -> Parser a
206+parseBoundedIntegral name =
207+ prependContext name . withScientific' parseBoundedIntegralFromScientific
208+{-# INLINE parseBoundedIntegral #-}
184parseScientificText :: Text -> Parser Scientific
210parseScientificText :: Text -> Parser Scientific
185parseScientificText
211parseScientificText
186 = either fail pure
212 = either fail pure
187 . A.parseOnly (A.scientific <* A.endOfInput)
213 . A.parseOnly (A.scientific <* A.endOfInput)
188 . T.encodeUtf8
214 . T.encodeUtf8
190−parseIntegralText :: Integral a => Text -> Parser a
216+parseIntegralText :: Integral a => String -> Text -> Parser a
191−parseIntegralText t = truncate <$> parseScientificText t
217+parseIntegralText name t =
218+ prependContext name $
219+ parseScientificText t
220+ >>= rejectLargeExponent
221+ >>= parseIntegralFromScientific
223+ rejectLargeExponent :: Scientific -> Parser Scientific
224+ rejectLargeExponent s = withBoundedScientific' pure (Number s)
225+{-# INLINE parseIntegralText #-}
227+parseBoundedIntegralText :: (Bounded a, Integral a) => String -> Text -> Parser a
228+parseBoundedIntegralText name t =
229+ prependContext name $
230+ parseScientificText t >>= parseBoundedIntegralFromScientific
193parseOptionalFieldWith :: (Value -> Parser (Maybe a))
232parseOptionalFieldWith :: (Value -> Parser (Maybe a))
194 -> Object -> Text -> Parser (Maybe a)
233 -> Object -> Text -> Parser (Maybe a)
@@ -207,16 +246,21 @@ class GFromJSON arity f where
207 -- | This method (applied to 'defaultOptions') is used as the
246 -- | This method (applied to 'defaultOptions') is used as the
208 -- default generic implementation of 'parseJSON' (if the @arity@ is 'Zero')
247 -- default generic implementation of 'parseJSON' (if the @arity@ is 'Zero')
209 -- or 'liftParseJSON' (if the @arity@ is 'One').
248 -- or 'liftParseJSON' (if the @arity@ is 'One').
210− gParseJSON :: Options -> Proxy arity
249+ gParseJSON :: Options -> FromArgs arity a -> Value -> Parser (f a)
251+-- | A 'FromArgs' value either stores nothing (for 'FromJSON') or it stores the
252+-- two function arguments that decode occurrences of the type parameter (for
254+data FromArgs arity a where
255+ NoFromArgs :: FromArgs Zero a
211− -> (Value -> Parser a) -> (Value -> Parser [a])
256+ From1Args :: (Value -> Parser a) -> (Value -> Parser [a]) -> FromArgs One a
212− -> Value -> Parser (f a)
214-- | A configurable generic JSON decoder. This function applied to
258-- | A configurable generic JSON decoder. This function applied to
215-- 'defaultOptions' is used as the default for 'parseJSON' when the
259-- 'defaultOptions' is used as the default for 'parseJSON' when the
216-- type is an instance of 'Generic'.
260-- type is an instance of 'Generic'.
217genericParseJSON :: (Generic a, GFromJSON Zero (Rep a))
261genericParseJSON :: (Generic a, GFromJSON Zero (Rep a))
218 => Options -> Value -> Parser a
262 => Options -> Value -> Parser a
219−genericParseJSON opts = fmap to . gParseJSON opts proxyZero undefined undefined
263+genericParseJSON opts = fmap to . gParseJSON opts NoFromArgs
221-- | A configurable generic JSON decoder. This function applied to
265-- | A configurable generic JSON decoder. This function applied to
222-- 'defaultOptions' is used as the default for 'liftParseJSON' when the
266-- 'defaultOptions' is used as the default for 'liftParseJSON' when the
@@ -224,7 +268,7 @@ genericParseJSON opts = fmap to . gParseJSON opts proxyZero undefined undefined
224genericLiftParseJSON :: (Generic1 f, GFromJSON One (Rep1 f))
268genericLiftParseJSON :: (Generic1 f, GFromJSON One (Rep1 f))
225 => Options -> (Value -> Parser a) -> (Value -> Parser [a])
269 => Options -> (Value -> Parser a) -> (Value -> Parser [a])
226 -> Value -> Parser (f a)
270 -> Value -> Parser (f a)
227−genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts proxyOne pj pjl
271+genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
229-------------------------------------------------------------------------------
273-------------------------------------------------------------------------------
@@ -243,14 +287,21 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts proxyOne pj pjl
244-- The basic ways to signal a failed conversion are as follows:
288-- The basic ways to signal a failed conversion are as follows:
246−-- * '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;
248−-- * '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 @('<|>')@;
250−-- * 'typeMismatch' produces an informative message for cases when the
296+-- * 'typeMismatch' can be used to report a failure when the encountered value
251−-- value encountered is not of the expected type
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
301+-- 'prependFailure' (or 'modifyFailure') add more information to a parser's
253−-- An example type and instance:
304+-- An example type and instance using 'typeMismatch' and 'prependFailure':
256-- \-- Allow ourselves to write 'Text' literals.
307-- \-- Allow ourselves to write 'Text' literals.
@@ -258,15 +309,30 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts proxyOne pj pjl
259-- data Coord = Coord { x :: Double, y :: Double }
310-- data Coord = Coord { x :: Double, y :: Double }
261−-- instance FromJSON Coord where
312+-- instance 'FromJSON' Coord where
262−-- parseJSON ('Object' v) = Coord '<$>'
313+-- 'parseJSON' ('Object' v) = Coord
263−-- v '.:' \"x\" '<*>'
314+-- '<$>' v '.:' \"x\"
264−-- v '.:' \"y\"
315+-- '<*>' v '.:' \"y\"
266−-- \-- We do not expect a non-'Object' value here.
317+-- \-- We do not expect a non-'Object' value here.
267−-- \-- We could use 'mzero' to fail, but 'typeMismatch'
318+-- \-- We could use 'Control.Applicative.empty' to fail, but 'typeMismatch'
268−-- \-- gives a much more informative error message.
319+-- \-- gives a much more informative error message.
320+-- 'parseJSON' invalid =
321+-- 'prependFailure' "parsing Coord failed, "
269−-- parseJSON invalid = 'typeMismatch' \"Coord\" invalid
322+-- ('typeMismatch' \"Object\" invalid)
325+-- For this common case of only being concerned with a single
326+-- type of JSON value, the functions 'withObject', 'withScientific', etc.
327+-- are provided. Their use is to be preferred when possible, since
328+-- they are more terse. Using 'withObject', we can rewrite the above instance
329+-- (assuming the same language extension and data type) as:
332+-- instance 'FromJSON' Coord where
333+-- 'parseJSON' = 'withObject' \"Coord\" $ \\v -> Coord
334+-- '<$>' v '.:' \"x\"
335+-- '<*>' v '.:' \"y\"
272-- Instead of manually writing your 'FromJSON' instance, there are two options
338-- Instead of manually writing your 'FromJSON' instance, there are two options
@@ -274,7 +340,7 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts proxyOne pj pjl
275-- * "Data.Aeson.TH" provides Template Haskell functions which will derive an
341-- * "Data.Aeson.TH" provides Template Haskell functions which will derive an
276-- instance at compile time. The generated instance is optimized for your type
342-- instance at compile time. The generated instance is optimized for your type
277−-- so will probably be more efficient than the following two options:
343+-- so it will probably be more efficient than the following option.
279-- * The compiler can provide a default generic implementation for
345-- * The compiler can provide a default generic implementation for
280-- 'parseJSON'.
346-- 'parseJSON'.
@@ -292,18 +358,21 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts proxyOne pj pjl
293-- data Coord = Coord { x :: Double, y :: Double } deriving 'Generic'
359-- data Coord = Coord { x :: Double, y :: Double } deriving 'Generic'
295−-- instance FromJSON Coord
361+-- instance 'FromJSON' Coord
298−-- If @DefaultSignatures@ doesn't give exactly the results you want,
364+-- The default implementation will be equivalent to
365+-- @parseJSON = 'genericParseJSON' 'defaultOptions'@; if you need different
299−-- you can customize the generic decoding with only a tiny amount of
366+-- options, you can customize the generic decoding by defining:
300−-- effort, using 'genericParseJSON' with your preferred 'Options':
369+-- customOptions = 'defaultOptions'
370+-- { 'fieldLabelModifier' = 'map' 'Data.Char.toUpper'
303−-- instance FromJSON Coord where
373+-- instance 'FromJSON' Coord where
304−-- parseJSON = 'genericParseJSON' 'defaultOptions'
374+-- 'parseJSON' = 'genericParseJSON' customOptions
307class FromJSON a where
376class FromJSON a where
308 parseJSON :: Value -> Parser a
377 parseJSON :: Value -> Parser a
@@ -311,25 +380,32 @@ class FromJSON a where
311 parseJSON = genericParseJSON defaultOptions
380 parseJSON = genericParseJSON defaultOptions
313 parseJSONList :: Value -> Parser [a]
382 parseJSONList :: Value -> Parser [a]
314− parseJSONList (Array a)
383+ parseJSONList = withArray "[]" $ \a ->
316− . zipWith (parseIndexedJSON parseJSON) [0..]
384+ zipWithM (parseIndexedJSON parseJSON) [0..]
317 . V.toList
385 . V.toList
320− parseJSONList v = typeMismatch "[a]" v
322-------------------------------------------------------------------------------
388-------------------------------------------------------------------------------
323-- Classes and types for map keys
389-- Classes and types for map keys
324-------------------------------------------------------------------------------
390-------------------------------------------------------------------------------
326−-- | Read the docs for 'ToJSONKey' first. This class is a conversion
392+-- | Read the docs for 'ToJSONKey' first. This class is a conversion
327-- in the opposite direction. If you have a newtype wrapper around 'Text',
393-- in the opposite direction. If you have a newtype wrapper around 'Text',
328-- the recommended way to define instances is with generalized newtype deriving:
394-- the recommended way to define instances is with generalized newtype deriving:
330-- > newtype SomeId = SomeId { getSomeId :: Text }
396-- > newtype SomeId = SomeId { getSomeId :: Text }
331-- > deriving (Eq,Ord,Hashable,FromJSONKey)
397-- > deriving (Eq,Ord,Hashable,FromJSONKey)
399+-- If you have a sum of nullary constructors, you may use the generic
403+-- data Color = Red | Green | Blue
406+-- instance 'FromJSONKey' Color where
407+-- 'fromJSONKey' = 'genericFromJSONKey' 'defaultJSONKeyOptions'
333class FromJSONKey a where
409class FromJSONKey a where
334 -- | Strategy for parsing the key of a map-like container.
410 -- | Strategy for parsing the key of a map-like container.
335 fromJSONKey :: FromJSONKeyFunction a
411 fromJSONKey :: FromJSONKeyFunction a
@@ -346,17 +422,13 @@ class FromJSONKey a where
347-- | With GHC 7.8+ we carry around @'Coercible' 'Text' a@ dictionary,
423-- | With GHC 7.8+ we carry around @'Coercible' 'Text' a@ dictionary,
348-- to give us an assurance that the program will not segfault.
424-- to give us an assurance that the program will not segfault.
349−-- Unfortunately we cannot enforce that the 'Eq' instances or the
425+-- Unfortunately we cannot enforce that the 'Eq' instances or the
350-- 'Hashable' instances for 'Text' and @a@ agree.
426-- 'Hashable' instances for 'Text' and @a@ agree.
352−-- At the moment this type is intentionally not exported. 'FromJSONKeyFunction'
428+-- At the moment this type is intentionally not exported. 'FromJSONKeyFunction'
353-- can be inspected, but cannot be constructed.
429-- can be inspected, but cannot be constructed.
354data CoerceText a where
430data CoerceText a where
356 CoerceText :: Coercible Text a => CoerceText a
431 CoerceText :: Coercible Text a => CoerceText a
358− CoerceText :: CoerceText a
361-- | This type is related to 'ToJSONKeyFunction'. If 'FromJSONKeyValue' is used in the
433-- | This type is related to 'ToJSONKeyFunction'. If 'FromJSONKeyValue' is used in the
362-- 'FromJSONKey' instance, then 'ToJSONKeyValue' should be used in the 'ToJSONKey'
434-- 'FromJSONKey' instance, then 'ToJSONKeyValue' should be used in the 'ToJSONKey'
@@ -376,7 +448,7 @@ data FromJSONKeyFunction a
377-- | Only law abiding up to interpretation
449-- | Only law abiding up to interpretation
378instance Functor FromJSONKeyFunction where
450instance Functor FromJSONKeyFunction where
379− fmap h (FromJSONKeyCoerce CoerceText) = FromJSONKeyText (h . coerce')
451+ fmap h (FromJSONKeyCoerce CoerceText) = FromJSONKeyText (h . coerce)
380 fmap h (FromJSONKeyText f) = FromJSONKeyText (h . f)
452 fmap h (FromJSONKeyText f) = FromJSONKeyText (h . f)
381 fmap h (FromJSONKeyTextParser f) = FromJSONKeyTextParser (fmap h . f)
453 fmap h (FromJSONKeyTextParser f) = FromJSONKeyTextParser (fmap h . f)
382 fmap h (FromJSONKeyValue f) = FromJSONKeyValue (fmap h . f)
454 fmap h (FromJSONKeyValue f) = FromJSONKeyValue (fmap h . f)
@@ -390,9 +462,7 @@ instance Functor FromJSONKeyFunction where
391-- On pre GHC 7.8 this is unconstrainted function.
463-- On pre GHC 7.8 this is unconstrainted function.
392fromJSONKeyCoerce ::
464fromJSONKeyCoerce ::
394 Coercible Text a =>
465 Coercible Text a =>
396 FromJSONKeyFunction a
466 FromJSONKeyFunction a
397fromJSONKeyCoerce = FromJSONKeyCoerce CoerceText
467fromJSONKeyCoerce = FromJSONKeyCoerce CoerceText
@@ -400,60 +470,91 @@ fromJSONKeyCoerce = FromJSONKeyCoerce CoerceText
401-- See note on 'fromJSONKeyCoerce'.
471-- See note on 'fromJSONKeyCoerce'.
402coerceFromJSONKeyFunction ::
472coerceFromJSONKeyFunction ::
404 Coercible a b =>
473 Coercible a b =>
406 FromJSONKeyFunction a -> FromJSONKeyFunction b
474 FromJSONKeyFunction a -> FromJSONKeyFunction b
408coerceFromJSONKeyFunction = coerce
475coerceFromJSONKeyFunction = coerce
410−coerceFromJSONKeyFunction (FromJSONKeyCoerce CoerceText) = FromJSONKeyCoerce CoerceText
411−coerceFromJSONKeyFunction (FromJSONKeyText f) = FromJSONKeyText (coerce' . f)
412−coerceFromJSONKeyFunction (FromJSONKeyTextParser f) = FromJSONKeyTextParser (fmap coerce' . f)
413−coerceFromJSONKeyFunction (FromJSONKeyValue f) = FromJSONKeyValue (fmap coerce' . f)
417 "FromJSONKeyCoerce: fmap id" forall (x :: FromJSONKeyFunction a).
478 "FromJSONKeyCoerce: fmap id" forall (x :: FromJSONKeyFunction a).
418 fmap id x = x
479 fmap id x = x
422 "FromJSONKeyCoerce: fmap coerce" forall x .
482 "FromJSONKeyCoerce: fmap coerce" forall x .
423 fmap coerce x = coerceFromJSONKeyFunction x
483 fmap coerce x = coerceFromJSONKeyFunction x
427-- | Same as 'fmap'. Provided for the consistency with 'ToJSONKeyFunction'.
486-- | Same as 'fmap'. Provided for the consistency with 'ToJSONKeyFunction'.
428mapFromJSONKeyFunction :: (a -> b) -> FromJSONKeyFunction a -> FromJSONKeyFunction b
487mapFromJSONKeyFunction :: (a -> b) -> FromJSONKeyFunction a -> FromJSONKeyFunction b
429mapFromJSONKeyFunction = fmap
488mapFromJSONKeyFunction = fmap
490+-- | 'fromJSONKey' for 'Generic' types.
491+-- These types must be sums of nullary constructors, whose names will be used
492+-- as keys for JSON objects.
494+-- See also 'genericToJSONKey'.
499+-- data Color = Red | Green | Blue
500+-- deriving 'Generic'
502+-- instance 'FromJSONKey' Color where
503+-- 'fromJSONKey' = 'genericFromJSONKey' 'defaultJSONKeyOptions'
505+genericFromJSONKey :: forall a. (Generic a, GFromJSONKey (Rep a))
507+ -> FromJSONKeyFunction a
508+genericFromJSONKey opts = FromJSONKeyTextParser $ \t ->
509+ case parseSumFromString (keyModifier opts) t of
511+ "invalid key " ++ show t ++ ", expected one of " ++ show cnames
512+ Just k -> pure (to k)
514+ cnames = unTagged2 (constructorTags (keyModifier opts) :: Tagged2 (Rep a) [String])
516+class (ConstructorNames f, SumFromString f) => GFromJSONKey f where
517+instance (ConstructorNames f, SumFromString f) => GFromJSONKey f where
431-------------------------------------------------------------------------------
519-------------------------------------------------------------------------------
432-- Functions needed for documentation
520-- Functions needed for documentation
433-------------------------------------------------------------------------------
521-------------------------------------------------------------------------------
435-- | Fail parsing due to a type mismatch, with a descriptive message.
523-- | Fail parsing due to a type mismatch, with a descriptive message.
437−-- Example usage:
525+-- The following wrappers should generally be prefered:
526+-- 'withObject', 'withArray', 'withText', 'withBool'.
439−-- @
528+-- ==== Error message example
440−-- instance FromJSON Coord where
529+--
441−-- parseJSON ('Object' v) = {- type matches, life is good -}
530+-- > typeMismatch "Object" (String "oops")
442−-- parseJSON wat = 'typeMismatch' \"Coord\" wat
531+-- > -- Error: "expected Object, but encountered String"
444−typeMismatch :: String -- ^ The name of the type you are trying to parse.
532+typeMismatch :: String -- ^ The name of the JSON type being parsed
533+ -- (@\"Object\"@, @\"Array\"@, @\"String\"@, @\"Number\"@,
534+ -- @\"Boolean\"@, or @\"Null\"@).
445 -> Value -- ^ The actual value encountered.
535 -> Value -- ^ The actual value encountered.
446 -> Parser a
536 -> Parser a
447typeMismatch expected actual =
537typeMismatch expected actual =
448− fail $ "expected " ++ expected ++ ", encountered " ++ name
538+ fail $ "expected " ++ expected ++ ", but encountered " ++ typeOf actual
540+-- | Fail parsing due to a type mismatch, when the expected types are implicit.
542+-- ==== Error message example
544+-- > unexpected (String "oops")
545+-- > -- Error: "unexpected String"
546+unexpected :: Value -> Parser a
547+unexpected actual = fail $ "unexpected " ++ typeOf actual
549+-- | JSON type of a value, name of the head constructor.
550+typeOf :: Value -> String
450− name = case actual of
551+typeOf v = case v of
451− Object _ -> "Object"
552+ Object _ -> "Object"
452− Array _ -> "Array"
553+ Array _ -> "Array"
453− String _ -> "String"
554+ String _ -> "String"
454− Number _ -> "Number"
555+ Number _ -> "Number"
455− Bool _ -> "Boolean"
556+ Bool _ -> "Boolean"
456− Null -> "Null"
557+ Null -> "Null"
458-------------------------------------------------------------------------------
559-------------------------------------------------------------------------------
459-- Lifings of FromJSON and ToJSON to unary and binary type constructors
560-- Lifings of FromJSON and ToJSON to unary and binary type constructors
@@ -466,7 +567,7 @@ typeMismatch expected actual =
467-- * "Data.Aeson.TH" provides Template Haskell functions which will derive an
568-- * "Data.Aeson.TH" provides Template Haskell functions which will derive an
468-- instance at compile time. The generated instance is optimized for your type
569-- instance at compile time. The generated instance is optimized for your type
469−-- so will probably be more efficient than the following two options:
570+-- so it will probably be more efficient than the following option.
471-- * The compiler can provide a default generic implementation for
572-- * The compiler can provide a default generic implementation for
472-- 'liftParseJSON'.
573-- 'liftParseJSON'.
@@ -484,16 +585,20 @@ typeMismatch expected actual =
485-- data Pair a b = Pair { pairFst :: a, pairSnd :: b } deriving 'Generic1'
586-- data Pair a b = Pair { pairFst :: a, pairSnd :: b } deriving 'Generic1'
487−-- instance FromJSON a => FromJSON1 (Pair a)
588+-- instance 'FromJSON' a => 'FromJSON1' (Pair a)
490−-- If @DefaultSignatures@ doesn't give exactly the results you want,
591+-- If the default implementation doesn't give exactly the results you want,
491-- you can customize the generic decoding with only a tiny amount of
592-- you can customize the generic decoding with only a tiny amount of
492-- effort, using 'genericLiftParseJSON' with your preferred 'Options':
593-- effort, using 'genericLiftParseJSON' with your preferred 'Options':
596+-- customOptions = 'defaultOptions'
597+-- { 'fieldLabelModifier' = 'map' 'Data.Char.toUpper'
495−-- instance FromJSON a => FromJSON1 (Pair a) where
600+-- instance 'FromJSON' a => 'FromJSON1' (Pair a) where
496−-- liftParseJSON = 'genericLiftParseJSON' 'defaultOptions'
601+-- 'liftParseJSON' = 'genericLiftParseJSON' customOptions
498class FromJSON1 f where
603class FromJSON1 f where
499 liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a)
604 liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a)
@@ -530,9 +635,8 @@ class FromJSON2 f where
530 -> (Value -> Parser b)
635 -> (Value -> Parser b)
531 -> (Value -> Parser [b])
636 -> (Value -> Parser [b])
532 -> Value -> Parser [f a b]
637 -> Value -> Parser [f a b]
533− liftParseJSONList2 fa ga fb gb v = case v of
638+ liftParseJSONList2 fa ga fb gb = withArray "[]" $ \vals ->
534− Array vals -> fmap V.toList (V.mapM (liftParseJSON2 fa ga fb gb) vals)
639+ fmap V.toList (V.mapM (liftParseJSON2 fa ga fb gb) vals)
535− _ -> typeMismatch "[a]" v
537-- | Lift the standard 'parseJSON' function through the type constructor.
641-- | Lift the standard 'parseJSON' function through the type constructor.
538parseJSON2 :: (FromJSON2 f, FromJSON a, FromJSON b) => Value -> Parser (f a b)
642parseJSON2 :: (FromJSON2 f, FromJSON a, FromJSON b) => Value -> Parser (f a b)
@@ -543,9 +647,10 @@ parseJSON2 = liftParseJSON2 parseJSON parseJSONList parseJSON parseJSONList
543-- List functions
647-- List functions
544-------------------------------------------------------------------------------
648-------------------------------------------------------------------------------
650+-- | Helper function to use with 'liftParseJSON'. See 'Data.Aeson.ToJSON.listEncoding'.
546listParser :: (Value -> Parser a) -> Value -> Parser [a]
651listParser :: (Value -> Parser a) -> Value -> Parser [a]
547listParser f (Array xs) = fmap V.toList (V.mapM f xs)
652listParser f (Array xs) = fmap V.toList (V.mapM f xs)
548−listParser _ v = typeMismatch "[a]" v
653+listParser _ v = typeMismatch "Array" v
549{-# INLINE listParser #-}
654{-# INLINE listParser #-}
551-------------------------------------------------------------------------------
656-------------------------------------------------------------------------------
@@ -563,48 +668,139 @@ instance (FromJSON a) => FromJSON [a] where
563-- Functions
668-- Functions
564-------------------------------------------------------------------------------
669-------------------------------------------------------------------------------
671+-- | Add context to a failure message, indicating the name of the structure
674+-- > prependContext "MyType" (fail "[error message]")
675+-- > -- Error: "parsing MyType failed, [error message]"
676+prependContext :: String -> Parser a -> Parser a
677+prependContext name = prependFailure ("parsing " ++ name ++ " failed, ")
566−-- | @withObject expected f value@ applies @f@ to the 'Object' when @value@ is an @Object@
679+-- | @'withObject' name f value@ applies @f@ to the 'Object' when @value@
567−-- and fails using @'typeMismatch' expected@ otherwise.
680+-- is an 'Data.Aeson.Object' and fails otherwise.
682+-- ==== Error message example
684+-- > withObject "MyType" f (String "oops")
685+-- > -- Error: "parsing MyType failed, expected Object, but encountered String"
568withObject :: String -> (Object -> Parser a) -> Value -> Parser a
686withObject :: String -> (Object -> Parser a) -> Value -> Parser a
569−withObject _ f (Object obj) = f obj
687+withObject _ f (Object obj) = f obj
570−withObject expected _ v = typeMismatch expected v
688+withObject name _ v = prependContext name (typeMismatch "Object" v)
571{-# INLINE withObject #-}
689{-# INLINE withObject #-}
573−-- | @withText expected f value@ applies @f@ to the 'Text' when @value@ is a @String@
691+-- | @'withText' name f value@ applies @f@ to the 'Text' when @value@ is a
574−-- and fails using @'typeMismatch' expected@ otherwise.
692+-- 'Data.Aeson.String' and fails otherwise.
694+-- ==== Error message example
696+-- > withText "MyType" f Null
697+-- > -- Error: "parsing MyType failed, expected String, but encountered Null"
575withText :: String -> (Text -> Parser a) -> Value -> Parser a
698withText :: String -> (Text -> Parser a) -> Value -> Parser a
576−withText _ f (String txt) = f txt
699+withText _ f (String txt) = f txt
577−withText expected _ v = typeMismatch expected v
700+withText name _ v = prependContext name (typeMismatch "String" v)
578{-# INLINE withText #-}
701{-# INLINE withText #-}
580−-- | @withArray expected f value@ applies @f@ to the 'Array' when @value@ is an @Array@
703+-- | @'withArray' expected f value@ applies @f@ to the 'Array' when @value@ is
581−-- and fails using @'typeMismatch' expected@ otherwise.
704+-- an 'Data.Aeson.Array' and fails otherwise.
706+-- ==== Error message example
708+-- > withArray "MyType" f (String "oops")
709+-- > -- Error: "parsing MyType failed, expected Array, but encountered String"
582withArray :: String -> (Array -> Parser a) -> Value -> Parser a
710withArray :: String -> (Array -> Parser a) -> Value -> Parser a
583−withArray _ f (Array arr) = f arr
711+withArray _ f (Array arr) = f arr
584−withArray expected _ v = typeMismatch expected v
712+withArray name _ v = prependContext name (typeMismatch "Array" v)
585{-# INLINE withArray #-}
713{-# INLINE withArray #-}
587−-- | @withNumber expected f value@ applies @f@ to the 'Number' when @value@ is a 'Number'.
588−-- and fails using @'typeMismatch' expected@ otherwise.
589−withNumber :: String -> (Number -> Parser a) -> Value -> Parser a
590−withNumber expected f = withScientific expected (f . scientificToNumber)
591−{-# INLINE withNumber #-}
592−{-# DEPRECATED withNumber "Use withScientific instead" #-}
594−-- | @withScientific expected f value@ applies @f@ to the 'Scientific' number when @value@ is a 'Number'.
715+-- | @'withScientific' name f value@ applies @f@ to the 'Scientific' number
595−-- and fails using @'typeMismatch' expected@ otherwise.
716+-- when @value@ is a 'Data.Aeson.Number' and fails using 'typeMismatch'
719+-- /Warning/: If you are converting from a scientific to an unbounded
720+-- type such as 'Integer' you may want to add a restriction on the
721+-- size of the exponent (see 'withBoundedScientific') to prevent
722+-- malicious input from filling up the memory of the target system.
724+-- ==== Error message example
726+-- > withScientific "MyType" f (String "oops")
727+-- > -- Error: "parsing MyType failed, expected Number, but encountered String"
596withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
728withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
597−withScientific _ f (Number scientific) = f scientific
729+withScientific _ f (Number scientific) = f scientific
598−withScientific expected _ v = typeMismatch expected v
730+withScientific name _ v = prependContext name (typeMismatch "Number" v)
599{-# INLINE withScientific #-}
731{-# INLINE withScientific #-}
601−-- | @withBool expected f value@ applies @f@ to the 'Bool' when @value@ is a @Bool@
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.
737+-- /Warning/: If you are converting from a scientific to an unbounded
738+-- type such as 'Integer' you may want to add a restriction on the
739+-- size of the exponent (see 'withBoundedScientific') to prevent
740+-- malicious input from filling up the memory of the target system.
742+-- ==== Error message examples
744+-- > withScientific' f (String "oops")
745+-- > -- Error: "unexpected String"
747+-- > prependContext "MyType" (withScientific' f (String "oops"))
748+-- > -- Error: "parsing MyType failed, unexpected String"
749+withScientific' :: (Scientific -> Parser a) -> Value -> Parser a
750+withScientific' f v = case v of
752+ _ -> typeMismatch "Number" v
753+{-# INLINE withScientific' #-}
755+-- | @'withBoundedScientific' name f value@ applies @f@ to the 'Scientific' number
756+-- when @value@ is a 'Number' with exponent less than or equal to 1024.
757+withBoundedScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
758+withBoundedScientific name f v = withBoundedScientific_ (prependContext name) f v
759+{-# INLINE withBoundedScientific #-}
761+-- | A variant of 'withBoundedScientific' which doesn't use 'prependContext',
762+-- so that such context can be added separately in a way that also applies
763+-- when the continuation @f :: Scientific -> Parser a@ fails.
764+withBoundedScientific' :: (Scientific -> Parser a) -> Value -> Parser a
765+withBoundedScientific' f v = withBoundedScientific_ id f v
766+{-# INLINE withBoundedScientific' #-}
768+-- | A variant of 'withBoundedScientific_' parameterized by a function to apply
769+-- to the 'Parser' in case of failure.
770+withBoundedScientific_ :: (Parser a -> Parser a) -> (Scientific -> Parser a) -> Value -> Parser a
771+withBoundedScientific_ whenFail f (Number scientific) =
773+ then whenFail (fail msg)
776+ exp10 = base10Exponent scientific
777+ msg = "found a number with exponent " ++ show exp10 ++ ", but it must not be greater than 1024"
778+withBoundedScientific_ whenFail _ v =
779+ whenFail (typeMismatch "Number" v)
780+{-# INLINE withBoundedScientific_ #-}
782+-- | @'withBool' expected f value@ applies @f@ to the 'Bool' when @value@ is a
602−-- and fails using @'typeMismatch' expected@ otherwise.
783+-- 'Boolean' and fails otherwise.
785+-- ==== Error message example
787+-- > withBool "MyType" f (String "oops")
788+-- > -- Error: "parsing MyType failed, expected Boolean, but encountered String"
603withBool :: String -> (Bool -> Parser a) -> Value -> Parser a
789withBool :: String -> (Bool -> Parser a) -> Value -> Parser a
604−withBool _ f (Bool arr) = f arr
790+withBool _ f (Bool arr) = f arr
605−withBool expected _ v = typeMismatch expected v
791+withBool name _ v = prependContext name (typeMismatch "Boolean" v)
606{-# INLINE withBool #-}
792{-# INLINE withBool #-}
794+-- | Decode a nested JSON-encoded string.
795+withEmbeddedJSON :: String -> (Value -> Parser a) -> Value -> Parser a
796+withEmbeddedJSON _ innerParser (String txt) =
797+ either fail innerParser $ eitherDecode (L.fromStrict $ T.encodeUtf8 txt)
799+ eitherDecode = eitherFormatError . eitherDecodeWith jsonEOF ifromJSON
800+ eitherFormatError = either (Left . uncurry formatError) Right
801+withEmbeddedJSON name _ v = prependContext name (typeMismatch "String" v)
802+{-# INLINE withEmbeddedJSON #-}
608-- | Convert a value from JSON, failing if the types do not match.
804-- | Convert a value from JSON, failing if the types do not match.
609fromJSON :: (FromJSON a) => Value -> Result a
805fromJSON :: (FromJSON a) => Value -> Result a
610fromJSON = parse parseJSON
806fromJSON = parse parseJSON
@@ -623,32 +819,68 @@ ifromJSON = iparse parseJSON
623-- in an object for it to be valid. If the key and value are
819-- in an object for it to be valid. If the key and value are
624-- optional, use '.:?' instead.
820-- optional, use '.:?' instead.
625(.:) :: (FromJSON a) => Object -> Text -> Parser a
821(.:) :: (FromJSON a) => Object -> Text -> Parser a
626−obj .: key = case H.lookup key obj of
822+(.:) = explicitParseField parseJSON
627− Nothing -> fail $ "key " ++ show key ++ " not present"
628− Just v -> parseJSON v <?> Key key
629{-# INLINE (.:) #-}
823{-# INLINE (.:) #-}
631−-- | Retrieve the value associated with the given key of an 'Object'.
825+-- | Retrieve the value associated with the given key of an 'Object'. The
632−-- The result is 'Nothing' if the key is not present, or 'empty' if
826+-- result is 'Nothing' if the key is not present or if its value is 'Null',
633−-- the value cannot be converted to the desired type.
827+-- or 'empty' if the value cannot be converted to the desired type.
635-- This accessor is most useful if the key and value can be absent
829-- This accessor is most useful if the key and value can be absent
636-- from an object without affecting its validity. If the key and
830-- from an object without affecting its validity. If the key and
637-- value are mandatory, use '.:' instead.
831-- value are mandatory, use '.:' instead.
638(.:?) :: (FromJSON a) => Object -> Text -> Parser (Maybe a)
832(.:?) :: (FromJSON a) => Object -> Text -> Parser (Maybe a)
639−obj .:? key = case H.lookup key obj of
833+(.:?) = explicitParseFieldMaybe parseJSON
640− Nothing -> pure Nothing
641− Just v -> parseJSON v <?> Key key
642{-# INLINE (.:?) #-}
834{-# INLINE (.:?) #-}
644−-- | Like '.:?', but the resulting parser will fail,
836+-- | Retrieve the value associated with the given key of an 'Object'.
645−-- if the key is present but is 'Null'.
837+-- The result is 'Nothing' if the key is not present or 'empty' if the
838+-- value cannot be converted to the desired type.
840+-- This differs from '.:?' by attempting to parse 'Null' the same as any
841+-- other JSON value, instead of interpreting it as 'Nothing'.
646(.:!) :: (FromJSON a) => Object -> Text -> Parser (Maybe a)
842(.:!) :: (FromJSON a) => Object -> Text -> Parser (Maybe a)
647−obj .:! key = case H.lookup key obj of
843+(.:!) = explicitParseFieldMaybe' parseJSON
648− Nothing -> pure Nothing
649− Just v -> Just <$> parseJSON v <?> Key key
650{-# INLINE (.:!) #-}
844{-# INLINE (.:!) #-}
846+-- | Function variant of '.:'.
847+parseField :: (FromJSON a) => Object -> Text -> Parser a
849+{-# INLINE parseField #-}
851+-- | Function variant of '.:?'.
852+parseFieldMaybe :: (FromJSON a) => Object -> Text -> Parser (Maybe a)
853+parseFieldMaybe = (.:?)
854+{-# INLINE parseFieldMaybe #-}
856+-- | Function variant of '.:!'.
857+parseFieldMaybe' :: (FromJSON a) => Object -> Text -> Parser (Maybe a)
858+parseFieldMaybe' = (.:!)
859+{-# INLINE parseFieldMaybe' #-}
861+-- | Variant of '.:' with explicit parser function.
863+-- E.g. @'explicitParseField' 'parseJSON1' :: ('FromJSON1' f, 'FromJSON' a) -> 'Object' -> 'Text' -> 'Parser' (f a)@
864+explicitParseField :: (Value -> Parser a) -> Object -> Text -> Parser a
865+explicitParseField p obj key = case H.lookup key obj of
866+ Nothing -> fail $ "key " ++ show key ++ " not found"
867+ Just v -> p v <?> Key key
868+{-# INLINE explicitParseField #-}
870+-- | Variant of '.:?' with explicit parser function.
871+explicitParseFieldMaybe :: (Value -> Parser a) -> Object -> Text -> Parser (Maybe a)
872+explicitParseFieldMaybe p obj key = case H.lookup key obj of
873+ Nothing -> pure Nothing
874+ Just v -> liftParseJSON p (listParser p) v <?> Key key -- listParser isn't used by maybe instance.
875+{-# INLINE explicitParseFieldMaybe #-}
877+-- | Variant of '.:!' with explicit parser function.
878+explicitParseFieldMaybe' :: (Value -> Parser a) -> Object -> Text -> Parser (Maybe a)
879+explicitParseFieldMaybe' p obj key = case H.lookup key obj of
880+ Nothing -> pure Nothing
881+ Just v -> Just <$> p v <?> Key key
882+{-# INLINE explicitParseFieldMaybe' #-}
652-- | Helper for use in combination with '.:?' to provide default
884-- | Helper for use in combination with '.:?' to provide default
653-- values for optional JSON object fields.
885-- values for optional JSON object fields.
@@ -671,317 +903,554 @@ pmval .!= val = fromMaybe val <$> pmval
671-- Generic parseJSON
903-- Generic parseJSON
672-------------------------------------------------------------------------------
904-------------------------------------------------------------------------------
906+instance GFromJSON arity V1 where
907+ -- Whereof we cannot format, thereof we cannot parse:
908+ gParseJSON _ _ _ = fail "Attempted to parse empty type"
674instance OVERLAPPABLE_ (GFromJSON arity a) => GFromJSON arity (M1 i c a) where
911instance OVERLAPPABLE_ (GFromJSON arity a) => GFromJSON arity (M1 i c a) where
675 -- Meta-information, which is not handled elsewhere, is just added to the
912 -- Meta-information, which is not handled elsewhere, is just added to the
676 -- parsed value:
913 -- parsed value:
677− gParseJSON opts pa pj pjl = fmap M1 . gParseJSON opts pa pj pjl
914+ gParseJSON opts fargs = fmap M1 . gParseJSON opts fargs
916+-- Information for error messages
918+type TypeName = String
919+type ConName = String
921+-- | Add the name of the type being parsed to a parser's error messages.
922+contextType :: TypeName -> Parser a -> Parser a
923+contextType = prependContext
925+-- | Add the tagKey that will be looked up while building an ADT
926+-- | Produce the error equivalent to
927+-- | Left "Error in $: parsing T failed, expected an object with keys "tag" and
928+-- | "contents", where "tag" i-- |s associated to one of ["Foo", "Bar"],
929+-- | The parser returned error was: could not find key "tag"
930+contextTag :: Text -> [String] -> Parser a -> Parser a
931+contextTag tagKey cnames = prependFailure
932+ ("expected Object with key \"" ++ unpack tagKey ++ "\"" ++
933+ " containing one of " ++ show cnames ++ ", ")
935+-- | Add the name of the constructor being parsed to a parser's error messages.
936+contextCons :: ConName -> TypeName -> Parser a -> Parser a
937+contextCons cname tname = prependContext (showCons cname tname)
939+-- | Render a constructor as @\"MyType(MyConstructor)\"@.
940+showCons :: ConName -> TypeName -> String
941+showCons cname tname = tname ++ "(" ++ cname ++ ")"
943+--------------------------------------------------------------------------------
945+-- Parsing single fields
679instance (FromJSON a) => GFromJSON arity (K1 i a) where
947instance (FromJSON a) => GFromJSON arity (K1 i a) where
680 -- Constant values are decoded using their FromJSON instance:
948 -- Constant values are decoded using their FromJSON instance:
681− gParseJSON _opts _ _ _ = fmap K1 . parseJSON
949+ gParseJSON _opts _ = fmap K1 . parseJSON
683instance GFromJSON One Par1 where
951instance GFromJSON One Par1 where
684 -- Direct occurrences of the last type parameter are decoded with the
952 -- Direct occurrences of the last type parameter are decoded with the
685 -- function passed in as an argument:
953 -- function passed in as an argument:
686− gParseJSON _opts _ pj _ = fmap Par1 . pj
954+ gParseJSON _opts (From1Args pj _) = fmap Par1 . pj
688instance (FromJSON1 f) => GFromJSON One (Rec1 f) where
956instance (FromJSON1 f) => GFromJSON One (Rec1 f) where
689 -- Recursive occurrences of the last type parameter are decoded using their
957 -- Recursive occurrences of the last type parameter are decoded using their
690 -- FromJSON1 instance:
958 -- FromJSON1 instance:
691− gParseJSON _opts _ pj pjl = fmap Rec1 . liftParseJSON pj pjl
959+ gParseJSON _opts (From1Args pj pjl) = fmap Rec1 . liftParseJSON pj pjl
693−instance GFromJSON arity U1 where
694− -- Empty constructors are expected to be encoded as an empty array:
695− gParseJSON _opts _ _ _ v
696− | isEmptyArray v = pure U1
697− | otherwise = typeMismatch "unit constructor (U1)" v
699−instance (ConsFromJSON arity a) => GFromJSON arity (C1 c a) where
700− -- Constructors need to be decoded differently depending on whether they're
701− -- a record or not. This distinction is made by consParseJSON:
702− gParseJSON opts pa pj pjl = fmap M1 . consParseJSON opts pa pj pjl
704−instance ( FromProduct arity a, FromProduct arity b
705− , ProductSize a, ProductSize b
706− ) => GFromJSON arity (a :*: b) where
707− -- Products are expected to be encoded to an array. Here we check whether we
708− -- got an array of the same size as the product, then parse each of the
709− -- product's elements using parseProduct:
710− gParseJSON opts pa pj pjl = withArray "product (:*:)" $ \arr ->
711− let lenArray = V.length arr
712− lenProduct = (unTagged2 :: Tagged2 (a :*: b) Int -> Int)
714− if lenArray == lenProduct
715− then parseProduct opts pa arr 0 lenProduct pj pjl
716− else fail $ "When expecting a product of " ++ show lenProduct ++
717− " values, encountered an Array of " ++ show lenArray ++
720−instance ( AllNullary (a :+: b) allNullary
721− , ParseSum arity (a :+: b) allNullary
722− ) => GFromJSON arity (a :+: b) where
723− -- If all constructors of a sum datatype are nullary and the
724− -- 'allNullaryToStringTag' option is set they are expected to be
725− -- encoded as strings. This distinction is made by 'parseSum':
726− gParseJSON opts pa pj pjl =
727− (unTagged :: Tagged allNullary (Parser ((a :+: b) d)) ->
728− (Parser ((a :+: b) d)))
729− . parseSum opts pa pj pjl
731instance (FromJSON1 f, GFromJSON One g) => GFromJSON One (f :.: g) where
961instance (FromJSON1 f, GFromJSON One g) => GFromJSON One (f :.: g) where
732 -- If an occurrence of the last type parameter is nested inside two
962 -- If an occurrence of the last type parameter is nested inside two
733 -- composed types, it is decoded by using the outermost type's FromJSON1
963 -- composed types, it is decoded by using the outermost type's FromJSON1
734 -- instance to generically decode the innermost type:
964 -- instance to generically decode the innermost type:
735− gParseJSON opts pa pj pjl =
965+ gParseJSON opts fargs =
736− let gpj = gParseJSON opts pa pj pjl in
966+ let gpj = gParseJSON opts fargs in
737− fmap Comp1 . liftParseJSON gpj (listParser gpj)
967+ fmap Comp1 . liftParseJSON gpj (listParser gpj)
969+--------------------------------------------------------------------------------
971+instance (GFromJSON' arity a, Datatype d) => GFromJSON arity (D1 d a) where
972+ -- Meta-information, which is not handled elsewhere, is just added to the
974+ gParseJSON opts fargs = fmap M1 . gParseJSON' (tname :* opts :* fargs)
976+ tname = moduleName proxy ++ "." ++ datatypeName proxy
977+ proxy = undefined :: M1 _i d _f _p
979+-- | 'GFromJSON', after unwrapping the 'D1' constructor, now carrying the data
981+class GFromJSON' arity f where
982+ gParseJSON' :: TypeName :* Options :* FromArgs arity a
986+-- | Single constructor.
987+instance ( ConsFromJSON arity a
988+ , AllNullary (C1 c a) allNullary
989+ , ParseSum arity (C1 c a) allNullary
991+ ) => GFromJSON' arity (C1 c a) where
992+ -- The option 'tagSingleConstructors' determines whether to wrap
993+ -- a single-constructor type.
994+ gParseJSON' p@(_ :* opts :* _)
995+ | tagSingleConstructors opts
996+ = (unTagged :: Tagged allNullary (Parser (C1 c a p)) -> Parser (C1 c a p))
998+ | otherwise = fmap M1 . consParseJSON (cname :* p)
1000+ cname = conName (undefined :: M1 _i c _f _p)
1002+-- | Multiple constructors.
1003+instance ( AllNullary (a :+: b) allNullary
1004+ , ParseSum arity (a :+: b) allNullary
1005+ ) => GFromJSON' arity (a :+: b) where
1006+ -- If all constructors of a sum datatype are nullary and the
1007+ -- 'allNullaryToStringTag' option is set they are expected to be
1008+ -- encoded as strings. This distinction is made by 'parseSum':
1010+ (unTagged :: Tagged allNullary (Parser ((a :+: b) _d)) ->
1011+ Parser ((a :+: b) _d))
739--------------------------------------------------------------------------------
1014--------------------------------------------------------------------------------
741class ParseSum arity f allNullary where
1016class ParseSum arity f allNullary where
742− parseSum :: Options -> Proxy arity
1017+ parseSum :: TypeName :* Options :* FromArgs arity a
743− -> (Value -> Parser a) -> (Value -> Parser [a])
1018+ -> Value
744− -> Value -> Tagged allNullary (Parser (f a))
1019+ -> Tagged allNullary (Parser (f a))
1021+instance ( ConstructorNames f
746−instance ( SumFromString (a :+: b)
1022+ , SumFromString f
747− , FromPair arity (a :+: b)
1023+ , FromPair arity f
748− , FromTaggedObject arity (a :+: b)
1024+ , FromTaggedObject arity f
1025+ , FromUntaggedValue arity f
749− ) => ParseSum arity (a :+: b) True where
1026+ ) => ParseSum arity f True where
750− parseSum opts pa pj pjl
1027+ parseSum p@(tname :* opts :* _)
751− | allNullaryToStringTag opts = Tagged . parseAllNullarySum opts
1028+ | allNullaryToStringTag opts = Tagged . parseAllNullarySum tname opts
752− | otherwise = Tagged . parseNonAllNullarySum opts pa pj pjl
1029+ | otherwise = Tagged . parseNonAllNullarySum p
754−instance ( FromPair arity (a :+: b)
1031+instance ( ConstructorNames f
755− , FromTaggedObject arity (a :+: b)
1032+ , FromPair arity f
1033+ , FromTaggedObject arity f
1034+ , FromUntaggedValue arity f
756− ) => ParseSum arity (a :+: b) False where
1035+ ) => ParseSum arity f False where
757− parseSum opts pa pj pjl = Tagged . parseNonAllNullarySum opts pa pj pjl
1036+ parseSum p = Tagged . parseNonAllNullarySum p
759--------------------------------------------------------------------------------
1038--------------------------------------------------------------------------------
761−parseAllNullarySum :: SumFromString f => Options -> Value -> Parser (f a)
1040+parseAllNullarySum :: (SumFromString f, ConstructorNames f)
1041+ => TypeName -> Options -> Value -> Parser (f a)
762−parseAllNullarySum opts = withText "Text" $ \key ->
1042+parseAllNullarySum tname opts =
1043+ withText tname $ \tag ->
763− maybe (notFound key) return $
1044+ maybe (badTag tag) return $
764− parseSumFromString opts key
1045+ parseSumFromString modifier tag
1047+ badTag tag = failWithCTags tname modifier $ \cnames ->
1048+ "expected one of the tags " ++ show cnames ++
1049+ ", but found tag " ++ show tag
1050+ modifier = constructorTagModifier opts
1052+-- | Fail with an informative error message about a mismatched tag.
1053+-- The error message is parameterized by the list of expected tags,
1054+-- to be inferred from the result type of the parser.
1056+ :: forall f a t. ConstructorNames f
1057+ => TypeName -> (String -> t) -> ([t] -> String) -> Parser (f a)
1058+failWithCTags tname modifier f =
1059+ contextType tname . fail $ f cnames
1061+ cnames = unTagged2 (constructorTags modifier :: Tagged2 f [t])
766class SumFromString f where
1063class SumFromString f where
767− parseSumFromString :: Options -> Text -> Maybe (f a)
1064+ parseSumFromString :: (String -> String) -> Text -> Maybe (f a)
769instance (SumFromString a, SumFromString b) => SumFromString (a :+: b) where
1066instance (SumFromString a, SumFromString b) => SumFromString (a :+: b) where
770 parseSumFromString opts key = (L1 <$> parseSumFromString opts key) <|>
1067 parseSumFromString opts key = (L1 <$> parseSumFromString opts key) <|>
771 (R1 <$> parseSumFromString opts key)
1068 (R1 <$> parseSumFromString opts key)
773instance (Constructor c) => SumFromString (C1 c U1) where
1070instance (Constructor c) => SumFromString (C1 c U1) where
774− parseSumFromString opts key | key == name = Just $ M1 U1
1071+ parseSumFromString modifier key
1072+ | key == name = Just $ M1 U1
775− | otherwise = Nothing
1073+ | otherwise = Nothing
777− name = pack $ constructorTagModifier opts $
778− conName (undefined :: t c U1 p)
1075+ name = pack $ modifier $ conName (undefined :: M1 _i c _f _p)
780−--------------------------------------------------------------------------------
1077+-- For genericFromJSONKey
1078+instance SumFromString a => SumFromString (D1 d a) where
1079+ parseSumFromString modifier key = M1 <$> parseSumFromString modifier key
1081+-- | List of all constructor tags.
1082+constructorTags :: ConstructorNames a => (String -> t) -> Tagged2 a [t]
1083+constructorTags modifier =
1084+ fmap DList.toList (constructorNames' modifier)
1086+-- | List of all constructor names of an ADT, after a given conversion
1087+-- function. (Better inlining.)
1088+class ConstructorNames a where
1089+ constructorNames' :: (String -> t) -> Tagged2 a (DList.DList t)
1091+instance (ConstructorNames a, ConstructorNames b) => ConstructorNames (a :+: b) where
1092+ constructorNames' = liftA2 append constructorNames' constructorNames'
1095+ :: Tagged2 a (DList.DList t)
1096+ -> Tagged2 b (DList.DList t)
1097+ -> Tagged2 (a :+: b) (DList.DList t)
1098+ append (Tagged2 xs) (Tagged2 ys) = Tagged2 (DList.append xs ys)
1100+instance Constructor c => ConstructorNames (C1 c a) where
1101+ constructorNames' f = Tagged2 (pure (f cname))
1103+ cname = conName (undefined :: M1 _i c _f _p)
1105+-- For genericFromJSONKey
1106+instance ConstructorNames a => ConstructorNames (D1 d a) where
1107+ constructorNames' = retag . constructorNames'
1109+ retag :: Tagged2 a u -> Tagged2 (D1 d a) u
1110+ retag (Tagged2 x) = Tagged2 x
1112+--------------------------------------------------------------------------------
782−parseNonAllNullarySum :: ( FromPair arity (a :+: b)
1113+parseNonAllNullarySum :: forall f c arity.
783− , FromTaggedObject arity (a :+: b)
1115+ , FromTaggedObject arity f
1116+ , FromUntaggedValue arity f
1117+ , ConstructorNames f
784− ) => Options -> Proxy arity
1118+ ) => TypeName :* Options :* FromArgs arity c
785− -> (Value -> Parser c) -> (Value -> Parser [c])
1119+ -> Value -> Parser (f c)
786− -> Value -> Parser ((a :+: b) c)
1120+parseNonAllNullarySum p@(tname :* opts :* _) =
787−parseNonAllNullarySum opts pa pj pjl =
788 case sumEncoding opts of
1121 case sumEncoding opts of
789 TaggedObject{..} ->
1122 TaggedObject{..} ->
790− withObject "Object" $ \obj -> do
1123+ withObject tname $ \obj -> do
791− tag <- obj .: pack tagFieldName
1124+ tag <- contextType tname . contextTag tagKey cnames_ $ obj .: tagKey
792− fromMaybe (notFound tag) $
1125+ fromMaybe (badTag tag <?> Key tagKey) $
793− parseFromTaggedObject opts pa contentsFieldName obj pj pjl tag
1126+ parseFromTaggedObject (tag :* contentsFieldName :* p) obj
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])
795 ObjectWithSingleField ->
1134 ObjectWithSingleField ->
796− withObject "Object" $ \obj ->
797− case H.toList obj of
1135+ withObject tname $ \obj -> case H.toList obj of
798− [pair@(tag, _)] -> fromMaybe (notFound tag) $
1136+ [(tag, v)] -> maybe (badTag tag) (<?> Key tag) $
799− parsePair opts pa pj pjl pair
1137+ parsePair (tag :* p) v
800− _ -> fail "Object doesn't have a single field"
1138+ _ -> contextType tname . fail $
1139+ "expected an Object with a single pair, but found " ++
1140+ show (H.size obj) ++ " pairs"
1142+ badTag tag = failWith_ $ \cnames ->
1143+ "expected an Object with a single pair where the tag is one of " ++
1144+ show cnames ++ ", but found tag " ++ show tag
802 TwoElemArray ->
1146 TwoElemArray ->
803− withArray "Array" $ \arr ->
1147+ withArray tname $ \arr -> case V.length arr of
804− if V.length arr == 2
1148+ 2 | String tag <- V.unsafeIndex arr 0 ->
805− then case V.unsafeIndex arr 0 of
1149+ maybe (badTag tag <?> Index 0) (<?> Index 1) $
806− String tag -> fromMaybe (notFound tag) $
807− parsePair opts pa pj pjl (tag, V.unsafeIndex arr 1)
1150+ parsePair (tag :* p) (V.unsafeIndex arr 1)
1152+ contextType tname $
808− _ -> fail "First element is not a String"
1153+ fail "tag element is not a String" <?> Index 0
809− else fail "Array doesn't have 2 elements"
1154+ len -> contextType tname . fail $
1155+ "expected a 2-element Array, but encountered an Array of length " ++
1158+ badTag tag = failWith_ $ \cnames ->
1159+ "expected tag of the 2-element Array to be one of " ++
1160+ show cnames ++ ", but found tag " ++ show tag
1162+ UntaggedValue -> parseUntaggedValue p
1164+ failWith_ = failWithCTags tname (constructorTagModifier opts)
811--------------------------------------------------------------------------------
1166--------------------------------------------------------------------------------
813class FromTaggedObject arity f where
1168class 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.
814− parseFromTaggedObject :: Options -> Proxy arity
1171+ parseFromTaggedObject
1172+ :: Text :* String :* TypeName :* Options :* FromArgs arity a
815− -> String -> Object
1173+ -> Object
816− -> (Value -> Parser a) -> (Value -> Parser [a])
817− -> Text -> Maybe (Parser (f a))
1174+ -> Maybe (Parser (f a))
819instance ( FromTaggedObject arity a, FromTaggedObject arity b) =>
1176instance ( FromTaggedObject arity a, FromTaggedObject arity b) =>
820 FromTaggedObject arity (a :+: b) where
1177 FromTaggedObject arity (a :+: b) where
821− parseFromTaggedObject opts pa contentsFieldName obj pj pjl tag =
1178+ parseFromTaggedObject p obj =
822− (fmap L1 <$> parseFromTaggedObject opts pa contentsFieldName obj pj pjl tag) <|>
1179+ (fmap L1 <$> parseFromTaggedObject p obj) <|>
823− (fmap R1 <$> parseFromTaggedObject opts pa contentsFieldName obj pj pjl tag)
1180+ (fmap R1 <$> parseFromTaggedObject p obj)
1182+instance ( IsRecord f isRecord
825−instance ( FromTaggedObject' arity f
1183+ , FromTaggedObject' arity f isRecord
826 , Constructor c
1184 , Constructor c
827 ) => FromTaggedObject arity (C1 c f) where
1185 ) => FromTaggedObject arity (C1 c f) where
828− parseFromTaggedObject opts pa contentsFieldName obj pj pjl tag
1186+ parseFromTaggedObject (tag :* contentsFieldName :* p@(_ :* opts :* _))
1189+ (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a)) .
829− | tag == name = Just $ M1 <$> parseFromTaggedObject'
1190+ parseFromTaggedObject' (contentsFieldName :* cname :* p)
830− opts pa contentsFieldName pj pjl obj
831− | otherwise = Nothing
1191+ | otherwise = const Nothing
833− name = pack $ constructorTagModifier opts $
1193+ tag' = pack $ constructorTagModifier opts cname
834− conName (undefined :: t c f p)
1194+ cname = conName (undefined :: M1 _i c _f _p)
836--------------------------------------------------------------------------------
1196--------------------------------------------------------------------------------
838−class FromTaggedObject' arity f where
1198+class FromTaggedObject' arity f isRecord where
839− parseFromTaggedObject' :: Options -> Proxy arity -> String
1199+ -- The first component of the parameter tuple is the contents field name.
840− -> (Value -> Parser a) -> (Value -> Parser [a])
841− -> Object -> Parser (f a)
843−class FromTaggedObject'' arity f isRecord where
844− parseFromTaggedObject'' :: Options -> Proxy arity -> String
1200+ parseFromTaggedObject'
845− -> (Value -> Parser a) -> (Value -> Parser [a])
1201+ :: String :* ConName :* TypeName :* Options :* FromArgs arity a
846− -> Object -> Tagged isRecord (Parser (f a))
1202+ -> Object -> Tagged isRecord (Parser (f a))
848−instance ( IsRecord f isRecord
849− , FromTaggedObject'' arity f isRecord
850− ) => FromTaggedObject' arity f where
1204+instance (RecordFromJSON arity f, FieldNames f) => FromTaggedObject' arity f True where
851− parseFromTaggedObject' opts pa contentsFieldName pj pjl =
1205+ -- Records are unpacked in the tagged object
852− (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a)) .
853− parseFromTaggedObject'' opts pa contentsFieldName pj pjl
855−instance (FromRecord arity f) => FromTaggedObject'' arity f True where
856− parseFromTaggedObject'' opts pa _ pj pjl =
1206+ parseFromTaggedObject' (_ :* p) = Tagged . recordParseJSON (True :* p)
857− Tagged . parseRecord opts pa Nothing pj pjl
1207+
859−instance (GFromJSON arity f) => FromTaggedObject'' arity f False where
1208+instance (ConsFromJSON arity f) => FromTaggedObject' arity f False where
860− parseFromTaggedObject'' opts pa contentsFieldName pj pjl = Tagged .
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
861− (gParseJSON opts pa pj pjl <=< (.: pack contentsFieldName))
1214+ key = pack contentsFieldName
1215+ contentsFieldName :* p'@(cname :* tname :* _) = p
863−instance OVERLAPPING_ FromTaggedObject'' arity U1 False where
1217+instance OVERLAPPING_ FromTaggedObject' arity U1 False where
1218+ -- Nullary constructors don't need a contents field
864− parseFromTaggedObject'' _ _ _ _ _ _ = Tagged (pure U1)
1219+ parseFromTaggedObject' _ _ = Tagged (pure U1)
866--------------------------------------------------------------------------------
1221--------------------------------------------------------------------------------
1223+-- | Constructors need to be decoded differently depending on whether they're
1224+-- a record or not. This distinction is made by 'ConsParseJSON'.
868class ConsFromJSON arity f where
1225class ConsFromJSON arity f where
869− consParseJSON :: Options -> Proxy arity
1226+ consParseJSON
870− -> (Value -> Parser a) -> (Value -> Parser [a])
1227+ :: ConName :* TypeName :* Options :* FromArgs arity a
871− -> Value -> Parser (f a)
1228+ -> Value -> Parser (f a)
873class ConsFromJSON' arity f isRecord where
1230class ConsFromJSON' arity f isRecord where
874− consParseJSON' :: Options -> Proxy arity
1231+ consParseJSON'
875− -> (Maybe Text) -- ^ A dummy label
1232+ :: ConName :* TypeName :* Options :* FromArgs arity a
876− -- (Nothing to use proper label)
877− -> (Value -> Parser a) -> (Value -> Parser [a])
878− -> Value -> Tagged isRecord (Parser (f a))
1233+ -> Value -> Tagged isRecord (Parser (f a))
880instance ( IsRecord f isRecord
1235instance ( IsRecord f isRecord
881 , ConsFromJSON' arity f isRecord
1236 , ConsFromJSON' arity f isRecord
882 ) => ConsFromJSON arity f where
1237 ) => ConsFromJSON arity f where
883− consParseJSON opts pa pj pjl v = let
1238+ consParseJSON p =
884− (v2,lab) = case (unwrapUnaryRecords opts,isUnary (undefined :: f a)) of
885− -- use a dummy object with a dummy label
886− (True,True) -> ((object [(pack "dummy",v)]),Just $ pack "dummy")
888− in (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a))
1239+ (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a))
889− $ consParseJSON' opts pa lab pj pjl v2
1240+ . consParseJSON' p
1242+instance OVERLAPPING_
1243+ ( GFromJSON arity a, RecordFromJSON arity (S1 s a)
1244+ ) => ConsFromJSON' arity (S1 s a) True where
1245+ consParseJSON' p@(cname :* tname :* opts :* fargs)
1246+ | unwrapUnaryRecords opts = Tagged . fmap M1 . gParseJSON opts fargs
1247+ | otherwise = Tagged . withObject (showCons cname tname) (recordParseJSON (False :* p))
1249+instance RecordFromJSON arity f => ConsFromJSON' arity f True where
1250+ consParseJSON' p@(cname :* tname :* _) =
1251+ Tagged . withObject (showCons cname tname) (recordParseJSON (False :* p))
1253+instance OVERLAPPING_
1254+ ConsFromJSON' arity U1 False where
1255+ -- Empty constructors are expected to be encoded as an empty array:
1256+ consParseJSON' (cname :* tname :* _) v =
1257+ Tagged . contextCons cname tname $ case v of
1258+ Array a | V.null a -> pure U1
1259+ | otherwise -> fail_ a
1260+ _ -> typeMismatch "Array" v
1263+ "expected an empty Array, but encountered an Array of length " ++
1266+instance OVERLAPPING_
892−instance (FromRecord arity f) => ConsFromJSON' arity f True where
1267+ GFromJSON arity f => ConsFromJSON' arity (S1 s f) False where
893− consParseJSON' opts pa mlab pj pjl = Tagged . (withObject "record (:*:)"
1268+ consParseJSON' (_ :* _ :* opts :* fargs) =
894− $ parseRecord opts pa mlab pj pjl)
1269+ Tagged . fmap M1 . gParseJSON opts fargs
1271+instance (ProductFromJSON arity f, ProductSize f
896−instance (GFromJSON arity f) => ConsFromJSON' arity f False where
1272+ ) => ConsFromJSON' arity f False where
897− consParseJSON' opts pa _ pj pjl = Tagged . gParseJSON opts pa pj pjl
1273+ consParseJSON' p = Tagged . productParseJSON0 p
899--------------------------------------------------------------------------------
1275--------------------------------------------------------------------------------
901−class FromRecord arity f where
1277+class FieldNames f where
902− parseRecord :: Options -> Proxy arity
1278+ fieldNames :: f a -> [Text] -> [Text]
903− -> (Maybe Text) -- ^ A dummy label
1279+
904− -- (Nothing to use proper label)
1280+instance (FieldNames a, FieldNames b) => FieldNames (a :*: b) where
905− -> (Value -> Parser a) -> (Value -> Parser [a])
1281+ fieldNames _ =
1282+ fieldNames (undefined :: a x) .
1283+ fieldNames (undefined :: b y)
1285+instance (Selector s) => FieldNames (S1 s f) where
1286+ fieldNames _ = (pack (selName (undefined :: M1 _i s _f _p)) :)
1288+class RecordFromJSON arity f where
1290+ :: Bool :* ConName :* TypeName :* Options :* FromArgs arity a
906− -> Object -> Parser (f a)
1291+ -> Object -> Parser (f a)
908−instance ( FromRecord arity a
1293+instance ( FieldNames f
909− , FromRecord arity b
1294+ , RecordFromJSON' arity f
910− ) => FromRecord arity (a :*: b) where
1295+ ) => RecordFromJSON arity f where
911− parseRecord opts pa _ pj pjl obj =
1296+ recordParseJSON (fromTaggedSum :* p@(cname :* tname :* opts :* _)) =
912− (:*:) <$> parseRecord opts pa Nothing pj pjl obj
1297+ \obj -> checkUnknown obj >> recordParseJSON' p obj
913− <*> parseRecord opts pa Nothing pj pjl obj
915−instance ( Selector s
917− ) => FromRecord arity (S1 s a) where
918− parseRecord opts pa lab pj pjl =
919− (<?> Key label) . gParseJSON opts pa pj pjl <=< (.: label)
921− label = fromMaybe defLabel lab
922− defLabel = pack . fieldLabelModifier opts $
923− selName (undefined :: t s a p)
925−instance OVERLAPPING_ (Selector s, FromJSON a) =>
926− FromRecord arity (S1 s (K1 i (Maybe a))) where
927− parseRecord _ _ (Just lab) _ _ obj = (M1 . K1) <$> obj .:? lab
928− parseRecord opts _ Nothing _ _ obj = (M1 . K1) <$> obj .:? pack label
1299+ knownFields :: H.HashMap Text ()
1300+ knownFields = H.fromList $ map (,()) $
1301+ fieldNames (undefined :: f a)
1302+ [pack (tagFieldName (sumEncoding opts)) | fromTaggedSum]
1304+ if not (rejectUnknownFields opts)
1305+ then \_ -> return ()
1306+ else \obj -> case H.keys (H.difference obj knownFields) of
1308+ unknownFields -> contextCons cname tname $
1309+ fail ("unknown fields: " ++ show unknownFields)
1311+class RecordFromJSON' arity f where
1313+ :: ConName :* TypeName :* Options :* FromArgs arity a
1314+ -> Object -> Parser (f a)
1316+instance ( RecordFromJSON' arity a
1317+ , RecordFromJSON' arity b
1318+ ) => RecordFromJSON' arity (a :*: b) where
1319+ recordParseJSON' p obj =
1320+ (:*:) <$> recordParseJSON' p obj
1321+ <*> recordParseJSON' p obj
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
930− label = fieldLabelModifier opts $
1329+ label = pack $ fieldLabelModifier opts sname
1330+ sname = selName (undefined :: M1 _i s _f _p)
1332+instance INCOHERENT_ (Selector s, FromJSON a) =>
1333+ RecordFromJSON' arity (S1 s (K1 i (Maybe a))) where
1334+ recordParseJSON' (_ :* _ :* opts :* _) obj = M1 . K1 <$> obj .:? pack label
1336+ label = fieldLabelModifier opts sname
931− selName (undefined :: t s (K1 i (Maybe a)) p)
1337+ sname = selName (undefined :: M1 _i s _f _p)
1339+-- Parse an Option like a Maybe.
1340+instance INCOHERENT_ (Selector s, FromJSON a) =>
1341+ RecordFromJSON' arity (S1 s (K1 i (Semigroup.Option a))) where
1342+ recordParseJSON' p obj = wrap <$> recordParseJSON' p obj
1344+ wrap :: S1 s (K1 i (Maybe a)) p -> S1 s (K1 i (Semigroup.Option a)) p
1345+ wrap (M1 (K1 a)) = M1 (K1 (Semigroup.Option a))
933--------------------------------------------------------------------------------
1347--------------------------------------------------------------------------------
1350+ :: forall f arity a. (ProductFromJSON arity f, ProductSize f)
1351+ => ConName :* TypeName :* Options :* FromArgs arity a
1352+ -> Value -> Parser (f a)
1353+ -- Products are expected to be encoded to an array. Here we check whether we
1354+ -- got an array of the same size as the product, then parse each of the
1355+ -- product's elements using productParseJSON:
1356+productParseJSON0 p@(cname :* tname :* _ :* _) =
1357+ withArray (showCons cname tname) $ \arr ->
1358+ let lenArray = V.length arr
1359+ lenProduct = (unTagged2 :: Tagged2 f Int -> Int)
1361+ if lenArray == lenProduct
1362+ then productParseJSON p arr 0 lenProduct
1363+ else contextCons cname tname $
1364+ fail $ "expected an Array of length " ++ show lenProduct ++
1365+ ", but encountered an Array of length " ++ show lenArray
935−class FromProduct arity f where
1369+class ProductFromJSON arity f where
936− parseProduct :: Options -> Proxy arity
1370+ productParseJSON :: ConName :* TypeName :* Options :* FromArgs arity a
937 -> Array -> Int -> Int
1371 -> Array -> Int -> Int
938− -> (Value -> Parser a) -> (Value -> Parser [a])
939 -> Parser (f a)
1372 -> Parser (f a)
941−instance ( FromProduct arity a
1374+instance ( ProductFromJSON arity a
942− , FromProduct arity b
1375+ , ProductFromJSON arity b
943− ) => FromProduct arity (a :*: b) where
1376+ ) => ProductFromJSON arity (a :*: b) where
944− parseProduct opts pa arr ix len pj pjl =
1377+ productParseJSON p arr ix len =
945− (:*:) <$> parseProduct opts pa arr ix lenL pj pjl
1378+ (:*:) <$> productParseJSON p arr ix lenL
946− <*> parseProduct opts pa arr ixR lenR pj pjl
1379+ <*> productParseJSON p arr ixR lenR
948 lenL = len `unsafeShiftR` 1
1381 lenL = len `unsafeShiftR` 1
949 ixR = ix + lenL
1382 ixR = ix + lenL
950 lenR = len - lenL
1383 lenR = len - lenL
952−instance (GFromJSON arity a) => FromProduct arity (S1 s a) where
1385+instance (GFromJSON arity a) => ProductFromJSON arity (S1 s a) where
953− parseProduct opts pa arr ix _ pj pjl =
1386+ productParseJSON (_ :* _ :* opts :* fargs) arr ix _ =
954− gParseJSON opts pa pj pjl $ V.unsafeIndex arr ix
1387+ M1 <$> gParseJSON opts fargs (V.unsafeIndex arr ix) <?> Index ix
956--------------------------------------------------------------------------------
1389--------------------------------------------------------------------------------
958class FromPair arity f where
1391class FromPair arity f where
1392+ -- The first component of the parameter tuple is the tag to match.
959− parsePair :: Options -> Proxy arity
1393+ parsePair :: Text :* TypeName :* Options :* FromArgs arity a
960− -> (Value -> Parser a) -> (Value -> Parser [a])
1394+ -> Value
961− -> Pair -> Maybe (Parser (f a))
1395+ -> Maybe (Parser (f a))
963instance ( FromPair arity a
1397instance ( FromPair arity a
964 , FromPair arity b
1398 , FromPair arity b
965 ) => FromPair arity (a :+: b) where
1399 ) => FromPair arity (a :+: b) where
966− parsePair opts pa pj pjl pair = (fmap L1 <$> parsePair opts pa pj pjl pair) <|>
1401+ (fmap L1 <$> parsePair p pair) <|>
967− (fmap R1 <$> parsePair opts pa pj pjl pair)
1402+ (fmap R1 <$> parsePair p pair)
969instance ( Constructor c
1404instance ( Constructor c
971 , ConsFromJSON arity a
1405 , ConsFromJSON arity a
972 ) => FromPair arity (C1 c a) where
1406 ) => FromPair arity (C1 c a) where
973− parsePair opts pa pj pjl (tag, value)
1407+ parsePair (tag :* p@(_ :* opts :* _)) v
974− | tag == tag' = Just $ gParseJSON opts pa pj pjl value
1408+ | tag == tag' = Just $ M1 <$> consParseJSON (cname :* p) v
975 | otherwise = Nothing
1409 | otherwise = Nothing
977− tag' = pack $ constructorTagModifier opts $
1411+ tag' = pack $ constructorTagModifier opts cname
978− conName (undefined :: t c a p)
1412+ cname = conName (undefined :: M1 _i c _a _p)
980--------------------------------------------------------------------------------
1414--------------------------------------------------------------------------------
1416+class FromUntaggedValue arity f where
1417+ parseUntaggedValue :: TypeName :* Options :* FromArgs arity a
982−notFound :: Text -> Parser a
1419+ -> Parser (f a)
983−notFound key = fail $ "The key \"" ++ unpack key ++ "\" was not found"
1420+
984−{-# INLINE notFound #-}
1421+instance
1422+ ( FromUntaggedValue arity a
1423+ , FromUntaggedValue arity b
1424+ ) => FromUntaggedValue arity (a :+: b)
1426+ parseUntaggedValue p value =
1427+ L1 <$> parseUntaggedValue p value <|>
1428+ R1 <$> parseUntaggedValue p value
1430+instance OVERLAPPABLE_
1431+ ( ConsFromJSON arity a
1433+ ) => FromUntaggedValue arity (C1 c a)
1435+ parseUntaggedValue p = fmap M1 . consParseJSON (cname :* p)
1437+ cname = conName (undefined :: M1 _i c _f _p)
1439+instance OVERLAPPING_
1441+ => FromUntaggedValue arity (C1 c U1)
1443+ parseUntaggedValue (tname :* opts :* _) v =
1444+ contextCons cname tname $ case v of
1446+ | tag == tag' -> pure $ M1 U1
1447+ | otherwise -> fail_ tag
1448+ _ -> typeMismatch "String" v
1450+ tag' = pack $ constructorTagModifier opts cname
1451+ cname = conName (undefined :: M1 _i c _f _p)
1453+ "expected tag " ++ show tag' ++ ", but found tag " ++ show tag
986-------------------------------------------------------------------------------
1455-------------------------------------------------------------------------------
987-- Instances
1456-- Instances
@@ -1039,17 +1508,20 @@ instance (FromJSON a, FromJSON b) => FromJSON (Either a b) where
1039 parseJSON = parseJSON2
1508 parseJSON = parseJSON2
1040 {-# INLINE parseJSON #-}
1509 {-# INLINE parseJSON #-}
1042−
1511+instance FromJSON Void where
1512+ parseJSON _ = fail "Cannot parse Void"
1513+ {-# INLINE parseJSON #-}
1044instance FromJSON Bool where
1515instance FromJSON Bool where
1045− parseJSON = withBool "Bool" pure
1516+ parseJSON (Bool b) = pure b
1517+ parseJSON v = typeMismatch "Bool" v
1046 {-# INLINE parseJSON #-}
1518 {-# INLINE parseJSON #-}
1048instance FromJSONKey Bool where
1520instance FromJSONKey Bool where
1049 fromJSONKey = FromJSONKeyTextParser $ \t -> case t of
1521 fromJSONKey = FromJSONKeyTextParser $ \t -> case t of
1050 "true" -> pure True
1522 "true" -> pure True
1051 "false" -> pure False
1523 "false" -> pure False
1052− _ -> fail $ "Cannot parse key into Bool: " ++ T.unpack t
1524+ _ -> fail $ "cannot parse key " ++ show t ++ " into Bool"
1054instance FromJSON Ordering where
1526instance FromJSON Ordering where
1055 parseJSON = withText "Ordering" $ \s ->
1527 parseJSON = withText "Ordering" $ \s ->
@@ -1057,25 +1529,30 @@ instance FromJSON Ordering where
1057 "LT" -> return LT
1529 "LT" -> return LT
1058 "EQ" -> return EQ
1530 "EQ" -> return EQ
1059 "GT" -> return GT
1531 "GT" -> return GT
1532+ _ -> fail $ "parsing Ordering failed, unexpected " ++ show s ++
1060− _ -> fail "Parsing Ordering value failed: expected \"LT\", \"EQ\", or \"GT\""
1533+ " (expected \"LT\", \"EQ\", or \"GT\")"
1062instance FromJSON () where
1535instance FromJSON () where
1063 parseJSON = withArray "()" $ \v ->
1536 parseJSON = withArray "()" $ \v ->
1064 if V.null v
1537 if V.null v
1065 then pure ()
1538 then pure ()
1066− else fail "Expected an empty array"
1539+ else prependContext "()" $ fail "expected an empty array"
1067 {-# INLINE parseJSON #-}
1540 {-# INLINE parseJSON #-}
1069instance FromJSON Char where
1542instance FromJSON Char where
1070− parseJSON = withText "Char" $ \t ->
1543+ parseJSON = withText "Char" parseChar
1071− if T.compareLength t 1 == EQ
1072− then pure $ T.head t
1073− else fail "Expected a string of length 1"
1074 {-# INLINE parseJSON #-}
1544 {-# INLINE parseJSON #-}
1076− parseJSONList = withText "String" $ pure . T.unpack
1546+ parseJSONList (String s) = pure (T.unpack s)
1547+ parseJSONList v = typeMismatch "String" v
1077 {-# INLINE parseJSONList #-}
1548 {-# INLINE parseJSONList #-}
1550+parseChar :: Text -> Parser Char
1552+ if T.compareLength t 1 == EQ
1553+ then pure $ T.head t
1554+ else prependContext "Char" $ fail "expected a string of length 1"
1079instance FromJSON Double where
1556instance FromJSON Double where
1080 parseJSON = parseRealFloat "Double"
1557 parseJSON = parseRealFloat "Double"
1081 {-# INLINE parseJSON #-}
1558 {-# INLINE parseJSON #-}
@@ -1087,12 +1564,6 @@ instance FromJSONKey Double where
1087 "-Infinity" -> pure (negate 1/0)
1564 "-Infinity" -> pure (negate 1/0)
1088 _ -> Scientific.toRealFloat <$> parseScientificText t
1565 _ -> Scientific.toRealFloat <$> parseScientificText t
1090−instance FromJSON Number where
1091− parseJSON (Number s) = pure $ scientificToNumber s
1092− parseJSON Null = pure (D (0/0))
1093− parseJSON v = typeMismatch "Number" v
1094− {-# INLINE parseJSON #-}
1096instance FromJSON Float where
1567instance FromJSON Float where
1097 parseJSON = parseRealFloat "Float"
1568 parseJSON = parseRealFloat "Float"
1098 {-# INLINE parseJSON #-}
1569 {-# INLINE parseJSON #-}
@@ -1105,112 +1576,133 @@ instance FromJSONKey Float where
1105 _ -> Scientific.toRealFloat <$> parseScientificText t
1576 _ -> Scientific.toRealFloat <$> parseScientificText t
1107instance (FromJSON a, Integral a) => FromJSON (Ratio a) where
1578instance (FromJSON a, Integral a) => FromJSON (Ratio a) where
1579+ parseJSON (Number x)
1581+ , exp10 >= -1024 = return $! realToFrac x
1582+ | otherwise = prependContext "Ratio" $ fail msg
1584+ exp10 = base10Exponent x
1585+ msg = "found a number with exponent " ++ show exp10
1586+ ++ ", but it must not be greater than 1024 or less than -1024"
1587+ parseJSON o = objParser o
1108− parseJSON = withObject "Rational" $ \obj ->
1589+ objParser = withObject "Rational" $ \obj -> do
1109− (%) <$> obj .: "numerator"
1590+ numerator <- obj .: "numerator"
1591+ denominator <- obj .: "denominator"
1592+ if denominator == 0
1593+ then fail "Ratio denominator was 0"
1110− <*> obj .: "denominator"
1594+ else pure $ numerator % denominator
1111− {-# INLINE parseJSON #-}
1595+ {-# INLINE parseJSON #-}
1113−-- | /WARNING:/ Only parse fixed-precision numbers from trusted input
1597+-- | This instance includes a bounds check to prevent maliciously
1114−-- since an attacker could easily fill up the memory of the target
1598+-- large inputs to fill up the memory of the target system. You can
1115−-- system by specifying a scientific number with a big exponent like
1599+-- newtype 'Scientific' and provide your own instance using
1116−-- @1e1000000000@.
1600+-- 'withScientific' if you want to allow larger inputs.
1117instance HasResolution a => FromJSON (Fixed a) where
1601instance HasResolution a => FromJSON (Fixed a) where
1118− parseJSON = withScientific "Fixed" $ pure . realToFrac
1602+ parseJSON = prependContext "Fixed" . withBoundedScientific' (pure . realToFrac)
1119 {-# INLINE parseJSON #-}
1603 {-# INLINE parseJSON #-}
1121instance FromJSON Int where
1605instance FromJSON Int where
1122− parseJSON = parseIntegral "Int"
1606+ parseJSON = parseBoundedIntegral "Int"
1123 {-# INLINE parseJSON #-}
1607 {-# INLINE parseJSON #-}
1125instance FromJSONKey Int where
1609instance FromJSONKey Int where
1126− fromJSONKey = FromJSONKeyTextParser parseIntegralText
1610+ fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Int"
1128−-- | /WARNING:/ Only parse Integers from trusted input since an
1612+-- | This instance includes a bounds check to prevent maliciously
1129−-- attacker could easily fill up the memory of the target system by
1613+-- large inputs to fill up the memory of the target system. You can
1130−-- specifying a scientific number with a big exponent like
1614+-- newtype 'Scientific' and provide your own instance using
1131−-- @1e1000000000@.
1615+-- 'withScientific' if you want to allow larger inputs.
1132instance FromJSON Integer where
1616instance FromJSON Integer where
1133− parseJSON = withScientific "Integral" $ pure . truncate
1617+ parseJSON = parseIntegral "Integer"
1134 {-# INLINE parseJSON #-}
1618 {-# INLINE parseJSON #-}
1136instance FromJSONKey Integer where
1620instance FromJSONKey Integer where
1137− fromJSONKey = FromJSONKeyTextParser parseIntegralText
1621+ fromJSONKey = FromJSONKeyTextParser $ parseIntegralText "Integer"
1139instance FromJSON Natural where
1623instance FromJSON Natural where
1140− parseJSON = withScientific "Natural" $ \s ->
1624+ parseJSON value = do
1141− if Scientific.coefficient s < 0
1625+ integer <- parseIntegral "Natural" value
1142− then fail $ "Expected a Natural number but got the negative number: " <> show s
1626+ parseNatural integer
1143− else pure $ truncate s
1145instance FromJSONKey Natural where
1628instance FromJSONKey Natural where
1146− fromJSONKey = FromJSONKeyTextParser $ \t -> parseScientificText t >>= \s ->
1629+ fromJSONKey = FromJSONKeyTextParser $ \text -> do
1147− if Scientific.coefficient s < 0
1630+ integer <- parseIntegralText "Natural" text
1631+ parseNatural integer
1633+parseNatural :: Integer -> Parser Natural
1634+parseNatural integer =
1635+ if integer < 0 then
1148− then fail $ "Expected a Natural number but got the negative number: " <> show s
1636+ fail $ "parsing Natural failed, unexpected negative number " <> show integer
1149− else pure $ truncate s
1637+ else
1638+ pure $ fromIntegral integer
1151instance FromJSON Int8 where
1640instance FromJSON Int8 where
1152− parseJSON = parseIntegral "Int8"
1641+ parseJSON = parseBoundedIntegral "Int8"
1153 {-# INLINE parseJSON #-}
1642 {-# INLINE parseJSON #-}
1155instance FromJSONKey Int8 where
1644instance FromJSONKey Int8 where
1156− fromJSONKey = FromJSONKeyTextParser parseIntegralText
1645+ fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Int8"
1158instance FromJSON Int16 where
1647instance FromJSON Int16 where
1159− parseJSON = parseIntegral "Int16"
1648+ parseJSON = parseBoundedIntegral "Int16"
1160 {-# INLINE parseJSON #-}
1649 {-# INLINE parseJSON #-}
1162instance FromJSONKey Int16 where
1651instance FromJSONKey Int16 where
1163− fromJSONKey = FromJSONKeyTextParser parseIntegralText
1652+ fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Int16"
1165instance FromJSON Int32 where
1654instance FromJSON Int32 where
1166− parseJSON = parseIntegral "Int32"
1655+ parseJSON = parseBoundedIntegral "Int32"
1167 {-# INLINE parseJSON #-}
1656 {-# INLINE parseJSON #-}
1169instance FromJSONKey Int32 where
1658instance FromJSONKey Int32 where
1170− fromJSONKey = FromJSONKeyTextParser parseIntegralText
1659+ fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Int32"
1172instance FromJSON Int64 where
1661instance FromJSON Int64 where
1173− parseJSON = parseIntegral "Int64"
1662+ parseJSON = parseBoundedIntegral "Int64"
1174 {-# INLINE parseJSON #-}
1663 {-# INLINE parseJSON #-}
1176instance FromJSONKey Int64 where
1665instance FromJSONKey Int64 where
1177− fromJSONKey = FromJSONKeyTextParser parseIntegralText
1666+ fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Int64"
1179instance FromJSON Word where
1668instance FromJSON Word where
1180− parseJSON = parseIntegral "Word"
1669+ parseJSON = parseBoundedIntegral "Word"
1181 {-# INLINE parseJSON #-}
1670 {-# INLINE parseJSON #-}
1183instance FromJSONKey Word where
1672instance FromJSONKey Word where
1184− fromJSONKey = FromJSONKeyTextParser parseIntegralText
1673+ fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Word"
1186instance FromJSON Word8 where
1675instance FromJSON Word8 where
1187− parseJSON = parseIntegral "Word8"
1676+ parseJSON = parseBoundedIntegral "Word8"
1188 {-# INLINE parseJSON #-}
1677 {-# INLINE parseJSON #-}
1190instance FromJSONKey Word8 where
1679instance FromJSONKey Word8 where
1191− fromJSONKey = FromJSONKeyTextParser parseIntegralText
1680+ fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Word8"
1193instance FromJSON Word16 where
1682instance FromJSON Word16 where
1194− parseJSON = parseIntegral "Word16"
1683+ parseJSON = parseBoundedIntegral "Word16"
1195 {-# INLINE parseJSON #-}
1684 {-# INLINE parseJSON #-}
1197instance FromJSONKey Word16 where
1686instance FromJSONKey Word16 where
1198− fromJSONKey = FromJSONKeyTextParser parseIntegralText
1687+ fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Word16"
1200instance FromJSON Word32 where
1689instance FromJSON Word32 where
1201− parseJSON = parseIntegral "Word32"
1690+ parseJSON = parseBoundedIntegral "Word32"
1202 {-# INLINE parseJSON #-}
1691 {-# INLINE parseJSON #-}
1204instance FromJSONKey Word32 where
1693instance FromJSONKey Word32 where
1205− fromJSONKey = FromJSONKeyTextParser parseIntegralText
1694+ fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Word32"
1207instance FromJSON Word64 where
1696instance FromJSON Word64 where
1208− parseJSON = parseIntegral "Word64"
1697+ parseJSON = parseBoundedIntegral "Word64"
1209 {-# INLINE parseJSON #-}
1698 {-# INLINE parseJSON #-}
1211instance FromJSONKey Word64 where
1700instance FromJSONKey Word64 where
1212− fromJSONKey = FromJSONKeyTextParser parseIntegralText
1701+ fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Word64"
1703+instance FromJSON CTime where
1704+ parseJSON = fmap CTime . parseJSON
1705+ {-# INLINE parseJSON #-}
1215instance FromJSON Text where
1707instance FromJSON Text where
1216 parseJSON = withText "Text" pure
1708 parseJSON = withText "Text" pure
@@ -1240,17 +1732,17 @@ parseVersionText = go . readP_to_S parseVersion . unpack
1241 go [(v,[])] = return v
1733 go [(v,[])] = return v
1242 go (_ : xs) = go xs
1734 go (_ : xs) = go xs
1243− go _ = fail $ "could not parse Version"
1735+ go _ = fail "parsing Version failed"
1245-------------------------------------------------------------------------------
1737-------------------------------------------------------------------------------
1246-- semigroups NonEmpty
1738-- semigroups NonEmpty
1247-------------------------------------------------------------------------------
1739-------------------------------------------------------------------------------
1249instance FromJSON1 NonEmpty where
1741instance FromJSON1 NonEmpty where
1250− liftParseJSON p _ = withArray "NonEmpty a" $
1742+ liftParseJSON p _ = withArray "NonEmpty" $
1251 (>>= ne) . Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
1743 (>>= ne) . Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
1253− ne [] = fail "Expected a NonEmpty but got an empty list"
1745+ ne [] = fail "parsing NonEmpty failed, unexpected empty list"
1254 ne (x:xs) = pure (x :| xs)
1746 ne (x:xs) = pure (x :| xs)
1255 {-# INLINE liftParseJSON #-}
1747 {-# INLINE liftParseJSON #-}
@@ -1271,7 +1763,7 @@ instance FromJSON Scientific where
1271-------------------------------------------------------------------------------
1763-------------------------------------------------------------------------------
1273instance FromJSON1 DList.DList where
1765instance FromJSON1 DList.DList where
1274− liftParseJSON p _ = withArray "DList a" $
1766+ liftParseJSON p _ = withArray "DList" $
1275 fmap DList.fromList .
1767 fmap DList.fromList .
1276 Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
1768 Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
1277 {-# INLINE liftParseJSON #-}
1769 {-# INLINE liftParseJSON #-}
@@ -1298,7 +1790,7 @@ instance (FromJSON a) => FromJSON (Identity a) where
1298 parseJSONList = liftParseJSONList parseJSON parseJSONList
1790 parseJSONList = liftParseJSONList parseJSON parseJSONList
1299 {-# INLINE parseJSONList #-}
1791 {-# INLINE parseJSONList #-}
1301−instance (FromJSONKey a, FromJSON a) => FromJSONKey (Identity a) where
1793+instance (FromJSONKey a) => FromJSONKey (Identity a) where
1302 fromJSONKey = coerceFromJSONKeyFunction (fromJSONKey :: FromJSONKeyFunction a)
1794 fromJSONKey = coerceFromJSONKeyFunction (fromJSONKey :: FromJSONKeyFunction a)
1303 fromJSONKeyList = coerceFromJSONKeyFunction (fromJSONKeyList :: FromJSONKeyFunction [a])
1795 fromJSONKeyList = coerceFromJSONKeyFunction (fromJSONKeyList :: FromJSONKeyFunction [a])
@@ -1348,7 +1840,7 @@ instance (FromJSON1 f, FromJSON1 g) => FromJSON1 (Sum f g) where
1348 inr = "InR"
1840 inr = "InR"
1350 liftParseJSON _ _ _ = fail $
1842 liftParseJSON _ _ _ = fail $
1351− "expected an object with a single property " ++
1843+ "parsing Sum failed, expected an object with a single property " ++
1352 "where the property key should be either " ++
1844 "where the property key should be either " ++
1353 "\"InL\" or \"InR\""
1845 "\"InL\" or \"InR\""
1354 {-# INLINE liftParseJSON #-}
1846 {-# INLINE liftParseJSON #-}
@@ -1362,7 +1854,7 @@ instance (FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Sum f g a) where
1362-------------------------------------------------------------------------------
1854-------------------------------------------------------------------------------
1364instance FromJSON1 Seq.Seq where
1856instance FromJSON1 Seq.Seq where
1365− liftParseJSON p _ = withArray "Seq a" $
1857+ liftParseJSON p _ = withArray "Seq" $
1366 fmap Seq.fromList .
1858 fmap Seq.fromList .
1367 Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
1859 Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
1368 {-# INLINE liftParseJSON #-}
1860 {-# INLINE liftParseJSON #-}
@@ -1396,15 +1888,15 @@ instance FromJSON a => FromJSON (IntMap.IntMap a) where
1397instance (FromJSONKey k, Ord k) => FromJSON1 (M.Map k) where
1889instance (FromJSONKey k, Ord k) => FromJSON1 (M.Map k) where
1398 liftParseJSON p _ = case fromJSONKey of
1890 liftParseJSON p _ = case fromJSONKey of
1399− FromJSONKeyCoerce _-> withObject "Map k v" $
1891+ FromJSONKeyCoerce _ -> withObject "Map" $
1400 fmap (H.foldrWithKey (M.insert . unsafeCoerce) M.empty) . H.traverseWithKey (\k v -> p v <?> Key k)
1892 fmap (H.foldrWithKey (M.insert . unsafeCoerce) M.empty) . H.traverseWithKey (\k v -> p v <?> Key k)
1401− FromJSONKeyText f -> withObject "Map k v" $
1893+ FromJSONKeyText f -> withObject "Map" $
1402 fmap (H.foldrWithKey (M.insert . f) M.empty) . H.traverseWithKey (\k v -> p v <?> Key k)
1894 fmap (H.foldrWithKey (M.insert . f) M.empty) . H.traverseWithKey (\k v -> p v <?> Key k)
1403− FromJSONKeyTextParser f -> withObject "Map k v" $
1895+ FromJSONKeyTextParser f -> withObject "Map" $
1404 H.foldrWithKey (\k v m -> M.insert <$> f k <?> Key k <*> p v <?> Key k <*> m) (pure M.empty)
1896 H.foldrWithKey (\k v m -> M.insert <$> f k <?> Key k <*> p v <?> Key k <*> m) (pure M.empty)
1405− FromJSONKeyValue f -> withArray "Map k v" $ \arr ->
1897+ FromJSONKeyValue f -> withArray "Map" $ \arr ->
1406− M.fromList <$> (Tr.sequence .
1898+ fmap M.fromList . Tr.sequence .
1407− zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr)
1899+ zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr
1408 {-# INLINE liftParseJSON #-}
1900 {-# INLINE liftParseJSON #-}
1410instance (FromJSONKey k, Ord k, FromJSON v) => FromJSON (M.Map k v) where
1902instance (FromJSONKey k, Ord k, FromJSON v) => FromJSON (M.Map k v) where
@@ -1424,12 +1916,24 @@ instance (FromJSON v) => FromJSON (Tree.Tree v) where
1424 parseJSON = parseJSON1
1916 parseJSON = parseJSON1
1425 {-# INLINE parseJSON #-}
1917 {-# INLINE parseJSON #-}
1919+-------------------------------------------------------------------------------
1921+-------------------------------------------------------------------------------
1923+instance FromJSON UUID.UUID where
1924+ parseJSON = withText "UUID" $
1925+ maybe (fail "invalid UUID") pure . UUID.fromText
1927+instance FromJSONKey UUID.UUID where
1928+ fromJSONKey = FromJSONKeyTextParser $
1929+ maybe (fail "invalid UUID") pure . UUID.fromText
1427-------------------------------------------------------------------------------
1931-------------------------------------------------------------------------------
1428-- vector
1932-- vector
1429-------------------------------------------------------------------------------
1933-------------------------------------------------------------------------------
1431instance FromJSON1 Vector where
1935instance FromJSON1 Vector where
1432− liftParseJSON p _ = withArray "Vector a" $
1936+ liftParseJSON p _ = withArray "Vector" $
1433 V.mapM (uncurry $ parseIndexedJSON p) . V.indexed
1937 V.mapM (uncurry $ parseIndexedJSON p) . V.indexed
1434 {-# INLINE liftParseJSON #-}
1938 {-# INLINE liftParseJSON #-}
@@ -1443,14 +1947,14 @@ vectorParseJSON s = withArray s $ fmap V.convert . V.mapM (uncurry $ parseIndexe
1443{-# INLINE vectorParseJSON #-}
1947{-# INLINE vectorParseJSON #-}
1445instance (Storable a, FromJSON a) => FromJSON (VS.Vector a) where
1949instance (Storable a, FromJSON a) => FromJSON (VS.Vector a) where
1446− parseJSON = vectorParseJSON "Data.Vector.Storable.Vector a"
1950+ parseJSON = vectorParseJSON "Data.Vector.Storable.Vector"
1448instance (VP.Prim a, FromJSON a) => FromJSON (VP.Vector a) where
1952instance (VP.Prim a, FromJSON a) => FromJSON (VP.Vector a) where
1449− parseJSON = vectorParseJSON "Data.Vector.Primitive.Vector a"
1953+ parseJSON = vectorParseJSON "Data.Vector.Primitive.Vector"
1450 {-# INLINE parseJSON #-}
1954 {-# INLINE parseJSON #-}
1452instance (VG.Vector VU.Vector a, FromJSON a) => FromJSON (VU.Vector a) where
1956instance (VG.Vector VU.Vector a, FromJSON a) => FromJSON (VU.Vector a) where
1453− parseJSON = vectorParseJSON "Data.Vector.Unboxed.Vector a"
1957+ parseJSON = vectorParseJSON "Data.Vector.Unboxed.Vector"
1454 {-# INLINE parseJSON #-}
1958 {-# INLINE parseJSON #-}
1456-------------------------------------------------------------------------------
1960-------------------------------------------------------------------------------
@@ -1464,15 +1968,15 @@ instance (Eq a, Hashable a, FromJSON a) => FromJSON (HashSet.HashSet a) where
1465instance (FromJSONKey k, Eq k, Hashable k) => FromJSON1 (H.HashMap k) where
1969instance (FromJSONKey k, Eq k, Hashable k) => FromJSON1 (H.HashMap k) where
1466 liftParseJSON p _ = case fromJSONKey of
1970 liftParseJSON p _ = case fromJSONKey of
1467− FromJSONKeyCoerce _ -> withObject "HashMap ~Text v" $
1971+ FromJSONKeyCoerce _ -> withObject "HashMap ~Text" $
1468 uc . H.traverseWithKey (\k v -> p v <?> Key k)
1972 uc . H.traverseWithKey (\k v -> p v <?> Key k)
1469− FromJSONKeyText f -> withObject "HashMap k v" $
1973+ FromJSONKeyText f -> withObject "HashMap" $
1470 fmap (mapKey f) . H.traverseWithKey (\k v -> p v <?> Key k)
1974 fmap (mapKey f) . H.traverseWithKey (\k v -> p v <?> Key k)
1471− FromJSONKeyTextParser f -> withObject "HashMap k v" $
1975+ FromJSONKeyTextParser f -> withObject "HashMap" $
1472 H.foldrWithKey (\k v m -> H.insert <$> f k <?> Key k <*> p v <?> Key k <*> m) (pure H.empty)
1976 H.foldrWithKey (\k v m -> H.insert <$> f k <?> Key k <*> p v <?> Key k <*> m) (pure H.empty)
1473− FromJSONKeyValue f -> withArray "Map k v" $ \arr ->
1977+ FromJSONKeyValue f -> withArray "Map" $ \arr ->
1474− H.fromList <$> (Tr.sequence .
1978+ fmap H.fromList . Tr.sequence .
1475− zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr)
1979+ zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr
1477 uc :: Parser (H.HashMap Text v) -> Parser (H.HashMap k v)
1981 uc :: Parser (H.HashMap Text v) -> Parser (H.HashMap k v)
1478 uc = unsafeCoerce
1982 uc = unsafeCoerce
@@ -1493,11 +1997,33 @@ instance FromJSON DotNetTime where
1493 parseJSON = withText "DotNetTime" $ \t ->
1997 parseJSON = withText "DotNetTime" $ \t ->
1494 let (s,m) = T.splitAt (T.length t - 5) t
1998 let (s,m) = T.splitAt (T.length t - 5) t
1495 t' = T.concat [s,".",m]
1999 t' = T.concat [s,".",m]
1496− in case parseTime defaultTimeLocale "/Date(%s%Q)/" (unpack t') of
2000+ in case parseTimeM True defaultTimeLocale "/Date(%s%Q)/" (unpack t') of
1497 Just d -> pure (DotNetTime d)
2001 Just d -> pure (DotNetTime d)
1498 _ -> fail "could not parse .NET time"
2002 _ -> fail "could not parse .NET time"
1499 {-# INLINE parseJSON #-}
2003 {-# INLINE parseJSON #-}
2005+-------------------------------------------------------------------------------
2007+-------------------------------------------------------------------------------
2009+instance FromJSON a => FromJSON (PM.Array a) where
2010+ -- note: we could do better than this if vector exposed the data
2011+ -- constructor in Data.Vector.
2012+ parseJSON = fmap Exts.fromList . parseJSON
2014+instance FromJSON a => FromJSON (PM.SmallArray a) where
2015+ parseJSON = fmap Exts.fromList . parseJSON
2017+#if MIN_VERSION_primitive(0,6,4)
2018+instance (PM.Prim a,FromJSON a) => FromJSON (PM.PrimArray a) where
2019+ parseJSON = fmap Exts.fromList . parseJSON
2021+#if !MIN_VERSION_primitive(0,7,0)
2022+instance (PM.PrimUnlifted a,FromJSON a) => FromJSON (PM.UnliftedArray a) where
2023+ parseJSON = fmap Exts.fromList . parseJSON
1501-------------------------------------------------------------------------------
2027-------------------------------------------------------------------------------
1503-------------------------------------------------------------------------------
2029-------------------------------------------------------------------------------
@@ -1523,6 +2049,17 @@ instance FromJSONKey LocalTime where
1523 fromJSONKey = FromJSONKeyTextParser (Time.run Time.localTime)
2049 fromJSONKey = FromJSONKeyTextParser (Time.run Time.localTime)
2052+-- | Supported string formats:
2054+-- @YYYY-MM-DD HH:MM Z@
2055+-- @YYYY-MM-DD HH:MM:SS Z@
2056+-- @YYYY-MM-DD HH:MM:SS.SSS Z@
2058+-- The first space may instead be a @T@, and the second space is
2059+-- optional. The @Z@ represents UTC. The @Z@ may be replaced with a
2060+-- time zone offset of the form @+0000@ or @-08:00@, where the first
2061+-- two digits are hours, the @:@ is optional and the second two digits
2062+-- (also optional) are minutes.
1526instance FromJSON ZonedTime where
2063instance FromJSON ZonedTime where
1527 parseJSON = withText "ZonedTime" (Time.run Time.zonedTime)
2064 parseJSON = withText "ZonedTime" (Time.run Time.zonedTime)
@@ -1537,41 +2074,168 @@ instance FromJSONKey UTCTime where
1537 fromJSONKey = FromJSONKeyTextParser (Time.run Time.utcTime)
2074 fromJSONKey = FromJSONKeyTextParser (Time.run Time.utcTime)
1540−-- | /WARNING:/ Only parse lengths of time from trusted input
2077+-- | This instance includes a bounds check to prevent maliciously
1541−-- since an attacker could easily fill up the memory of the target
2078+-- large inputs to fill up the memory of the target system. You can
1542−-- system by specifying a scientific number with a big exponent like
2079+-- newtype 'Scientific' and provide your own instance using
1543−-- @1e1000000000@.
2080+-- 'withScientific' if you want to allow larger inputs.
1544instance FromJSON NominalDiffTime where
2081instance FromJSON NominalDiffTime where
1545− parseJSON = withScientific "NominalDiffTime" $ pure . realToFrac
2082+ parseJSON = withBoundedScientific "NominalDiffTime" $ pure . realToFrac
2083+ {-# INLINE parseJSON #-}
2086+-- | This instance includes a bounds check to prevent maliciously
2087+-- large inputs to fill up the memory of the target system. You can
2088+-- newtype 'Scientific' and provide your own instance using
2089+-- 'withScientific' if you want to allow larger inputs.
2090+instance FromJSON DiffTime where
2091+ parseJSON = withBoundedScientific "DiffTime" $ pure . realToFrac
1546 {-# INLINE parseJSON #-}
2092 {-# INLINE parseJSON #-}
2094+instance FromJSON SystemTime where
2095+ parseJSON v = prependContext "SystemTime" $ do
2097+ let n' = floor (n * fromInteger (resolution n) :: Nano)
2098+ let (secs, nano) = n' `divMod` resolution n
2099+ return (MkSystemTime (fromInteger secs) (fromInteger nano))
2101+instance FromJSON CalendarDiffTime where
2102+ parseJSON = withObject "CalendarDiffTime" $ \obj -> CalendarDiffTime
2103+ <$> obj .: "months"
2106+instance FromJSON CalendarDiffDays where
2107+ parseJSON = withObject "CalendarDiffDays" $ \obj -> CalendarDiffDays
2108+ <$> obj .: "months"
2111+instance FromJSON DayOfWeek where
2112+ parseJSON = withText "DaysOfWeek" parseDayOfWeek
2114+parseDayOfWeek :: T.Text -> Parser DayOfWeek
2115+parseDayOfWeek t = case T.toLower t of
2116+ "monday" -> return Monday
2117+ "tuesday" -> return Tuesday
2118+ "wednesday" -> return Wednesday
2119+ "thursday" -> return Thursday
2120+ "friday" -> return Friday
2121+ "saturday" -> return Saturday
2122+ "sunday" -> return Sunday
2123+ _ -> fail "Invalid week day"
2125+instance FromJSONKey DayOfWeek where
2126+ fromJSONKey = FromJSONKeyTextParser parseDayOfWeek
1548-------------------------------------------------------------------------------
2128-------------------------------------------------------------------------------
1549-- base Monoid/Semigroup
2129-- base Monoid/Semigroup
1550-------------------------------------------------------------------------------
2130-------------------------------------------------------------------------------
1552−instance FromJSON1 Dual where
2132+instance FromJSON1 Monoid.Dual where
1553− liftParseJSON p _ = fmap Dual . p
2133+ liftParseJSON p _ = fmap Monoid.Dual . p
2134+ {-# INLINE liftParseJSON #-}
2136+instance FromJSON a => FromJSON (Monoid.Dual a) where
2137+ parseJSON = parseJSON1
2138+ {-# INLINE parseJSON #-}
2141+instance FromJSON1 Monoid.First where
2142+ liftParseJSON p p' = fmap Monoid.First . liftParseJSON p p'
2143+ {-# INLINE liftParseJSON #-}
2145+instance FromJSON a => FromJSON (Monoid.First a) where
2146+ parseJSON = parseJSON1
2147+ {-# INLINE parseJSON #-}
2150+instance FromJSON1 Monoid.Last where
2151+ liftParseJSON p p' = fmap Monoid.Last . liftParseJSON p p'
2152+ {-# INLINE liftParseJSON #-}
2154+instance FromJSON a => FromJSON (Monoid.Last a) where
2155+ parseJSON = parseJSON1
2156+ {-# INLINE parseJSON #-}
2159+instance FromJSON1 Semigroup.Min where
2160+ liftParseJSON p _ a = Semigroup.Min <$> p a
1554 {-# INLINE liftParseJSON #-}
2161 {-# INLINE liftParseJSON #-}
2163+ liftParseJSONList _ p a = fmap Semigroup.Min <$> p a
2164+ {-# INLINE liftParseJSONList #-}
1556−instance FromJSON a => FromJSON (Dual a) where
2166+instance (FromJSON a) => FromJSON (Semigroup.Min a) where
1557 parseJSON = parseJSON1
2167 parseJSON = parseJSON1
1558 {-# INLINE parseJSON #-}
2168 {-# INLINE parseJSON #-}
2170+ parseJSONList = liftParseJSONList parseJSON parseJSONList
2171+ {-# INLINE parseJSONList #-}
1561−instance FromJSON1 First where
2174+instance FromJSON1 Semigroup.Max where
1562− liftParseJSON p p' = fmap First . liftParseJSON p p'
2175+ liftParseJSON p _ a = Semigroup.Max <$> p a
1563 {-# INLINE liftParseJSON #-}
2176 {-# INLINE liftParseJSON #-}
2178+ liftParseJSONList _ p a = fmap Semigroup.Max <$> p a
2179+ {-# INLINE liftParseJSONList #-}
1565−instance FromJSON a => FromJSON (First a) where
2181+instance (FromJSON a) => FromJSON (Semigroup.Max a) where
1566 parseJSON = parseJSON1
2182 parseJSON = parseJSON1
1567 {-# INLINE parseJSON #-}
2183 {-# INLINE parseJSON #-}
2185+ parseJSONList = liftParseJSONList parseJSON parseJSONList
2186+ {-# INLINE parseJSONList #-}
1570−instance FromJSON1 Last where
2189+instance FromJSON1 Semigroup.First where
1571− liftParseJSON p p' = fmap Last . liftParseJSON p p'
2190+ liftParseJSON p _ a = Semigroup.First <$> p a
1572 {-# INLINE liftParseJSON #-}
2191 {-# INLINE liftParseJSON #-}
2193+ liftParseJSONList _ p a = fmap Semigroup.First <$> p a
2194+ {-# INLINE liftParseJSONList #-}
1574−instance FromJSON a => FromJSON (Last a) where
2196+instance (FromJSON a) => FromJSON (Semigroup.First a) where
2197+ parseJSON = parseJSON1
2198+ {-# INLINE parseJSON #-}
2200+ parseJSONList = liftParseJSONList parseJSON parseJSONList
2201+ {-# INLINE parseJSONList #-}
2204+instance FromJSON1 Semigroup.Last where
2205+ liftParseJSON p _ a = Semigroup.Last <$> p a
2206+ {-# INLINE liftParseJSON #-}
2208+ liftParseJSONList _ p a = fmap Semigroup.Last <$> p a
2209+ {-# INLINE liftParseJSONList #-}
2211+instance (FromJSON a) => FromJSON (Semigroup.Last a) where
2212+ parseJSON = parseJSON1
2213+ {-# INLINE parseJSON #-}
2215+ parseJSONList = liftParseJSONList parseJSON parseJSONList
2216+ {-# INLINE parseJSONList #-}
2219+instance FromJSON1 Semigroup.WrappedMonoid where
2220+ liftParseJSON p _ a = Semigroup.WrapMonoid <$> p a
2221+ {-# INLINE liftParseJSON #-}
2223+ liftParseJSONList _ p a = fmap Semigroup.WrapMonoid <$> p a
2224+ {-# INLINE liftParseJSONList #-}
2226+instance (FromJSON a) => FromJSON (Semigroup.WrappedMonoid a) where
2227+ parseJSON = parseJSON1
2228+ {-# INLINE parseJSON #-}
2230+ parseJSONList = liftParseJSONList parseJSON parseJSONList
2231+ {-# INLINE parseJSONList #-}
2234+instance FromJSON1 Semigroup.Option where
2235+ liftParseJSON p p' = fmap Semigroup.Option . liftParseJSON p p'
2236+ {-# INLINE liftParseJSON #-}
2238+instance FromJSON a => FromJSON (Semigroup.Option a) where
1575 parseJSON = parseJSON1
2239 parseJSON = parseJSON1
1576 {-# INLINE parseJSON #-}
2240 {-# INLINE parseJSON #-}
@@ -1579,11 +2243,21 @@ instance FromJSON a => FromJSON (Last a) where
1579-- tagged
2243-- tagged
1580-------------------------------------------------------------------------------
2244-------------------------------------------------------------------------------
2246+instance FromJSON1 Proxy where
2247+ {-# INLINE liftParseJSON #-}
2248+ liftParseJSON _ _ = fromNull "Proxy" Proxy
1582instance FromJSON (Proxy a) where
2250instance FromJSON (Proxy a) where
1583 {-# INLINE parseJSON #-}
2251 {-# INLINE parseJSON #-}
1584− parseJSON Null = pure Proxy
2252+ parseJSON = fromNull "Proxy" Proxy
1585− parseJSON v = typeMismatch "Proxy" v
2254+fromNull :: String -> a -> Value -> Parser a
2255+fromNull _ a Null = pure a
2256+fromNull c _ v = prependContext c (typeMismatch "Null" v)
2258+instance FromJSON2 Tagged where
2259+ liftParseJSON2 _ _ p _ = fmap Tagged . p
2260+ {-# INLINE liftParseJSON2 #-}
1588instance FromJSON1 (Tagged a) where
2262instance FromJSON1 (Tagged a) where
1589 liftParseJSON p _ = fmap Tagged . p
2263 liftParseJSON p _ = fmap Tagged . p
@@ -1606,10 +2280,7 @@ instance (FromJSON a, FromJSON b, FromJSON c) => FromJSONKey (a,b,c)
1606instance (FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSONKey (a,b,c,d)
2280instance (FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSONKey (a,b,c,d)
1608instance FromJSONKey Char where
2282instance FromJSONKey Char where
1609− fromJSONKey = FromJSONKeyTextParser $ \t ->
2283+ fromJSONKey = FromJSONKeyTextParser parseChar
1611− then return (T.index t 0)
1612− else typeMismatch "Expected Char but String didn't contain exactly one character" (String t)
1613 fromJSONKeyList = FromJSONKeyText T.unpack
2284 fromJSONKeyList = FromJSONKeyText T.unpack
1615instance (FromJSONKey a, FromJSON a) => FromJSONKey [a] where
2286instance (FromJSONKey a, FromJSON a) => FromJSONKey [a] where
@@ -1619,7 +2290,7 @@ instance (FromJSONKey a, FromJSON a) => FromJSONKey [a] where
1619-- Tuple instances, see tuple-instances-from.hs
2290-- Tuple instances, see tuple-instances-from.hs
1620-------------------------------------------------------------------------------
2291-------------------------------------------------------------------------------
1622−instance FromJSON2 ((,) ) where
2293+instance FromJSON2 (,) where
1623 liftParseJSON2 pA _ pB _ = withArray "(a, b)" $ \t ->
2294 liftParseJSON2 pA _ pB _ = withArray "(a, b)" $ \t ->
1624 let n = V.length t
2295 let n = V.length t
1625 in if n == 2
2296 in if n == 2