@@ -1,28 +1,29 @@
1−{-# LANGUAGE CPP #-}
2−{-# LANGUAGE DataKinds #-}
3−{-# LANGUAGE DefaultSignatures #-}
4−{-# LANGUAGE FlexibleContexts #-}
5−{-# LANGUAGE FlexibleInstances #-}
6−{-# LANGUAGE GADTs #-}
1+{-# LANGUAGE CPP #-}
2+{-# LANGUAGE DataKinds #-}
3+{-# LANGUAGE DefaultSignatures #-}
4+{-# LANGUAGE FlexibleContexts #-}
5+{-# LANGUAGE FlexibleInstances #-}
6+{-# LANGUAGE GADTs #-}
77{-# LANGUAGE MultiParamTypeClasses #-}
8−{-# LANGUAGE NoImplicitPrelude #-}
9−{-# LANGUAGE OverloadedStrings #-}
10−{-# LANGUAGE PolyKinds #-}
11−{-# LANGUAGE RecordWildCards #-}
12−{-# LANGUAGE ScopedTypeVariables #-}
13−{-# LANGUAGE TypeOperators #-}
14−{-# LANGUAGE TupleSections #-}
15−{-# LANGUAGE UndecidableInstances #-}
16−{-# LANGUAGE ViewPatterns #-}
17−
18−#include "incoherent-compat.h"
8+{-# LANGUAGE NamedFieldPuns #-}
9+{-# LANGUAGE OverloadedStrings #-}
10+{-# LANGUAGE RecordWildCards #-}
11+{-# LANGUAGE ScopedTypeVariables #-}
12+{-# LANGUAGE TypeOperators #-}
13+{-# LANGUAGE TypeSynonymInstances #-}
14+{-# LANGUAGE UndecidableInstances #-}
15+{-# LANGUAGE ViewPatterns #-}
16+
17+#if __GLASGOW_HASKELL__ >= 706
18+{-# LANGUAGE PolyKinds #-}
19+#endif
20+
1921#include "overlapping-compat.h"
2022
2123-- TODO: Drop this when we remove support for Data.Attoparsec.Number
2224{-# OPTIONS_GHC -fno-warn-deprecations #-}
2325
24−module Data.Aeson.Types.FromJSON
25− (
26+module Data.Aeson.Types.FromJSON (
2627 -- * Core JSON classes
2728 FromJSON(..)
2829 -- * Liftings to unary and binary type constructors
@@ -32,7 +33,6 @@ module Data.Aeson.Types.FromJSON
3233 , parseJSON2
3334 -- * Generic JSON classes
3435 , GFromJSON(..)
35− , FromArgs(..)
3636 , genericParseJSON
3737 , genericLiftParseJSON
3838 -- * Classes and types for map keys
@@ -42,121 +42,103 @@ module Data.Aeson.Types.FromJSON
4242 , coerceFromJSONKeyFunction
4343 , mapFromJSONKeyFunction
4444
45− , GFromJSONKey()
46− , genericFromJSONKey
47−
4845 -- * List functions
4946 , listParser
5047
51− -- * Inspecting @'Value's@
48+ -- * Inspecting @'Value's@
5249 , withObject
5350 , withText
5451 , withArray
52+ , withNumber
5553 , withScientific
5654 , withBool
57− , withEmbeddedJSON
5855
5956 -- * Functions
6057 , fromJSON
6158 , ifromJSON
62− , typeMismatch
63− , unexpected
64− , parseField
65− , parseFieldMaybe
66− , parseFieldMaybe'
67− , explicitParseField
68− , explicitParseFieldMaybe
69− , explicitParseFieldMaybe'
70− , parseIndexedJSON
71− -- ** Operators
7259 , (.:)
7360 , (.:?)
7461 , (.:!)
7562 , (.!=)
63+ , typeMismatch
7664
7765 -- * Internal
7866 , parseOptionalFieldWith
7967 ) where
8068
81−import Prelude.Compat
69+import Prelude ()
70+import Prelude.Compat hiding (foldr)
8271
83−import Control.Applicative ((<|>), Const(..), liftA2)
84−import Control.Monad (zipWithM)
8572import Data.Aeson.Internal.Functions (mapKey)
86−import Data.Aeson.Parser.Internal (eitherDecodeWith, jsonEOF)
8773import Data.Aeson.Types.Generic
8874import Data.Aeson.Types.Internal
89−import Data.Bits (unsafeShiftR)
90−import Data.Fixed (Fixed, HasResolution (resolution), Nano)
91−import Data.Functor.Compose (Compose(..))
92−import Data.Functor.Identity (Identity(..))
93−import Data.Functor.Product (Product(..))
94−import Data.Functor.Sum (Sum(..))
95−import Data.Hashable (Hashable(..))
96−import Data.Int (Int16, Int32, Int64, Int8)
97−import Data.List.NonEmpty (NonEmpty(..))
98−import Data.Maybe (fromMaybe)
99−import Data.Semigroup ((<>))
100−import Data.Proxy (Proxy(..))
101−import Data.Ratio ((%), Ratio)
102−import Data.Scientific (Scientific, base10Exponent)
103−import Data.Tagged (Tagged(..))
104−import Data.Text (Text, pack, unpack)
105−import Data.Time (Day, DiffTime, LocalTime, NominalDiffTime, TimeOfDay, UTCTime, ZonedTime)
106−import Data.Time.Calendar.Compat (CalendarDiffDays (..), DayOfWeek (..))
107−import Data.Time.LocalTime.Compat (CalendarDiffTime (..))
108−import Data.Time.Clock.System.Compat (SystemTime (..))
109−import Data.Time.Format.Compat (parseTimeM, defaultTimeLocale)
110−import Data.Traversable as Tr (sequence)
111−import Data.Vector (Vector)
112−import Data.Version (Version, parseVersion)
113−import Data.Void (Void)
114−import Data.Word (Word16, Word32, Word64, Word8)
115−import Foreign.Storable (Storable)
116−import Foreign.C.Types (CTime (..))
75+
76+import qualified Data.Aeson.Parser.Time as Time
77+import qualified Data.Attoparsec.ByteString.Char8 as A (endOfInput, parseOnly,
78+ scientific)
79+
80+import Control.Applicative (Const (..), (<|>))
81+import Control.Monad ((<=<))
82+import Data.Attoparsec.Number (Number (..))
83+import Data.Bits (unsafeShiftR)
84+import Data.Fixed (Fixed, HasResolution)
85+import Data.Functor.Identity (Identity (..))
86+import Data.Hashable (Hashable (..))
87+import Data.Int (Int16, Int32, Int64, Int8)
88+import Data.List.NonEmpty (NonEmpty (..))
89+import Data.Maybe (fromMaybe)
90+import Data.Monoid (Dual (..), First (..), Last (..), (<>))
91+import Data.Proxy (Proxy (..))
92+import Data.Ratio (Ratio, (%))
93+import Data.Scientific (Scientific)
94+import Data.Tagged (Tagged (..))
95+import Data.Text (Text, pack, unpack)
96+import Data.Time (Day, LocalTime, NominalDiffTime, TimeOfDay,
97+ UTCTime, ZonedTime)
98+import Data.Time.Format (parseTime)
99+import Data.Time.Locale.Compat (defaultTimeLocale)
100+import Data.Traversable as Tr (sequence)
101+import Data.Vector (Vector)
102+import Data.Version (Version, parseVersion)
103+import Data.Word (Word16, Word32, Word64, Word8)
104+import Foreign.Storable (Storable)
117105import GHC.Generics
118−import Numeric.Natural (Natural)
106+import Numeric.Natural (Natural)
119107import Text.ParserCombinators.ReadP (readP_to_S)
120−import Unsafe.Coerce (unsafeCoerce)
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
125−import qualified Data.HashMap.Strict as H
126−import qualified Data.HashSet as HashSet
127−import qualified Data.IntMap as IntMap
128−import qualified Data.IntSet as IntSet
129−import qualified Data.Map as M
130−import qualified Data.Monoid as Monoid
131−import qualified Data.Scientific as Scientific
132−import qualified Data.Semigroup as Semigroup
133−import qualified Data.Sequence as Seq
134−import qualified Data.Set as Set
135−import qualified Data.Text as T
136−import qualified Data.Text.Encoding as T
137−import qualified Data.Text.Lazy as LT
138−import qualified Data.Tree as Tree
139−import qualified Data.UUID.Types as UUID
140−import qualified Data.Vector as V
141−import qualified Data.Vector.Generic as VG
108+
109+import qualified Data.DList as DList
110+import qualified Data.HashMap.Strict as H
111+import qualified Data.HashSet as HashSet
112+import qualified Data.IntMap as IntMap
113+import qualified Data.IntSet as IntSet
114+import qualified Data.Map as M
115+import qualified Data.Scientific as Scientific
116+import qualified Data.Sequence as Seq
117+import qualified Data.Set as Set
118+import qualified Data.Text as T
119+import qualified Data.Text.Encoding as T
120+import qualified Data.Text.Lazy as LT
121+import qualified Data.Tree as Tree
122+import qualified Data.Vector as V
123+import qualified Data.Vector.Generic as VG
142124import qualified Data.Vector.Primitive as VP
143−import qualified Data.Vector.Storable as VS
144−import qualified Data.Vector.Unboxed as VU
125+import qualified Data.Vector.Storable as VS
126+import qualified Data.Vector.Unboxed as VU
145127
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
128+import Unsafe.Coerce (unsafeCoerce)
150129
151−#if MIN_VERSION_primitive(0,6,4)
152−#if !MIN_VERSION_primitive(0,7,0)
153−import qualified Data.Primitive.UnliftedArray as PM
154−#endif
155−import qualified Data.Primitive.PrimArray as PM
130+#ifndef HAS_COERCIBLE
131+#define HAS_COERCIBLE (__GLASGOW_HASKELL__ >= 707)
156132#endif
157133
158−
134+#if HAS_COERCIBLE
159135import Data.Coerce (Coercible, coerce)
136+coerce' :: Coercible a b => a -> b
137+coerce' = coerce
138+#else
139+coerce' :: a -> b
140+coerce' = unsafeCoerce
141+#endif
160142
161143parseIndexedJSON :: (Value -> Parser a) -> Int -> Value -> Parser a
162144parseIndexedJSON p idx value = p value <?> Index idx
@@ -165,7 +147,7 @@ parseIndexedJSON p idx value = p value <?> Index idx
165147parseIndexedJSONPair :: (Value -> Parser a) -> (Value -> Parser b) -> Int -> Value -> Parser (a, b)
166148parseIndexedJSONPair keyParser valParser idx value = p value <?> Index idx
167149 where
168− p = withArray "(k, v)" $ \ab ->
150+ p = withArray "(k,v)" $ \ab ->
169151 let n = V.length ab
170152 in if n == 2
171153 then (,) <$> parseJSONElemAtIndex keyParser 0 ab
@@ -177,57 +159,33 @@ parseIndexedJSONPair keyParser valParser idx value = p value <?> Index idx
177159parseJSONElemAtIndex :: (Value -> Parser a) -> Int -> V.Vector Value -> Parser a
178160parseJSONElemAtIndex p idx ary = p (V.unsafeIndex ary idx) <?> Index idx
179161
162+scientificToNumber :: Scientific -> Number
163+scientificToNumber s
164+ | e < 0 = D $ Scientific.toRealFloat s
165+ | otherwise = I $ c * 10 ^ e
166+ where
167+ e = Scientific.base10Exponent s
168+ c = Scientific.coefficient s
169+{-# INLINE scientificToNumber #-}
170+
180171parseRealFloat :: RealFloat a => String -> Value -> Parser a
181−parseRealFloat _ (Number s) = pure $ Scientific.toRealFloat s
182−parseRealFloat _ Null = pure (0/0)
183−parseRealFloat name v = prependContext name (unexpected v)
172+parseRealFloat _ (Number s) = pure $ Scientific.toRealFloat s
173+parseRealFloat _ Null = pure (0/0)
174+parseRealFloat expected v = typeMismatch expected v
184175{-# INLINE parseRealFloat #-}
185176
186−parseIntegralFromScientific :: forall a. Integral a => Scientific -> Parser a
187−parseIntegralFromScientific s =
188− case Scientific.floatingOrInteger s :: Either Double a of
189− Right x -> pure x
190− Left _ -> fail $ "unexpected floating number " ++ show s
191−{-# INLINE parseIntegralFromScientific #-}
192−
193177parseIntegral :: Integral a => String -> Value -> Parser a
194−parseIntegral name =
195− prependContext name . withBoundedScientific' parseIntegralFromScientific
178+parseIntegral expected = withScientific expected $ pure . truncate
196179{-# INLINE parseIntegral #-}
197180
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)
201− pure
202− (Scientific.toBoundedInteger s)
203−{-# INLINE parseBoundedIntegralFromScientific #-}
204−
205−parseBoundedIntegral :: (Bounded a, Integral a) => String -> Value -> Parser a
206−parseBoundedIntegral name =
207− prependContext name . withScientific' parseBoundedIntegralFromScientific
208−{-# INLINE parseBoundedIntegral #-}
209−
210181parseScientificText :: Text -> Parser Scientific
211182parseScientificText
212183 = either fail pure
213184 . A.parseOnly (A.scientific <* A.endOfInput)
214185 . T.encodeUtf8
215186
216−parseIntegralText :: Integral a => String -> Text -> Parser a
217−parseIntegralText name t =
218− prependContext name $
219− parseScientificText t
220− >>= rejectLargeExponent
221− >>= parseIntegralFromScientific
222− where
223− rejectLargeExponent :: Scientific -> Parser Scientific
224− rejectLargeExponent s = withBoundedScientific' pure (Number s)
225−{-# INLINE parseIntegralText #-}
226−
227−parseBoundedIntegralText :: (Bounded a, Integral a) => String -> Text -> Parser a
228−parseBoundedIntegralText name t =
229− prependContext name $
230− parseScientificText t >>= parseBoundedIntegralFromScientific
187+parseIntegralText :: Integral a => Text -> Parser a
188+parseIntegralText t = truncate <$> parseScientificText t
231189
232190parseOptionalFieldWith :: (Value -> Parser (Maybe a))
233191 -> Object -> Text -> Parser (Maybe a)
@@ -246,21 +204,16 @@ class GFromJSON arity f where
246204 -- | This method (applied to 'defaultOptions') is used as the
247205 -- default generic implementation of 'parseJSON' (if the @arity@ is 'Zero')
248206 -- or 'liftParseJSON' (if the @arity@ is 'One').
249− gParseJSON :: Options -> FromArgs arity a -> Value -> Parser (f a)
250−
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
253−-- 'FromJSON1').
254−data FromArgs arity a where
255− NoFromArgs :: FromArgs Zero a
256− From1Args :: (Value -> Parser a) -> (Value -> Parser [a]) -> FromArgs One a
207+ gParseJSON :: Options -> Proxy arity
208+ -> (Value -> Parser a) -> (Value -> Parser [a])
209+ -> Value -> Parser (f a)
257210
258211-- | A configurable generic JSON decoder. This function applied to
259212-- 'defaultOptions' is used as the default for 'parseJSON' when the
260213-- type is an instance of 'Generic'.
261214genericParseJSON :: (Generic a, GFromJSON Zero (Rep a))
262215 => Options -> Value -> Parser a
263−genericParseJSON opts = fmap to . gParseJSON opts NoFromArgs
216+genericParseJSON opts = fmap to . gParseJSON opts proxyZero undefined undefined
264217
265218-- | A configurable generic JSON decoder. This function applied to
266219-- 'defaultOptions' is used as the default for 'liftParseJSON' when the
@@ -268,7 +221,7 @@ genericParseJSON opts = fmap to . gParseJSON opts NoFromArgs
268221genericLiftParseJSON :: (Generic1 f, GFromJSON One (Rep1 f))
269222 => Options -> (Value -> Parser a) -> (Value -> Parser [a])
270223 -> Value -> Parser (f a)
271−genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
224+genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts proxyOne pj pjl
272225
273226-------------------------------------------------------------------------------
274227-- Class
@@ -287,21 +240,14 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
287240--
288241-- The basic ways to signal a failed conversion are as follows:
289242--
290−-- * 'fail' yields a custom error message: it is the recommended way of
291−-- reporting a failure;
292−--
293−-- * 'Control.Applicative.empty' (or 'Control.Monad.mzero') is uninformative:
294−-- use it when the error is meant to be caught by some @('<|>')@;
243+-- * 'empty' and 'mzero' work, but are terse and uninformative
295244--
296−-- * 'typeMismatch' can be used to report a failure when the encountered value
297−-- is not of the expected JSON type; 'unexpected' is an appropriate alternative
298−-- when more than one type may be expected, or to keep the expected type
299−-- implicit.
245+-- * 'fail' yields a custom error message
300246--
301−-- 'prependFailure' (or 'modifyFailure') add more information to a parser's
302−-- error messages.
247+-- * 'typeMismatch' produces an informative message for cases when the
248+-- value encountered is not of the expected type
303249--
304−-- An example type and instance using 'typeMismatch' and 'prependFailure':
250+-- An example type and instance:
305251--
306252-- @
307253-- \-- Allow ourselves to write 'Text' literals.
@@ -309,30 +255,15 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
309255--
310256-- data Coord = Coord { x :: Double, y :: Double }
311257--
312−-- instance 'FromJSON' Coord where
313−-- 'parseJSON' ('Object' v) = Coord
314−-- '<$>' v '.:' \"x\"
315−-- '<*>' v '.:' \"y\"
316−--
317−-- \-- We do not expect a non-'Object' value here.
318−-- \-- We could use 'Control.Applicative.empty' to fail, but 'typeMismatch'
319−-- \-- gives a much more informative error message.
320−-- 'parseJSON' invalid =
321−-- 'prependFailure' "parsing Coord failed, "
322−-- ('typeMismatch' \"Object\" invalid)
323−-- @
324−--
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:
258+-- instance FromJSON Coord where
259+-- parseJSON ('Object' v) = Coord '<$>'
260+-- v '.:' \"x\" '<*>'
261+-- v '.:' \"y\"
330262--
331−-- @
332−-- instance 'FromJSON' Coord where
333−-- 'parseJSON' = 'withObject' \"Coord\" $ \\v -> Coord
334−-- '<$>' v '.:' \"x\"
335−-- '<*>' v '.:' \"y\"
263+-- \-- We do not expect a non-'Object' value here.
264+-- \-- We could use 'mzero' to fail, but 'typeMismatch'
265+-- \-- gives a much more informative error message.
266+-- parseJSON invalid = 'typeMismatch' \"Coord\" invalid
336267-- @
337268--
338269-- Instead of manually writing your 'FromJSON' instance, there are two options
@@ -340,7 +271,7 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
340271--
341272-- * "Data.Aeson.TH" provides Template Haskell functions which will derive an
342273-- instance at compile time. The generated instance is optimized for your type
343−-- so it will probably be more efficient than the following option.
274+-- so will probably be more efficient than the following two options:
344275--
345276-- * The compiler can provide a default generic implementation for
346277-- 'parseJSON'.
@@ -358,21 +289,18 @@ genericLiftParseJSON opts pj pjl = fmap to1 . gParseJSON opts (From1Args pj pjl)
358289--
359290-- data Coord = Coord { x :: Double, y :: Double } deriving 'Generic'
360291--
361−-- instance 'FromJSON' Coord
292+-- instance FromJSON Coord
362293-- @
363294--
364−-- The default implementation will be equivalent to
365−-- @parseJSON = 'genericParseJSON' 'defaultOptions'@; if you need different
366−-- options, you can customize the generic decoding by defining:
295+-- If @DefaultSignatures@ doesn't give exactly the results you want,
296+-- you can customize the generic decoding with only a tiny amount of
297+-- effort, using 'genericParseJSON' with your preferred 'Options':
367298--
368299-- @
369−-- customOptions = 'defaultOptions'
370−-- { 'fieldLabelModifier' = 'map' 'Data.Char.toUpper'
371−-- }
372−--
373−-- instance 'FromJSON' Coord where
374−-- 'parseJSON' = 'genericParseJSON' customOptions
300+-- instance FromJSON Coord where
301+-- parseJSON = 'genericParseJSON' 'defaultOptions'
375302-- @
303+
376304class FromJSON a where
377305 parseJSON :: Value -> Parser a
378306
@@ -380,89 +308,61 @@ class FromJSON a where
380308 parseJSON = genericParseJSON defaultOptions
381309
382310 parseJSONList :: Value -> Parser [a]
383− parseJSONList = withArray "[]" $ \a ->
384− zipWithM (parseIndexedJSON parseJSON) [0..]
311+ parseJSONList (Array a)
312+ = sequence
313+ . zipWith (parseIndexedJSON parseJSON) [0..]
385314 . V.toList
386315 $ a
387316
317+ parseJSONList v = typeMismatch "[a]" v
318+
388319-------------------------------------------------------------------------------
389320-- Classes and types for map keys
390321-------------------------------------------------------------------------------
391322
392−-- | Read the docs for 'ToJSONKey' first. This class is a conversion
393−-- in the opposite direction. If you have a newtype wrapper around 'Text',
394−-- the recommended way to define instances is with generalized newtype deriving:
395−--
396−-- > newtype SomeId = SomeId { getSomeId :: Text }
397−-- > deriving (Eq,Ord,Hashable,FromJSONKey)
398−--
399−-- If you have a sum of nullary constructors, you may use the generic
400−-- implementation:
401−--
402−-- @
403−-- data Color = Red | Green | Blue
404−-- deriving Generic
405−--
406−-- instance 'FromJSONKey' Color where
407−-- 'fromJSONKey' = 'genericFromJSONKey' 'defaultJSONKeyOptions'
408−-- @
409323class FromJSONKey a where
410− -- | Strategy for parsing the key of a map-like container.
411324 fromJSONKey :: FromJSONKeyFunction a
412325 default fromJSONKey :: FromJSON a => FromJSONKeyFunction a
413326 fromJSONKey = FromJSONKeyValue parseJSON
414327
415− -- | This is similar in spirit to the 'readList' method of 'Read'.
416− -- It makes it possible to give 'String' keys special treatment
417− -- without using @OverlappingInstances@. End users should always
418− -- be able to use the default implementation of this method.
419328 fromJSONKeyList :: FromJSONKeyFunction [a]
420329 default fromJSONKeyList :: FromJSON a => FromJSONKeyFunction [a]
421330 fromJSONKeyList = FromJSONKeyValue parseJSON
422331
423−-- | With GHC 7.8+ we carry around @'Coercible' 'Text' a@ dictionary,
424−-- to give us an assurance that the program will not segfault.
425−-- Unfortunately we cannot enforce that the 'Eq' instances or the
426−-- 'Hashable' instances for 'Text' and @a@ agree.
332+-- | With GHC 7.8 + we carry around 'Coercible Text a' dictionary,
333+-- to have even some amount of safety net.
334+-- Unfortunately we cannot enforce that 'Hashable' instance agree on the type level
427335--
428−-- At the moment this type is intentionally not exported. 'FromJSONKeyFunction'
429−-- can be inspected, but cannot be constructed.
336+-- ATM this type is intentionally not exported. FromJSONKeyFunction can be inspected,
337+-- but cannot be constructed.
430338data CoerceText a where
339+#if HAS_COERCIBLE
431340 CoerceText :: Coercible Text a => CoerceText a
341+#else
342+ CoerceText :: CoerceText a
343+#endif
432344
433−-- | This type is related to 'ToJSONKeyFunction'. If 'FromJSONKeyValue' is used in the
434−-- 'FromJSONKey' instance, then 'ToJSONKeyValue' should be used in the 'ToJSONKey'
435−-- instance. The other three data constructors for this type all correspond to
436−-- 'ToJSONKeyText'. Strictly speaking, 'FromJSONKeyTextParser' is more powerful than
437−-- 'FromJSONKeyText', which is in turn more powerful than 'FromJSONKeyCoerce'.
438−-- For performance reasons, these exist as three options instead of one.
439345data FromJSONKeyFunction a
440346 = FromJSONKeyCoerce !(CoerceText a)
441− -- ^ uses 'coerce' ('unsafeCoerce' in older GHCs)
442347 | FromJSONKeyText !(Text -> a)
443− -- ^ conversion from 'Text' that always succeeds
444348 | FromJSONKeyTextParser !(Text -> Parser a)
445− -- ^ conversion from 'Text' that may fail
446349 | FromJSONKeyValue !(Value -> Parser a)
447− -- ^ conversion for non-textual keys
448350
449−-- | Only law abiding up to interpretation
450351instance Functor FromJSONKeyFunction where
451− fmap h (FromJSONKeyCoerce CoerceText) = FromJSONKeyText (h . coerce)
352+ fmap h (FromJSONKeyCoerce CoerceText) = FromJSONKeyText (h . coerce')
452353 fmap h (FromJSONKeyText f) = FromJSONKeyText (h . f)
453354 fmap h (FromJSONKeyTextParser f) = FromJSONKeyTextParser (fmap h . f)
454355 fmap h (FromJSONKeyValue f) = FromJSONKeyValue (fmap h . f)
455356
456357-- | Construct 'FromJSONKeyFunction' for types coercible from 'Text'. This
457358-- conversion is still unsafe, as 'Hashable' and 'Eq' instances of @a@ should be
458−-- compatible with 'Text' i.e. hash values should be equal for wrapped values as well.
459−-- This property will always be maintained if the 'Hashable' and 'Eq' instances
460−-- are derived with generalized newtype deriving.
461359-- compatible with 'Text' i.e. hash values be equal for wrapped values as well.
462360--
463361-- On pre GHC 7.8 this is unconstrainted function.
464362fromJSONKeyCoerce ::
363+#if HAS_COERCIBLE
465364 Coercible Text a =>
365+#endif
466366 FromJSONKeyFunction a
467367fromJSONKeyCoerce = FromJSONKeyCoerce CoerceText
468368
@@ -470,91 +370,60 @@ fromJSONKeyCoerce = FromJSONKeyCoerce CoerceText
470370--
471371-- See note on 'fromJSONKeyCoerce'.
472372coerceFromJSONKeyFunction ::
373+#if HAS_COERCIBLE
473374 Coercible a b =>
375+#endif
474376 FromJSONKeyFunction a -> FromJSONKeyFunction b
377+#if HAS_COERCIBLE
475378coerceFromJSONKeyFunction = coerce
379+#else
380+coerceFromJSONKeyFunction (FromJSONKeyCoerce CoerceText) = FromJSONKeyCoerce CoerceText
381+coerceFromJSONKeyFunction (FromJSONKeyText f) = FromJSONKeyText (coerce' . f)
382+coerceFromJSONKeyFunction (FromJSONKeyTextParser f) = FromJSONKeyTextParser (fmap coerce' . f)
383+coerceFromJSONKeyFunction (FromJSONKeyValue f) = FromJSONKeyValue (fmap coerce' . f)
384+#endif
476385
477386{-# RULES
478387 "FromJSONKeyCoerce: fmap id" forall (x :: FromJSONKeyFunction a).
479388 fmap id x = x
480389 #-}
390+#if HAS_COERCIBLE
481391{-# RULES
482392 "FromJSONKeyCoerce: fmap coerce" forall x .
483393 fmap coerce x = coerceFromJSONKeyFunction x
484394 #-}
395+#endif
485396
486397-- | Same as 'fmap'. Provided for the consistency with 'ToJSONKeyFunction'.
487398mapFromJSONKeyFunction :: (a -> b) -> FromJSONKeyFunction a -> FromJSONKeyFunction b
488399mapFromJSONKeyFunction = fmap
489400
490−-- | 'fromJSONKey' for 'Generic' types.
491−-- These types must be sums of nullary constructors, whose names will be used
492−-- as keys for JSON objects.
493−--
494−-- See also 'genericToJSONKey'.
495−--
496−-- === __Example__
497−--
498−-- @
499−-- data Color = Red | Green | Blue
500−-- deriving 'Generic'
501−--
502−-- instance 'FromJSONKey' Color where
503−-- 'fromJSONKey' = 'genericFromJSONKey' 'defaultJSONKeyOptions'
504−-- @
505−genericFromJSONKey :: forall a. (Generic a, GFromJSONKey (Rep a))
506− => JSONKeyOptions
507− -> FromJSONKeyFunction a
508−genericFromJSONKey opts = FromJSONKeyTextParser $ \t ->
509− case parseSumFromString (keyModifier opts) t of
510− Nothing -> fail $
511− "invalid key " ++ show t ++ ", expected one of " ++ show cnames
512− Just k -> pure (to k)
513− where
514− cnames = unTagged2 (constructorTags (keyModifier opts) :: Tagged2 (Rep a) [String])
515−
516−class (ConstructorNames f, SumFromString f) => GFromJSONKey f where
517−instance (ConstructorNames f, SumFromString f) => GFromJSONKey f where
518−
519401-------------------------------------------------------------------------------
520402-- Functions needed for documentation
521403-------------------------------------------------------------------------------
522404
523405-- | Fail parsing due to a type mismatch, with a descriptive message.
524406--
525−-- The following wrappers should generally be prefered:
526−-- 'withObject', 'withArray', 'withText', 'withBool'.
527−--
528−-- ==== Error message example
407+-- Example usage:
529408--
530−-- > typeMismatch "Object" (String "oops")
531−-- > -- Error: "expected Object, but encountered String"
532−typeMismatch :: String -- ^ The name of the JSON type being parsed
533− -- (@\"Object\"@, @\"Array\"@, @\"String\"@, @\"Number\"@,
534− -- @\"Boolean\"@, or @\"Null\"@).
409+-- @
410+-- instance FromJSON Coord where
411+-- parseJSON ('Object' v) = {- type matches, life is good -}
412+-- parseJSON wat = 'typeMismatch' \"Coord\" wat
413+-- @
414+typeMismatch :: String -- ^ The name of the type you are trying to parse.
535415 -> Value -- ^ The actual value encountered.
536416 -> Parser a
537417typeMismatch expected actual =
538− fail $ "expected " ++ expected ++ ", but encountered " ++ typeOf actual
539−
540−-- | Fail parsing due to a type mismatch, when the expected types are implicit.
541−--
542−-- ==== Error message example
543−--
544−-- > unexpected (String "oops")
545−-- > -- Error: "unexpected String"
546−unexpected :: Value -> Parser a
547−unexpected actual = fail $ "unexpected " ++ typeOf actual
548−
549−-- | JSON type of a value, name of the head constructor.
550−typeOf :: Value -> String
551−typeOf v = case v of
552− Object _ -> "Object"
553− Array _ -> "Array"
554− String _ -> "String"
555− Number _ -> "Number"
556− Bool _ -> "Boolean"
557− Null -> "Null"
418+ fail $ "expected " ++ expected ++ ", encountered " ++ name
419+ where
420+ name = case actual of
421+ Object _ -> "Object"
422+ Array _ -> "Array"
423+ String _ -> "String"
424+ Number _ -> "Number"
425+ Bool _ -> "Boolean"
426+ Null -> "Null"
558427
559428-------------------------------------------------------------------------------
560429-- Lifings of FromJSON and ToJSON to unary and binary type constructors
@@ -567,7 +436,7 @@ typeOf v = case v of
567436--
568437-- * "Data.Aeson.TH" provides Template Haskell functions which will derive an
569438-- instance at compile time. The generated instance is optimized for your type
570−-- so it will probably be more efficient than the following option.
439+-- so will probably be more efficient than the following two options:
571440--
572441-- * The compiler can provide a default generic implementation for
573442-- 'liftParseJSON'.
@@ -585,20 +454,16 @@ typeOf v = case v of
585454--
586455-- data Pair a b = Pair { pairFst :: a, pairSnd :: b } deriving 'Generic1'
587456--
588−-- instance 'FromJSON' a => 'FromJSON1' (Pair a)
457+-- instance FromJSON a => FromJSON1 (Pair a)
589458-- @
590459--
591−-- If the default implementation doesn't give exactly the results you want,
460+-- If @DefaultSignatures@ doesn't give exactly the results you want,
592461-- you can customize the generic decoding with only a tiny amount of
593462-- effort, using 'genericLiftParseJSON' with your preferred 'Options':
594463--
595464-- @
596−-- customOptions = 'defaultOptions'
597−-- { 'fieldLabelModifier' = 'map' 'Data.Char.toUpper'
598−-- }
599−--
600−-- instance 'FromJSON' a => 'FromJSON1' (Pair a) where
601−-- 'liftParseJSON' = 'genericLiftParseJSON' customOptions
465+-- instance FromJSON a => FromJSON1 (Pair a) where
466+-- liftParseJSON = 'genericLiftParseJSON' 'defaultOptions'
602467-- @
603468class FromJSON1 f where
604469 liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a)
@@ -635,8 +500,9 @@ class FromJSON2 f where
635500 -> (Value -> Parser b)
636501 -> (Value -> Parser [b])
637502 -> Value -> Parser [f a b]
638− liftParseJSONList2 fa ga fb gb = withArray "[]" $ \vals ->
639− fmap V.toList (V.mapM (liftParseJSON2 fa ga fb gb) vals)
503+ liftParseJSONList2 fa ga fb gb v = case v of
504+ Array vals -> fmap V.toList (V.mapM (liftParseJSON2 fa ga fb gb) vals)
505+ _ -> typeMismatch "[a]" v
640506
641507-- | Lift the standard 'parseJSON' function through the type constructor.
642508parseJSON2 :: (FromJSON2 f, FromJSON a, FromJSON b) => Value -> Parser (f a b)
@@ -647,10 +513,9 @@ parseJSON2 = liftParseJSON2 parseJSON parseJSONList parseJSON parseJSONList
647513-- List functions
648514-------------------------------------------------------------------------------
649515
650−-- | Helper function to use with 'liftParseJSON'. See 'Data.Aeson.ToJSON.listEncoding'.
651516listParser :: (Value -> Parser a) -> Value -> Parser [a]
652517listParser f (Array xs) = fmap V.toList (V.mapM f xs)
653−listParser _ v = typeMismatch "Array" v
518+listParser _ v = typeMismatch "[a]" v
654519{-# INLINE listParser #-}
655520
656521-------------------------------------------------------------------------------
@@ -668,139 +533,48 @@ instance (FromJSON a) => FromJSON [a] where
668533-- Functions
669534-------------------------------------------------------------------------------
670535
671−-- | Add context to a failure message, indicating the name of the structure
672−-- being parsed.
673−--
674−-- > prependContext "MyType" (fail "[error message]")
675−-- > -- Error: "parsing MyType failed, [error message]"
676−prependContext :: String -> Parser a -> Parser a
677−prependContext name = prependFailure ("parsing " ++ name ++ " failed, ")
678−
679−-- | @'withObject' name f value@ applies @f@ to the 'Object' when @value@
680−-- is an 'Data.Aeson.Object' and fails otherwise.
681−--
682−-- ==== Error message example
683−--
684−-- > withObject "MyType" f (String "oops")
685−-- > -- Error: "parsing MyType failed, expected Object, but encountered String"
536+-- | @withObject expected f value@ applies @f@ to the 'Object' when @value@ is an @Object@
537+-- and fails using @'typeMismatch' expected@ otherwise.
686538withObject :: String -> (Object -> Parser a) -> Value -> Parser a
687−withObject _ f (Object obj) = f obj
688−withObject name _ v = prependContext name (typeMismatch "Object" v)
539+withObject _ f (Object obj) = f obj
540+withObject expected _ v = typeMismatch expected v
689541{-# INLINE withObject #-}
690542
691−-- | @'withText' name f value@ applies @f@ to the 'Text' when @value@ is a
692−-- 'Data.Aeson.String' and fails otherwise.
693−--
694−-- ==== Error message example
695−--
696−-- > withText "MyType" f Null
697−-- > -- Error: "parsing MyType failed, expected String, but encountered Null"
543+-- | @withText expected f value@ applies @f@ to the 'Text' when @value@ is a @String@
544+-- and fails using @'typeMismatch' expected@ otherwise.
698545withText :: String -> (Text -> Parser a) -> Value -> Parser a
699−withText _ f (String txt) = f txt
700−withText name _ v = prependContext name (typeMismatch "String" v)
546+withText _ f (String txt) = f txt
547+withText expected _ v = typeMismatch expected v
701548{-# INLINE withText #-}
702549
703−-- | @'withArray' expected f value@ applies @f@ to the 'Array' when @value@ is
704−-- an 'Data.Aeson.Array' and fails otherwise.
705−--
706−-- ==== Error message example
707−--
708−-- > withArray "MyType" f (String "oops")
709−-- > -- Error: "parsing MyType failed, expected Array, but encountered String"
550+-- | @withArray expected f value@ applies @f@ to the 'Array' when @value@ is an @Array@
551+-- and fails using @'typeMismatch' expected@ otherwise.
710552withArray :: String -> (Array -> Parser a) -> Value -> Parser a
711−withArray _ f (Array arr) = f arr
712−withArray name _ v = prependContext name (typeMismatch "Array" v)
553+withArray _ f (Array arr) = f arr
554+withArray expected _ v = typeMismatch expected v
713555{-# INLINE withArray #-}
714556
715−-- | @'withScientific' name f value@ applies @f@ to the 'Scientific' number
716−-- when @value@ is a 'Data.Aeson.Number' and fails using 'typeMismatch'
717−-- otherwise.
718−--
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.
723−--
724−-- ==== Error message example
725−--
726−-- > withScientific "MyType" f (String "oops")
727−-- > -- Error: "parsing MyType failed, expected Number, but encountered String"
557+-- | @withNumber expected f value@ applies @f@ to the 'Number' when @value@ is a 'Number'.
558+-- and fails using @'typeMismatch' expected@ otherwise.
559+withNumber :: String -> (Number -> Parser a) -> Value -> Parser a
560+withNumber expected f = withScientific expected (f . scientificToNumber)
561+{-# INLINE withNumber #-}
562+{-# DEPRECATED withNumber "Use withScientific instead" #-}
563+
564+-- | @withScientific expected f value@ applies @f@ to the 'Scientific' number when @value@ is a 'Number'.
565+-- and fails using @'typeMismatch' expected@ otherwise.
728566withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
729−withScientific _ f (Number scientific) = f scientific
730−withScientific name _ v = prependContext name (typeMismatch "Number" v)
567+withScientific _ f (Number scientific) = f scientific
568+withScientific expected _ v = typeMismatch expected v
731569{-# INLINE withScientific #-}
732570
733−-- | A variant of 'withScientific' which doesn't use 'prependContext', so that
734−-- such context can be added separately in a way that also applies when the
735−-- continuation @f :: Scientific -> Parser a@ fails.
736−--
737−-- /Warning/: If you are converting from a scientific to an unbounded
738−-- type such as 'Integer' you may want to add a restriction on the
739−-- size of the exponent (see 'withBoundedScientific') to prevent
740−-- malicious input from filling up the memory of the target system.
741−--
742−-- ==== Error message examples
743−--
744−-- > withScientific' f (String "oops")
745−-- > -- Error: "unexpected String"
746−-- >
747−-- > prependContext "MyType" (withScientific' f (String "oops"))
748−-- > -- Error: "parsing MyType failed, unexpected String"
749−withScientific' :: (Scientific -> Parser a) -> Value -> Parser a
750−withScientific' f v = case v of
751− Number n -> f n
752− _ -> typeMismatch "Number" v
753−{-# INLINE withScientific' #-}
754−
755−-- | @'withBoundedScientific' name f value@ applies @f@ to the 'Scientific' number
756−-- when @value@ is a 'Number' with exponent less than or equal to 1024.
757−withBoundedScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
758−withBoundedScientific name f v = withBoundedScientific_ (prependContext name) f v
759−{-# INLINE withBoundedScientific #-}
760−
761−-- | A variant of 'withBoundedScientific' which doesn't use 'prependContext',
762−-- so that such context can be added separately in a way that also applies
763−-- when the continuation @f :: Scientific -> Parser a@ fails.
764−withBoundedScientific' :: (Scientific -> Parser a) -> Value -> Parser a
765−withBoundedScientific' f v = withBoundedScientific_ id f v
766−{-# INLINE withBoundedScientific' #-}
767−
768−-- | A variant of 'withBoundedScientific_' parameterized by a function to apply
769−-- to the 'Parser' in case of failure.
770−withBoundedScientific_ :: (Parser a -> Parser a) -> (Scientific -> Parser a) -> Value -> Parser a
771−withBoundedScientific_ whenFail f (Number scientific) =
772− if exp10 > 1024
773− then whenFail (fail msg)
774− else f scientific
775− where
776− exp10 = base10Exponent scientific
777− msg = "found a number with exponent " ++ show exp10 ++ ", but it must not be greater than 1024"
778−withBoundedScientific_ whenFail _ v =
779− whenFail (typeMismatch "Number" v)
780−{-# INLINE withBoundedScientific_ #-}
781−
782−-- | @'withBool' expected f value@ applies @f@ to the 'Bool' when @value@ is a
783−-- 'Boolean' and fails otherwise.
784−--
785−-- ==== Error message example
786−--
787−-- > withBool "MyType" f (String "oops")
788−-- > -- Error: "parsing MyType failed, expected Boolean, but encountered String"
571+-- | @withBool expected f value@ applies @f@ to the 'Bool' when @value@ is a @Bool@
572+-- and fails using @'typeMismatch' expected@ otherwise.
789573withBool :: String -> (Bool -> Parser a) -> Value -> Parser a
790−withBool _ f (Bool arr) = f arr
791−withBool name _ v = prependContext name (typeMismatch "Boolean" v)
574+withBool _ f (Bool arr) = f arr
575+withBool expected _ v = typeMismatch expected v
792576{-# INLINE withBool #-}
793577
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)
798− where
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 #-}
803−
804578-- | Convert a value from JSON, failing if the types do not match.
805579fromJSON :: (FromJSON a) => Value -> Result a
806580fromJSON = parse parseJSON
@@ -819,68 +593,32 @@ ifromJSON = iparse parseJSON
819593-- in an object for it to be valid. If the key and value are
820594-- optional, use '.:?' instead.
821595(.:) :: (FromJSON a) => Object -> Text -> Parser a
822−(.:) = explicitParseField parseJSON
596+obj .: key = case H.lookup key obj of
597+ Nothing -> fail $ "key " ++ show key ++ " not present"
598+ Just v -> parseJSON v <?> Key key
823599{-# INLINE (.:) #-}
824600
825−-- | Retrieve the value associated with the given key of an 'Object'. The
826−-- result is 'Nothing' if the key is not present or if its value is 'Null',
827−-- or 'empty' if the value cannot be converted to the desired type.
601+-- | Retrieve the value associated with the given key of an 'Object'.
602+-- The result is 'Nothing' if the key is not present, or 'empty' if
603+-- the value cannot be converted to the desired type.
828604--
829605-- This accessor is most useful if the key and value can be absent
830606-- from an object without affecting its validity. If the key and
831607-- value are mandatory, use '.:' instead.
832608(.:?) :: (FromJSON a) => Object -> Text -> Parser (Maybe a)
833−(.:?) = explicitParseFieldMaybe parseJSON
609+obj .:? key = case H.lookup key obj of
610+ Nothing -> pure Nothing
611+ Just v -> parseJSON v <?> Key key
834612{-# INLINE (.:?) #-}
835613
836−-- | Retrieve the value associated with the given key of an 'Object'.
837−-- The result is 'Nothing' if the key is not present or 'empty' if the
838−-- value cannot be converted to the desired type.
839−--
840−-- This differs from '.:?' by attempting to parse 'Null' the same as any
841−-- other JSON value, instead of interpreting it as 'Nothing'.
614+-- | Like '.:?', but the resulting parser will fail,
615+-- if the key is present but is 'Null'.
842616(.:!) :: (FromJSON a) => Object -> Text -> Parser (Maybe a)
843−(.:!) = explicitParseFieldMaybe' parseJSON
617+obj .:! key = case H.lookup key obj of
618+ Nothing -> pure Nothing
619+ Just v -> Just <$> parseJSON v <?> Key key
844620{-# INLINE (.:!) #-}
845621
846−-- | Function variant of '.:'.
847−parseField :: (FromJSON a) => Object -> Text -> Parser a
848−parseField = (.:)
849−{-# INLINE parseField #-}
850−
851−-- | Function variant of '.:?'.
852−parseFieldMaybe :: (FromJSON a) => Object -> Text -> Parser (Maybe a)
853−parseFieldMaybe = (.:?)
854−{-# INLINE parseFieldMaybe #-}
855−
856−-- | Function variant of '.:!'.
857−parseFieldMaybe' :: (FromJSON a) => Object -> Text -> Parser (Maybe a)
858−parseFieldMaybe' = (.:!)
859−{-# INLINE parseFieldMaybe' #-}
860−
861−-- | Variant of '.:' with explicit parser function.
862−--
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 #-}
869−
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 #-}
876−
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' #-}
883−
884622-- | Helper for use in combination with '.:?' to provide default
885623-- values for optional JSON object fields.
886624--
@@ -903,554 +641,317 @@ pmval .!= val = fromMaybe val <$> pmval
903641-- Generic parseJSON
904642-------------------------------------------------------------------------------
905643
906−instance GFromJSON arity V1 where
907− -- Whereof we cannot format, thereof we cannot parse:
908− gParseJSON _ _ _ = fail "Attempted to parse empty type"
909−
910−
911644instance OVERLAPPABLE_ (GFromJSON arity a) => GFromJSON arity (M1 i c a) where
912645 -- Meta-information, which is not handled elsewhere, is just added to the
913646 -- parsed value:
914− gParseJSON opts fargs = fmap M1 . gParseJSON opts fargs
915−
916−-- Information for error messages
917−
918−type TypeName = String
919−type ConName = String
920−
921−-- | Add the name of the type being parsed to a parser's error messages.
922−contextType :: TypeName -> Parser a -> Parser a
923−contextType = prependContext
924−
925−-- | Add the tagKey that will be looked up while building an ADT
926−-- | Produce the error equivalent to
927−-- | Left "Error in $: parsing T failed, expected an object with keys "tag" and
928−-- | "contents", where "tag" i-- |s associated to one of ["Foo", "Bar"],
929−-- | The parser returned error was: could not find key "tag"
930−contextTag :: Text -> [String] -> Parser a -> Parser a
931−contextTag tagKey cnames = prependFailure
932− ("expected Object with key \"" ++ unpack tagKey ++ "\"" ++
933− " containing one of " ++ show cnames ++ ", ")
934−
935−-- | Add the name of the constructor being parsed to a parser's error messages.
936−contextCons :: ConName -> TypeName -> Parser a -> Parser a
937−contextCons cname tname = prependContext (showCons cname tname)
938−
939−-- | Render a constructor as @\"MyType(MyConstructor)\"@.
940−showCons :: ConName -> TypeName -> String
941−showCons cname tname = tname ++ "(" ++ cname ++ ")"
942−
943−--------------------------------------------------------------------------------
944−
945−-- Parsing single fields
647+ gParseJSON opts pa pj pjl = fmap M1 . gParseJSON opts pa pj pjl
946648
947649instance (FromJSON a) => GFromJSON arity (K1 i a) where
948650 -- Constant values are decoded using their FromJSON instance:
949− gParseJSON _opts _ = fmap K1 . parseJSON
651+ gParseJSON _opts _ _ _ = fmap K1 . parseJSON
950652
951653instance GFromJSON One Par1 where
952654 -- Direct occurrences of the last type parameter are decoded with the
953655 -- function passed in as an argument:
954− gParseJSON _opts (From1Args pj _) = fmap Par1 . pj
656+ gParseJSON _opts _ pj _ = fmap Par1 . pj
955657
956658instance (FromJSON1 f) => GFromJSON One (Rec1 f) where
957659 -- Recursive occurrences of the last type parameter are decoded using their
958660 -- FromJSON1 instance:
959− gParseJSON _opts (From1Args pj pjl) = fmap Rec1 . liftParseJSON pj pjl
661+ gParseJSON _opts _ pj pjl = fmap Rec1 . liftParseJSON pj pjl
662+
663+instance GFromJSON arity U1 where
664+ -- Empty constructors are expected to be encoded as an empty array:
665+ gParseJSON _opts _ _ _ v
666+ | isEmptyArray v = pure U1
667+ | otherwise = typeMismatch "unit constructor (U1)" v
668+
669+instance (ConsFromJSON arity a) => GFromJSON arity (C1 c a) where
670+ -- Constructors need to be decoded differently depending on whether they're
671+ -- a record or not. This distinction is made by consParseJSON:
672+ gParseJSON opts pa pj pjl = fmap M1 . consParseJSON opts pa pj pjl
673+
674+instance ( FromProduct arity a, FromProduct arity b
675+ , ProductSize a, ProductSize b
676+ ) => GFromJSON arity (a :*: b) where
677+ -- Products are expected to be encoded to an array. Here we check whether we
678+ -- got an array of the same size as the product, then parse each of the
679+ -- product's elements using parseProduct:
680+ gParseJSON opts pa pj pjl = withArray "product (:*:)" $ \arr ->
681+ let lenArray = V.length arr
682+ lenProduct = (unTagged2 :: Tagged2 (a :*: b) Int -> Int)
683+ productSize in
684+ if lenArray == lenProduct
685+ then parseProduct opts pa arr 0 lenProduct pj pjl
686+ else fail $ "When expecting a product of " ++ show lenProduct ++
687+ " values, encountered an Array of " ++ show lenArray ++
688+ " elements instead"
689+
690+instance ( AllNullary (a :+: b) allNullary
691+ , ParseSum arity (a :+: b) allNullary
692+ ) => GFromJSON arity (a :+: b) where
693+ -- If all constructors of a sum datatype are nullary and the
694+ -- 'allNullaryToStringTag' option is set they are expected to be
695+ -- encoded as strings. This distinction is made by 'parseSum':
696+ gParseJSON opts pa pj pjl =
697+ (unTagged :: Tagged allNullary (Parser ((a :+: b) d)) ->
698+ (Parser ((a :+: b) d)))
699+ . parseSum opts pa pj pjl
960700
961701instance (FromJSON1 f, GFromJSON One g) => GFromJSON One (f :.: g) where
962702 -- If an occurrence of the last type parameter is nested inside two
963703 -- composed types, it is decoded by using the outermost type's FromJSON1
964704 -- instance to generically decode the innermost type:
965− gParseJSON opts fargs =
966− let gpj = gParseJSON opts fargs in
967− fmap Comp1 . liftParseJSON gpj (listParser gpj)
968−
969−--------------------------------------------------------------------------------
970−
971−instance (GFromJSON' arity a, Datatype d) => GFromJSON arity (D1 d a) where
972− -- Meta-information, which is not handled elsewhere, is just added to the
973− -- parsed value:
974− gParseJSON opts fargs = fmap M1 . gParseJSON' (tname :* opts :* fargs)
975− where
976− tname = moduleName proxy ++ "." ++ datatypeName proxy
977− proxy = undefined :: M1 _i d _f _p
978−
979−-- | 'GFromJSON', after unwrapping the 'D1' constructor, now carrying the data
980−-- type's name.
981−class GFromJSON' arity f where
982− gParseJSON' :: TypeName :* Options :* FromArgs arity a
983− -> Value
984− -> Parser (f a)
985−
986−-- | Single constructor.
987−instance ( ConsFromJSON arity a
988− , AllNullary (C1 c a) allNullary
989− , ParseSum arity (C1 c a) allNullary
990− , Constructor c
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))
997− . parseSum p
998− | otherwise = fmap M1 . consParseJSON (cname :* p)
999− where
1000− cname = conName (undefined :: M1 _i c _f _p)
1001−
1002−-- | Multiple constructors.
1003−instance ( AllNullary (a :+: b) allNullary
1004− , ParseSum arity (a :+: b) allNullary
1005− ) => GFromJSON' arity (a :+: b) where
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':
1009− gParseJSON' p =
1010− (unTagged :: Tagged allNullary (Parser ((a :+: b) _d)) ->
1011− Parser ((a :+: b) _d))
1012− . parseSum p
705+ gParseJSON opts pa pj pjl =
706+ let gpj = gParseJSON opts pa pj pjl in
707+ fmap Comp1 . liftParseJSON gpj (listParser gpj)
1013708
1014709--------------------------------------------------------------------------------
1015710
1016711class ParseSum arity f allNullary where
1017− parseSum :: TypeName :* Options :* FromArgs arity a
1018− -> Value
1019− -> Tagged allNullary (Parser (f a))
1020−
1021−instance ( ConstructorNames f
1022− , SumFromString f
1023− , FromPair arity f
1024− , FromTaggedObject arity f
1025− , FromUntaggedValue arity f
1026− ) => ParseSum arity f True where
1027− parseSum p@(tname :* opts :* _)
1028− | allNullaryToStringTag opts = Tagged . parseAllNullarySum tname opts
1029− | otherwise = Tagged . parseNonAllNullarySum p
1030−
1031−instance ( ConstructorNames f
1032− , FromPair arity f
1033− , FromTaggedObject arity f
1034− , FromUntaggedValue arity f
1035− ) => ParseSum arity f False where
1036− parseSum p = Tagged . parseNonAllNullarySum p
712+ parseSum :: Options -> Proxy arity
713+ -> (Value -> Parser a) -> (Value -> Parser [a])
714+ -> Value -> Tagged allNullary (Parser (f a))
715+
716+instance ( SumFromString (a :+: b)
717+ , FromPair arity (a :+: b)
718+ , FromTaggedObject arity (a :+: b)
719+ ) => ParseSum arity (a :+: b) True where
720+ parseSum opts pa pj pjl
721+ | allNullaryToStringTag opts = Tagged . parseAllNullarySum opts
722+ | otherwise = Tagged . parseNonAllNullarySum opts pa pj pjl
723+
724+instance ( FromPair arity (a :+: b)
725+ , FromTaggedObject arity (a :+: b)
726+ ) => ParseSum arity (a :+: b) False where
727+ parseSum opts pa pj pjl = Tagged . parseNonAllNullarySum opts pa pj pjl
1037728
1038729--------------------------------------------------------------------------------
1039730
1040−parseAllNullarySum :: (SumFromString f, ConstructorNames f)
1041− => TypeName -> Options -> Value -> Parser (f a)
1042−parseAllNullarySum tname opts =
1043− withText tname $ \tag ->
1044− maybe (badTag tag) return $
1045− parseSumFromString modifier tag
1046− where
1047− badTag tag = failWithCTags tname modifier $ \cnames ->
1048− "expected one of the tags " ++ show cnames ++
1049− ", but found tag " ++ show tag
1050− modifier = constructorTagModifier opts
1051−
1052−-- | Fail with an informative error message about a mismatched tag.
1053−-- The error message is parameterized by the list of expected tags,
1054−-- to be inferred from the result type of the parser.
1055−failWithCTags
1056− :: forall f a t. ConstructorNames f
1057− => TypeName -> (String -> t) -> ([t] -> String) -> Parser (f a)
1058−failWithCTags tname modifier f =
1059− contextType tname . fail $ f cnames
1060− where
1061− cnames = unTagged2 (constructorTags modifier :: Tagged2 f [t])
731+parseAllNullarySum :: SumFromString f => Options -> Value -> Parser (f a)
732+parseAllNullarySum opts = withText "Text" $ \key ->
733+ maybe (notFound key) return $
734+ parseSumFromString opts key
1062735
1063736class SumFromString f where
1064− parseSumFromString :: (String -> String) -> Text -> Maybe (f a)
737+ parseSumFromString :: Options -> Text -> Maybe (f a)
1065738
1066739instance (SumFromString a, SumFromString b) => SumFromString (a :+: b) where
1067740 parseSumFromString opts key = (L1 <$> parseSumFromString opts key) <|>
1068741 (R1 <$> parseSumFromString opts key)
1069742
1070743instance (Constructor c) => SumFromString (C1 c U1) where
1071− parseSumFromString modifier key
1072− | key == name = Just $ M1 U1
1073− | otherwise = Nothing
1074− where
1075− name = pack $ modifier $ conName (undefined :: M1 _i c _f _p)
1076−
1077−-- For genericFromJSONKey
1078−instance SumFromString a => SumFromString (D1 d a) where
1079− parseSumFromString modifier key = M1 <$> parseSumFromString modifier key
1080−
1081−-- | List of all constructor tags.
1082−constructorTags :: ConstructorNames a => (String -> t) -> Tagged2 a [t]
1083−constructorTags modifier =
1084− fmap DList.toList (constructorNames' modifier)
1085−
1086−-- | List of all constructor names of an ADT, after a given conversion
1087−-- function. (Better inlining.)
1088−class ConstructorNames a where
1089− constructorNames' :: (String -> t) -> Tagged2 a (DList.DList t)
1090−
1091−instance (ConstructorNames a, ConstructorNames b) => ConstructorNames (a :+: b) where
1092− constructorNames' = liftA2 append constructorNames' constructorNames'
1093− where
1094− append
1095− :: Tagged2 a (DList.DList t)
1096− -> Tagged2 b (DList.DList t)
1097− -> Tagged2 (a :+: b) (DList.DList t)
1098− append (Tagged2 xs) (Tagged2 ys) = Tagged2 (DList.append xs ys)
1099−
1100−instance Constructor c => ConstructorNames (C1 c a) where
1101− constructorNames' f = Tagged2 (pure (f cname))
1102− where
1103− cname = conName (undefined :: M1 _i c _f _p)
1104−
1105−-- For genericFromJSONKey
1106−instance ConstructorNames a => ConstructorNames (D1 d a) where
1107− constructorNames' = retag . constructorNames'
1108− where
1109− retag :: Tagged2 a u -> Tagged2 (D1 d a) u
1110− retag (Tagged2 x) = Tagged2 x
744+ parseSumFromString opts key | key == name = Just $ M1 U1
745+ | otherwise = Nothing
746+ where
747+ name = pack $ constructorTagModifier opts $
748+ conName (undefined :: t c U1 p)
1111749
1112750--------------------------------------------------------------------------------
1113−parseNonAllNullarySum :: forall f c arity.
1114− ( FromPair arity f
1115− , FromTaggedObject arity f
1116− , FromUntaggedValue arity f
1117− , ConstructorNames f
1118− ) => TypeName :* Options :* FromArgs arity c
1119− -> Value -> Parser (f c)
1120−parseNonAllNullarySum p@(tname :* opts :* _) =
751+
752+parseNonAllNullarySum :: ( FromPair arity (a :+: b)
753+ , FromTaggedObject arity (a :+: b)
754+ ) => Options -> Proxy arity
755+ -> (Value -> Parser c) -> (Value -> Parser [c])
756+ -> Value -> Parser ((a :+: b) c)
757+parseNonAllNullarySum opts pa pj pjl =
1121758 case sumEncoding opts of
1122759 TaggedObject{..} ->
1123− withObject tname $ \obj -> do
1124− tag <- contextType tname . contextTag tagKey cnames_ $ obj .: tagKey
1125− fromMaybe (badTag tag <?> Key tagKey) $
1126− parseFromTaggedObject (tag :* contentsFieldName :* p) obj
1127− where
1128− tagKey = pack tagFieldName
1129− badTag tag = failWith_ $ \cnames ->
1130− "expected tag field to be one of " ++ show cnames ++
1131− ", but found tag " ++ show tag
1132− cnames_ = unTagged2 (constructorTags (constructorTagModifier opts) :: Tagged2 f [String])
760+ withObject "Object" $ \obj -> do
761+ tag <- obj .: pack tagFieldName
762+ fromMaybe (notFound tag) $
763+ parseFromTaggedObject opts pa contentsFieldName obj pj pjl tag
1133764
1134765 ObjectWithSingleField ->
1135− withObject tname $ \obj -> case H.toList obj of
1136− [(tag, v)] -> maybe (badTag tag) (<?> Key tag) $
1137− parsePair (tag :* p) v
1138− _ -> contextType tname . fail $
1139− "expected an Object with a single pair, but found " ++
1140− show (H.size obj) ++ " pairs"
1141− where
1142− badTag tag = failWith_ $ \cnames ->
1143− "expected an Object with a single pair where the tag is one of " ++
1144− show cnames ++ ", but found tag " ++ show tag
766+ withObject "Object" $ \obj ->
767+ case H.toList obj of
768+ [pair@(tag, _)] -> fromMaybe (notFound tag) $
769+ parsePair opts pa pj pjl pair
770+ _ -> fail "Object doesn't have a single field"
1145771
1146772 TwoElemArray ->
1147− withArray tname $ \arr -> case V.length arr of
1148− 2 | String tag <- V.unsafeIndex arr 0 ->
1149− maybe (badTag tag <?> Index 0) (<?> Index 1) $
1150− parsePair (tag :* p) (V.unsafeIndex arr 1)
1151− | otherwise ->
1152− contextType tname $
1153− fail "tag element is not a String" <?> Index 0
1154− len -> contextType tname . fail $
1155− "expected a 2-element Array, but encountered an Array of length " ++
1156− show len
1157− where
1158− badTag tag = failWith_ $ \cnames ->
1159− "expected tag of the 2-element Array to be one of " ++
1160− show cnames ++ ", but found tag " ++ show tag
1161−
1162− UntaggedValue -> parseUntaggedValue p
1163− where
1164− failWith_ = failWithCTags tname (constructorTagModifier opts)
773+ withArray "Array" $ \arr ->
774+ if V.length arr == 2
775+ then case V.unsafeIndex arr 0 of
776+ String tag -> fromMaybe (notFound tag) $
777+ parsePair opts pa pj pjl (tag, V.unsafeIndex arr 1)
778+ _ -> fail "First element is not a String"
779+ else fail "Array doesn't have 2 elements"
1165780
1166781--------------------------------------------------------------------------------
1167782
1168783class FromTaggedObject arity f where
1169− -- The first two components of the parameter tuple are: the constructor tag
1170− -- to match against, and the contents field name.
1171− parseFromTaggedObject
1172− :: Text :* String :* TypeName :* Options :* FromArgs arity a
1173− -> Object
1174− -> Maybe (Parser (f a))
784+ parseFromTaggedObject :: Options -> Proxy arity
785+ -> String -> Object
786+ -> (Value -> Parser a) -> (Value -> Parser [a])
787+ -> Text -> Maybe (Parser (f a))
1175788
1176789instance ( FromTaggedObject arity a, FromTaggedObject arity b) =>
1177790 FromTaggedObject arity (a :+: b) where
1178− parseFromTaggedObject p obj =
1179− (fmap L1 <$> parseFromTaggedObject p obj) <|>
1180− (fmap R1 <$> parseFromTaggedObject p obj)
791+ parseFromTaggedObject opts pa contentsFieldName obj pj pjl tag =
792+ (fmap L1 <$> parseFromTaggedObject opts pa contentsFieldName obj pj pjl tag) <|>
793+ (fmap R1 <$> parseFromTaggedObject opts pa contentsFieldName obj pj pjl tag)
1181794
1182−instance ( IsRecord f isRecord
1183− , FromTaggedObject' arity f isRecord
795+instance ( FromTaggedObject' arity f
1184796 , Constructor c
1185797 ) => FromTaggedObject arity (C1 c f) where
1186− parseFromTaggedObject (tag :* contentsFieldName :* p@(_ :* opts :* _))
1187− | tag == tag'
1188− = Just . fmap M1 .
1189− (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a)) .
1190− parseFromTaggedObject' (contentsFieldName :* cname :* p)
1191− | otherwise = const Nothing
1192− where
1193− tag' = pack $ constructorTagModifier opts cname
1194− cname = conName (undefined :: M1 _i c _f _p)
798+ parseFromTaggedObject opts pa contentsFieldName obj pj pjl tag
799+ | tag == name = Just $ M1 <$> parseFromTaggedObject'
800+ opts pa contentsFieldName pj pjl obj
801+ | otherwise = Nothing
802+ where
803+ name = pack $ constructorTagModifier opts $
804+ conName (undefined :: t c f p)
1195805
1196806--------------------------------------------------------------------------------
1197807
1198−class FromTaggedObject' arity f isRecord where
1199− -- The first component of the parameter tuple is the contents field name.
1200− parseFromTaggedObject'
1201− :: String :* ConName :* TypeName :* Options :* FromArgs arity a
1202− -> Object -> Tagged isRecord (Parser (f a))
1203−
1204−instance (RecordFromJSON arity f, FieldNames f) => FromTaggedObject' arity f True where
1205− -- Records are unpacked in the tagged object
1206− parseFromTaggedObject' (_ :* p) = Tagged . recordParseJSON (True :* p)
1207−
1208−instance (ConsFromJSON arity f) => FromTaggedObject' arity f False where
1209− -- Nonnullary nonrecords are encoded in the contents field
1210− parseFromTaggedObject' p obj = Tagged $ do
1211− contents <- contextCons cname tname (obj .: key)
1212− consParseJSON p' contents <?> Key key
1213− where
1214− key = pack contentsFieldName
1215− contentsFieldName :* p'@(cname :* tname :* _) = p
808+class FromTaggedObject' arity f where
809+ parseFromTaggedObject' :: Options -> Proxy arity -> String
810+ -> (Value -> Parser a) -> (Value -> Parser [a])
811+ -> Object -> Parser (f a)
812+
813+class FromTaggedObject'' arity f isRecord where
814+ parseFromTaggedObject'' :: Options -> Proxy arity -> String
815+ -> (Value -> Parser a) -> (Value -> Parser [a])
816+ -> Object -> Tagged isRecord (Parser (f a))
1216817
1217−instance OVERLAPPING_ FromTaggedObject' arity U1 False where
1218− -- Nullary constructors don't need a contents field
1219− parseFromTaggedObject' _ _ = Tagged (pure U1)
818+instance ( IsRecord f isRecord
819+ , FromTaggedObject'' arity f isRecord
820+ ) => FromTaggedObject' arity f where
821+ parseFromTaggedObject' opts pa contentsFieldName pj pjl =
822+ (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a)) .
823+ parseFromTaggedObject'' opts pa contentsFieldName pj pjl
824+
825+instance (FromRecord arity f) => FromTaggedObject'' arity f True where
826+ parseFromTaggedObject'' opts pa _ pj pjl =
827+ Tagged . parseRecord opts pa Nothing pj pjl
828+
829+instance (GFromJSON arity f) => FromTaggedObject'' arity f False where
830+ parseFromTaggedObject'' opts pa contentsFieldName pj pjl = Tagged .
831+ (gParseJSON opts pa pj pjl <=< (.: pack contentsFieldName))
832+
833+instance OVERLAPPING_ FromTaggedObject'' arity U1 False where
834+ parseFromTaggedObject'' _ _ _ _ _ _ = Tagged (pure U1)
1220835
1221836--------------------------------------------------------------------------------
1222837
1223−-- | Constructors need to be decoded differently depending on whether they're
1224−-- a record or not. This distinction is made by 'ConsParseJSON'.
1225838class ConsFromJSON arity f where
1226− consParseJSON
1227− :: ConName :* TypeName :* Options :* FromArgs arity a
1228− -> Value -> Parser (f a)
839+ consParseJSON :: Options -> Proxy arity
840+ -> (Value -> Parser a) -> (Value -> Parser [a])
841+ -> Value -> Parser (f a)
1229842
1230843class ConsFromJSON' arity f isRecord where
1231− consParseJSON'
1232− :: ConName :* TypeName :* Options :* FromArgs arity a
1233− -> Value -> Tagged isRecord (Parser (f a))
844+ consParseJSON' :: Options -> Proxy arity
845+ -> (Maybe Text) -- ^ A dummy label
846+ -- (Nothing to use proper label)
847+ -> (Value -> Parser a) -> (Value -> Parser [a])
848+ -> Value -> Tagged isRecord (Parser (f a))
1234849
1235850instance ( IsRecord f isRecord
1236851 , ConsFromJSON' arity f isRecord
1237852 ) => ConsFromJSON arity f where
1238− consParseJSON p =
1239− (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a))
1240− . consParseJSON' p
1241−
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))
1248−
1249−instance RecordFromJSON arity f => ConsFromJSON' arity f True where
1250− consParseJSON' p@(cname :* tname :* _) =
1251− Tagged . withObject (showCons cname tname) (recordParseJSON (False :* p))
1252−
1253−instance OVERLAPPING_
1254− ConsFromJSON' arity U1 False where
1255− -- Empty constructors are expected to be encoded as an empty array:
1256− consParseJSON' (cname :* tname :* _) v =
1257− Tagged . contextCons cname tname $ case v of
1258− Array a | V.null a -> pure U1
1259− | otherwise -> fail_ a
1260− _ -> typeMismatch "Array" v
1261− where
1262− fail_ a = fail $
1263− "expected an empty Array, but encountered an Array of length " ++
1264− show (V.length a)
853+ consParseJSON opts pa pj pjl v = let
854+ (v2,lab) = case (unwrapUnaryRecords opts,isUnary (undefined :: f a)) of
855+ -- use a dummy object with a dummy label
856+ (True,True) -> ((object [(pack "dummy",v)]),Just $ pack "dummy")
857+ _ ->(v,Nothing)
858+ in (unTagged :: Tagged isRecord (Parser (f a)) -> Parser (f a))
859+ $ consParseJSON' opts pa lab pj pjl v2
1265860
1266−instance OVERLAPPING_
1267− GFromJSON arity f => ConsFromJSON' arity (S1 s f) False where
1268− consParseJSON' (_ :* _ :* opts :* fargs) =
1269− Tagged . fmap M1 . gParseJSON opts fargs
1270861
1271−instance (ProductFromJSON arity f, ProductSize f
1272− ) => ConsFromJSON' arity f False where
1273− consParseJSON' p = Tagged . productParseJSON0 p
862+instance (FromRecord arity f) => ConsFromJSON' arity f True where
863+ consParseJSON' opts pa mlab pj pjl = Tagged . (withObject "record (:*:)"
864+ $ parseRecord opts pa mlab pj pjl)
1274865
1275−--------------------------------------------------------------------------------
1276−
1277−class FieldNames f where
1278− fieldNames :: f a -> [Text] -> [Text]
1279−
1280−instance (FieldNames a, FieldNames b) => FieldNames (a :*: b) where
1281− fieldNames _ =
1282− fieldNames (undefined :: a x) .
1283− fieldNames (undefined :: b y)
866+instance (GFromJSON arity f) => ConsFromJSON' arity f False where
867+ consParseJSON' opts pa _ pj pjl = Tagged . gParseJSON opts pa pj pjl
1284868
1285−instance (Selector s) => FieldNames (S1 s f) where
1286− fieldNames _ = (pack (selName (undefined :: M1 _i s _f _p)) :)
1287−
1288−class RecordFromJSON arity f where
1289− recordParseJSON
1290− :: Bool :* ConName :* TypeName :* Options :* FromArgs arity a
1291− -> Object -> Parser (f a)
869+--------------------------------------------------------------------------------
1292870
1293−instance ( FieldNames f
1294− , RecordFromJSON' arity f
1295− ) => RecordFromJSON arity f where
1296− recordParseJSON (fromTaggedSum :* p@(cname :* tname :* opts :* _)) =
1297− \obj -> checkUnknown obj >> recordParseJSON' p obj
871+class FromRecord arity f where
872+ parseRecord :: Options -> Proxy arity
873+ -> (Maybe Text) -- ^ A dummy label
874+ -- (Nothing to use proper label)
875+ -> (Value -> Parser a) -> (Value -> Parser [a])
876+ -> Object -> Parser (f a)
877+
878+instance ( FromRecord arity a
879+ , FromRecord arity b
880+ ) => FromRecord arity (a :*: b) where
881+ parseRecord opts pa _ pj pjl obj =
882+ (:*:) <$> parseRecord opts pa Nothing pj pjl obj
883+ <*> parseRecord opts pa Nothing pj pjl obj
884+
885+instance ( Selector s
886+ , GFromJSON arity a
887+ ) => FromRecord arity (S1 s a) where
888+ parseRecord opts pa lab pj pjl =
889+ (<?> Key label) . gParseJSON opts pa pj pjl <=< (.: label)
1298890 where
1299− knownFields :: H.HashMap Text ()
1300− knownFields = H.fromList $ map (,()) $
1301− fieldNames (undefined :: f a)
1302− [pack (tagFieldName (sumEncoding opts)) | fromTaggedSum]
1303− checkUnknown =
1304− if not (rejectUnknownFields opts)
1305− then \_ -> return ()
1306− else \obj -> case H.keys (H.difference obj knownFields) of
1307− [] -> return ()
1308− unknownFields -> contextCons cname tname $
1309− fail ("unknown fields: " ++ show unknownFields)
1310−
1311−class RecordFromJSON' arity f where
1312− recordParseJSON'
1313− :: ConName :* TypeName :* Options :* FromArgs arity a
1314− -> Object -> Parser (f a)
1315−
1316−instance ( RecordFromJSON' arity a
1317− , RecordFromJSON' arity b
1318− ) => RecordFromJSON' arity (a :*: b) where
1319− recordParseJSON' p obj =
1320− (:*:) <$> recordParseJSON' p obj
1321− <*> recordParseJSON' p obj
1322−
1323−instance OVERLAPPABLE_ (Selector s, GFromJSON arity a) =>
1324− RecordFromJSON' arity (S1 s a) where
1325− recordParseJSON' (cname :* tname :* opts :* fargs) obj = do
1326− fv <- contextCons cname tname (obj .: label)
1327− M1 <$> gParseJSON opts fargs fv <?> Key label
1328− where
1329− label = pack $ fieldLabelModifier opts sname
1330− sname = selName (undefined :: M1 _i s _f _p)
1331−
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
1335− where
1336− label = fieldLabelModifier opts sname
1337− sname = selName (undefined :: M1 _i s _f _p)
1338−
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
1343− where
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))
891+ label = fromMaybe defLabel lab
892+ defLabel = pack . fieldLabelModifier opts $
893+ selName (undefined :: t s a p)
894+
895+instance OVERLAPPING_ (Selector s, FromJSON a) =>
896+ FromRecord arity (S1 s (K1 i (Maybe a))) where
897+ parseRecord _ _ (Just lab) _ _ obj = (M1 . K1) <$> obj .:? lab
898+ parseRecord opts _ Nothing _ _ obj = (M1 . K1) <$> obj .:? pack label
899+ where
900+ label = fieldLabelModifier opts $
901+ selName (undefined :: t s (K1 i (Maybe a)) p)
1346902
1347903--------------------------------------------------------------------------------
1348904
1349−productParseJSON0
1350− :: forall f arity a. (ProductFromJSON arity f, ProductSize f)
1351− => ConName :* TypeName :* Options :* FromArgs arity a
1352− -> Value -> Parser (f a)
1353− -- Products are expected to be encoded to an array. Here we check whether we
1354− -- got an array of the same size as the product, then parse each of the
1355− -- product's elements using productParseJSON:
1356−productParseJSON0 p@(cname :* tname :* _ :* _) =
1357− withArray (showCons cname tname) $ \arr ->
1358− let lenArray = V.length arr
1359− lenProduct = (unTagged2 :: Tagged2 f Int -> Int)
1360− productSize in
1361− if lenArray == lenProduct
1362− then productParseJSON p arr 0 lenProduct
1363− else contextCons cname tname $
1364− fail $ "expected an Array of length " ++ show lenProduct ++
1365− ", but encountered an Array of length " ++ show lenArray
1366−
1367−--
1368−
1369−class ProductFromJSON arity f where
1370− productParseJSON :: ConName :* TypeName :* Options :* FromArgs arity a
905+class FromProduct arity f where
906+ parseProduct :: Options -> Proxy arity
1371907 -> Array -> Int -> Int
908+ -> (Value -> Parser a) -> (Value -> Parser [a])
1372909 -> Parser (f a)
1373910
1374−instance ( ProductFromJSON arity a
1375− , ProductFromJSON arity b
1376− ) => ProductFromJSON arity (a :*: b) where
1377− productParseJSON p arr ix len =
1378− (:*:) <$> productParseJSON p arr ix lenL
1379− <*> productParseJSON p arr ixR lenR
911+instance ( FromProduct arity a
912+ , FromProduct arity b
913+ ) => FromProduct arity (a :*: b) where
914+ parseProduct opts pa arr ix len pj pjl =
915+ (:*:) <$> parseProduct opts pa arr ix lenL pj pjl
916+ <*> parseProduct opts pa arr ixR lenR pj pjl
1380917 where
1381918 lenL = len `unsafeShiftR` 1
1382919 ixR = ix + lenL
1383920 lenR = len - lenL
1384921
1385−instance (GFromJSON arity a) => ProductFromJSON arity (S1 s a) where
1386− productParseJSON (_ :* _ :* opts :* fargs) arr ix _ =
1387− M1 <$> gParseJSON opts fargs (V.unsafeIndex arr ix) <?> Index ix
922+instance (GFromJSON arity a) => FromProduct arity (S1 s a) where
923+ parseProduct opts pa arr ix _ pj pjl =
924+ gParseJSON opts pa pj pjl $ V.unsafeIndex arr ix
1388925
1389926--------------------------------------------------------------------------------
1390927
1391928class FromPair arity f where
1392− -- The first component of the parameter tuple is the tag to match.
1393− parsePair :: Text :* TypeName :* Options :* FromArgs arity a
1394− -> Value
1395− -> Maybe (Parser (f a))
929+ parsePair :: Options -> Proxy arity
930+ -> (Value -> Parser a) -> (Value -> Parser [a])
931+ -> Pair -> Maybe (Parser (f a))
1396932
1397933instance ( FromPair arity a
1398934 , FromPair arity b
1399935 ) => FromPair arity (a :+: b) where
1400− parsePair p pair =
1401− (fmap L1 <$> parsePair p pair) <|>
1402− (fmap R1 <$> parsePair p pair)
936+ parsePair opts pa pj pjl pair = (fmap L1 <$> parsePair opts pa pj pjl pair) <|>
937+ (fmap R1 <$> parsePair opts pa pj pjl pair)
1403938
1404939instance ( Constructor c
940+ , GFromJSON arity a
1405941 , ConsFromJSON arity a
1406942 ) => FromPair arity (C1 c a) where
1407− parsePair (tag :* p@(_ :* opts :* _)) v
1408− | tag == tag' = Just $ M1 <$> consParseJSON (cname :* p) v
943+ parsePair opts pa pj pjl (tag, value)
944+ | tag == tag' = Just $ gParseJSON opts pa pj pjl value
1409945 | otherwise = Nothing
1410− where
1411− tag' = pack $ constructorTagModifier opts cname
1412− cname = conName (undefined :: M1 _i c _a _p)
946+ where
947+ tag' = pack $ constructorTagModifier opts $
948+ conName (undefined :: t c a p)
1413949
1414950--------------------------------------------------------------------------------
1415951
1416−class FromUntaggedValue arity f where
1417− parseUntaggedValue :: TypeName :* Options :* FromArgs arity a
1418− -> Value
1419− -> Parser (f a)
1420−
1421−instance
1422− ( FromUntaggedValue arity a
1423− , FromUntaggedValue arity b
1424− ) => FromUntaggedValue arity (a :+: b)
1425− where
1426− parseUntaggedValue p value =
1427− L1 <$> parseUntaggedValue p value <|>
1428− R1 <$> parseUntaggedValue p value
1429−
1430−instance OVERLAPPABLE_
1431− ( ConsFromJSON arity a
1432− , Constructor c
1433− ) => FromUntaggedValue arity (C1 c a)
1434− where
1435− parseUntaggedValue p = fmap M1 . consParseJSON (cname :* p)
1436− where
1437− cname = conName (undefined :: M1 _i c _f _p)
1438−
1439−instance OVERLAPPING_
1440− ( Constructor c )
1441− => FromUntaggedValue arity (C1 c U1)
1442− where
1443− parseUntaggedValue (tname :* opts :* _) v =
1444− contextCons cname tname $ case v of
1445− String tag
1446− | tag == tag' -> pure $ M1 U1
1447− | otherwise -> fail_ tag
1448− _ -> typeMismatch "String" v
1449− where
1450− tag' = pack $ constructorTagModifier opts cname
1451− cname = conName (undefined :: M1 _i c _f _p)
1452− fail_ tag = fail $
1453− "expected tag " ++ show tag' ++ ", but found tag " ++ show tag
952+notFound :: Text -> Parser a
953+notFound key = fail $ "The key \"" ++ unpack key ++ "\" was not found"
954+{-# INLINE notFound #-}
1454955
1455956-------------------------------------------------------------------------------
1456957-- Instances
@@ -1460,6 +961,13 @@ instance OVERLAPPING_
1460961-- base
1461962-------------------------------------------------------------------------------
1462963
964+instance FromJSON1 Identity where
965+ liftParseJSON p _ a = Identity <$> p a
966+ {-# INLINE liftParseJSON #-}
967+
968+instance (FromJSON a) => FromJSON (Identity a) where
969+ parseJSON = parseJSON1
970+ {-# INLINE parseJSON #-}
1463971
1464972instance FromJSON2 Const where
1465973 liftParseJSON2 p _ _ _ = fmap Const . p
@@ -1489,10 +997,6 @@ instance FromJSON2 Either where
1489997 liftParseJSON2 pA _ pB _ (Object (H.toList -> [(key, value)]))
1490998 | key == left = Left <$> pA value <?> Key left
1491999 | key == right = Right <$> pB value <?> Key right
1492− where
1493− left, right :: Text
1494− left = "Left"
1495− right = "Right"
14961000
14971001 liftParseJSON2 _ _ _ _ _ = fail $
14981002 "expected an object with a single property " ++
@@ -1508,20 +1012,20 @@ instance (FromJSON a, FromJSON b) => FromJSON (Either a b) where
15081012 parseJSON = parseJSON2
15091013 {-# INLINE parseJSON #-}
15101014
1511−instance FromJSON Void where
1512− parseJSON _ = fail "Cannot parse Void"
1513− {-# INLINE parseJSON #-}
1015+left, right :: Text
1016+left = "Left"
1017+right = "Right"
1018+
15141019
15151020instance FromJSON Bool where
1516− parseJSON (Bool b) = pure b
1517− parseJSON v = typeMismatch "Bool" v
1021+ parseJSON = withBool "Bool" pure
15181022 {-# INLINE parseJSON #-}
15191023
15201024instance FromJSONKey Bool where
15211025 fromJSONKey = FromJSONKeyTextParser $ \t -> case t of
15221026 "true" -> pure True
15231027 "false" -> pure False
1524− _ -> fail $ "cannot parse key " ++ show t ++ " into Bool"
1028+ _ -> fail $ "Cannot parse key into Bool: " ++ T.unpack t
15251029
15261030instance FromJSON Ordering where
15271031 parseJSON = withText "Ordering" $ \s ->
@@ -1529,30 +1033,25 @@ instance FromJSON Ordering where
15291033 "LT" -> return LT
15301034 "EQ" -> return EQ
15311035 "GT" -> return GT
1532− _ -> fail $ "parsing Ordering failed, unexpected " ++ show s ++
1533− " (expected \"LT\", \"EQ\", or \"GT\")"
1036+ _ -> fail "Parsing Ordering value failed: expected \"LT\", \"EQ\", or \"GT\""
15341037
15351038instance FromJSON () where
15361039 parseJSON = withArray "()" $ \v ->
15371040 if V.null v
15381041 then pure ()
1539− else prependContext "()" $ fail "expected an empty array"
1042+ else fail "Expected an empty array"
15401043 {-# INLINE parseJSON #-}
15411044
15421045instance FromJSON Char where
1543− parseJSON = withText "Char" parseChar
1046+ parseJSON = withText "Char" $ \t ->
1047+ if T.compareLength t 1 == EQ
1048+ then pure $ T.head t
1049+ else fail "Expected a string of length 1"
15441050 {-# INLINE parseJSON #-}
15451051
1546− parseJSONList (String s) = pure (T.unpack s)
1547− parseJSONList v = typeMismatch "String" v
1052+ parseJSONList = withText "String" $ pure . T.unpack
15481053 {-# INLINE parseJSONList #-}
15491054
1550−parseChar :: Text -> Parser Char
1551−parseChar t =
1552− if T.compareLength t 1 == EQ
1553− then pure $ T.head t
1554− else prependContext "Char" $ fail "expected a string of length 1"
1555−
15561055instance FromJSON Double where
15571056 parseJSON = parseRealFloat "Double"
15581057 {-# INLINE parseJSON #-}
@@ -1564,6 +1063,12 @@ instance FromJSONKey Double where
15641063 "-Infinity" -> pure (negate 1/0)
15651064 _ -> Scientific.toRealFloat <$> parseScientificText t
15661065
1066+instance FromJSON Number where
1067+ parseJSON (Number s) = pure $ scientificToNumber s
1068+ parseJSON Null = pure (D (0/0))
1069+ parseJSON v = typeMismatch "Number" v
1070+ {-# INLINE parseJSON #-}
1071+
15671072instance FromJSON Float where
15681073 parseJSON = parseRealFloat "Float"
15691074 {-# INLINE parseJSON #-}
@@ -1576,133 +1081,112 @@ instance FromJSONKey Float where
15761081 _ -> Scientific.toRealFloat <$> parseScientificText t
15771082
15781083instance (FromJSON a, Integral a) => FromJSON (Ratio a) where
1579− parseJSON (Number x)
1580− | exp10 <= 1024
1581− , exp10 >= -1024 = return $! realToFrac x
1582− | otherwise = prependContext "Ratio" $ fail msg
1583− where
1584− exp10 = base10Exponent x
1585− msg = "found a number with exponent " ++ show exp10
1586− ++ ", but it must not be greater than 1024 or less than -1024"
1587− parseJSON o = objParser o
1588− where
1589− objParser = withObject "Rational" $ \obj -> do
1590− numerator <- obj .: "numerator"
1591− denominator <- obj .: "denominator"
1592− if denominator == 0
1593− then fail "Ratio denominator was 0"
1594− else pure $ numerator % denominator
1084+ parseJSON = withObject "Rational" $ \obj ->
1085+ (%) <$> obj .: "numerator"
1086+ <*> obj .: "denominator"
15951087 {-# INLINE parseJSON #-}
15961088
1597−-- | This instance includes a bounds check to prevent maliciously
1598−-- large inputs to fill up the memory of the target system. You can
1599−-- newtype 'Scientific' and provide your own instance using
1600−-- 'withScientific' if you want to allow larger inputs.
1089+-- | /WARNING:/ Only parse fixed-precision numbers from trusted input
1090+-- since an attacker could easily fill up the memory of the target
1091+-- system by specifying a scientific number with a big exponent like
1092+-- @1e1000000000@.
16011093instance HasResolution a => FromJSON (Fixed a) where
1602− parseJSON = prependContext "Fixed" . withBoundedScientific' (pure . realToFrac)
1094+ parseJSON = withScientific "Fixed" $ pure . realToFrac
16031095 {-# INLINE parseJSON #-}
16041096
16051097instance FromJSON Int where
1606− parseJSON = parseBoundedIntegral "Int"
1098+ parseJSON = parseIntegral "Int"
16071099 {-# INLINE parseJSON #-}
16081100
16091101instance FromJSONKey Int where
1610− fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Int"
1102+ fromJSONKey = FromJSONKeyTextParser parseIntegralText
16111103
1612−-- | This instance includes a bounds check to prevent maliciously
1613−-- large inputs to fill up the memory of the target system. You can
1614−-- newtype 'Scientific' and provide your own instance using
1615−-- 'withScientific' if you want to allow larger inputs.
1104+-- | /WARNING:/ Only parse Integers from trusted input since an
1105+-- attacker could easily fill up the memory of the target system by
1106+-- specifying a scientific number with a big exponent like
1107+-- @1e1000000000@.
16161108instance FromJSON Integer where
1617− parseJSON = parseIntegral "Integer"
1109+ parseJSON = withScientific "Integral" $ pure . truncate
16181110 {-# INLINE parseJSON #-}
16191111
16201112instance FromJSONKey Integer where
1621− fromJSONKey = FromJSONKeyTextParser $ parseIntegralText "Integer"
1113+ fromJSONKey = FromJSONKeyTextParser parseIntegralText
16221114
16231115instance FromJSON Natural where
1624− parseJSON value = do
1625− integer <- parseIntegral "Natural" value
1626− parseNatural integer
1116+ parseJSON = withScientific "Natural" $ \s ->
1117+ if Scientific.coefficient s < 0
1118+ then fail $ "Expected a Natural number but got the negative number: " <> show s
1119+ else pure $ truncate s
16271120
16281121instance FromJSONKey Natural where
1629− fromJSONKey = FromJSONKeyTextParser $ \text -> do
1630− integer <- parseIntegralText "Natural" text
1631− parseNatural integer
1632−
1633−parseNatural :: Integer -> Parser Natural
1634−parseNatural integer =
1635− if integer < 0 then
1636− fail $ "parsing Natural failed, unexpected negative number " <> show integer
1637− else
1638− pure $ fromIntegral integer
1122+ fromJSONKey = FromJSONKeyTextParser $ \t -> parseScientificText t >>= \s ->
1123+ if Scientific.coefficient s < 0
1124+ then fail $ "Expected a Natural number but got the negative number: " <> show s
1125+ else pure $ truncate s
16391126
16401127instance FromJSON Int8 where
1641− parseJSON = parseBoundedIntegral "Int8"
1128+ parseJSON = parseIntegral "Int8"
16421129 {-# INLINE parseJSON #-}
16431130
16441131instance FromJSONKey Int8 where
1645− fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Int8"
1132+ fromJSONKey = FromJSONKeyTextParser parseIntegralText
16461133
16471134instance FromJSON Int16 where
1648− parseJSON = parseBoundedIntegral "Int16"
1135+ parseJSON = parseIntegral "Int16"
16491136 {-# INLINE parseJSON #-}
16501137
16511138instance FromJSONKey Int16 where
1652− fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Int16"
1139+ fromJSONKey = FromJSONKeyTextParser parseIntegralText
16531140
16541141instance FromJSON Int32 where
1655− parseJSON = parseBoundedIntegral "Int32"
1142+ parseJSON = parseIntegral "Int32"
16561143 {-# INLINE parseJSON #-}
16571144
16581145instance FromJSONKey Int32 where
1659− fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Int32"
1146+ fromJSONKey = FromJSONKeyTextParser parseIntegralText
16601147
16611148instance FromJSON Int64 where
1662− parseJSON = parseBoundedIntegral "Int64"
1149+ parseJSON = parseIntegral "Int64"
16631150 {-# INLINE parseJSON #-}
16641151
16651152instance FromJSONKey Int64 where
1666− fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Int64"
1153+ fromJSONKey = FromJSONKeyTextParser parseIntegralText
16671154
16681155instance FromJSON Word where
1669− parseJSON = parseBoundedIntegral "Word"
1156+ parseJSON = parseIntegral "Word"
16701157 {-# INLINE parseJSON #-}
16711158
16721159instance FromJSONKey Word where
1673− fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Word"
1160+ fromJSONKey = FromJSONKeyTextParser parseIntegralText
16741161
16751162instance FromJSON Word8 where
1676− parseJSON = parseBoundedIntegral "Word8"
1163+ parseJSON = parseIntegral "Word8"
16771164 {-# INLINE parseJSON #-}
16781165
16791166instance FromJSONKey Word8 where
1680− fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Word8"
1167+ fromJSONKey = FromJSONKeyTextParser parseIntegralText
16811168
16821169instance FromJSON Word16 where
1683− parseJSON = parseBoundedIntegral "Word16"
1170+ parseJSON = parseIntegral "Word16"
16841171 {-# INLINE parseJSON #-}
16851172
16861173instance FromJSONKey Word16 where
1687− fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Word16"
1174+ fromJSONKey = FromJSONKeyTextParser parseIntegralText
16881175
16891176instance FromJSON Word32 where
1690− parseJSON = parseBoundedIntegral "Word32"
1177+ parseJSON = parseIntegral "Word32"
16911178 {-# INLINE parseJSON #-}
16921179
16931180instance FromJSONKey Word32 where
1694− fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Word32"
1181+ fromJSONKey = FromJSONKeyTextParser parseIntegralText
16951182
16961183instance FromJSON Word64 where
1697− parseJSON = parseBoundedIntegral "Word64"
1184+ parseJSON = parseIntegral "Word64"
16981185 {-# INLINE parseJSON #-}
16991186
17001187instance FromJSONKey Word64 where
1701− fromJSONKey = FromJSONKeyTextParser $ parseBoundedIntegralText "Word64"
1188+ fromJSONKey = FromJSONKeyTextParser parseIntegralText
17021189
1703−instance FromJSON CTime where
1704− parseJSON = fmap CTime . parseJSON
1705− {-# INLINE parseJSON #-}
17061190
17071191instance FromJSON Text where
17081192 parseJSON = withText "Text" pure
@@ -1732,17 +1216,17 @@ parseVersionText = go . readP_to_S parseVersion . unpack
17321216 where
17331217 go [(v,[])] = return v
17341218 go (_ : xs) = go xs
1735− go _ = fail "parsing Version failed"
1219+ go _ = fail $ "could not parse Version"
17361220
17371221-------------------------------------------------------------------------------
17381222-- semigroups NonEmpty
17391223-------------------------------------------------------------------------------
17401224
17411225instance FromJSON1 NonEmpty where
1742− liftParseJSON p _ = withArray "NonEmpty" $
1226+ liftParseJSON p _ = withArray "NonEmpty a" $
17431227 (>>= ne) . Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
17441228 where
1745− ne [] = fail "parsing NonEmpty failed, unexpected empty list"
1229+ ne [] = fail "Expected a NonEmpty but got an empty list"
17461230 ne (x:xs) = pure (x :| xs)
17471231 {-# INLINE liftParseJSON #-}
17481232
@@ -1763,7 +1247,7 @@ instance FromJSON Scientific where
17631247-------------------------------------------------------------------------------
17641248
17651249instance FromJSON1 DList.DList where
1766− liftParseJSON p _ = withArray "DList" $
1250+ liftParseJSON p _ = withArray "DList a" $
17671251 fmap DList.fromList .
17681252 Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
17691253 {-# INLINE liftParseJSON #-}
@@ -1772,89 +1256,12 @@ instance (FromJSON a) => FromJSON (DList.DList a) where
17721256 parseJSON = parseJSON1
17731257 {-# INLINE parseJSON #-}
17741258
1775−-------------------------------------------------------------------------------
1776−-- tranformers - Functors
1777−-------------------------------------------------------------------------------
1778−
1779−instance FromJSON1 Identity where
1780− liftParseJSON p _ a = Identity <$> p a
1781− {-# INLINE liftParseJSON #-}
1782−
1783− liftParseJSONList _ p a = fmap Identity <$> p a
1784− {-# INLINE liftParseJSONList #-}
1785−
1786−instance (FromJSON a) => FromJSON (Identity a) where
1787− parseJSON = parseJSON1
1788− {-# INLINE parseJSON #-}
1789−
1790− parseJSONList = liftParseJSONList parseJSON parseJSONList
1791− {-# INLINE parseJSONList #-}
1792−
1793−instance (FromJSONKey a) => FromJSONKey (Identity a) where
1794− fromJSONKey = coerceFromJSONKeyFunction (fromJSONKey :: FromJSONKeyFunction a)
1795− fromJSONKeyList = coerceFromJSONKeyFunction (fromJSONKeyList :: FromJSONKeyFunction [a])
1796−
1797−
1798−instance (FromJSON1 f, FromJSON1 g) => FromJSON1 (Compose f g) where
1799− liftParseJSON p pl a = Compose <$> liftParseJSON g gl a
1800− where
1801− g = liftParseJSON p pl
1802− gl = liftParseJSONList p pl
1803− {-# INLINE liftParseJSON #-}
1804−
1805− liftParseJSONList p pl a = map Compose <$> liftParseJSONList g gl a
1806− where
1807− g = liftParseJSON p pl
1808− gl = liftParseJSONList p pl
1809− {-# INLINE liftParseJSONList #-}
1810−
1811−instance (FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Compose f g a) where
1812− parseJSON = parseJSON1
1813− {-# INLINE parseJSON #-}
1814−
1815− parseJSONList = liftParseJSONList parseJSON parseJSONList
1816− {-# INLINE parseJSONList #-}
1817−
1818−
1819−instance (FromJSON1 f, FromJSON1 g) => FromJSON1 (Product f g) where
1820− liftParseJSON p pl a = uncurry Pair <$> liftParseJSON2 px pxl py pyl a
1821− where
1822− px = liftParseJSON p pl
1823− pxl = liftParseJSONList p pl
1824− py = liftParseJSON p pl
1825− pyl = liftParseJSONList p pl
1826− {-# INLINE liftParseJSON #-}
1827−
1828−instance (FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Product f g a) where
1829− parseJSON = parseJSON1
1830− {-# INLINE parseJSON #-}
1831−
1832−
1833−instance (FromJSON1 f, FromJSON1 g) => FromJSON1 (Sum f g) where
1834− liftParseJSON p pl (Object (H.toList -> [(key, value)]))
1835− | key == inl = InL <$> liftParseJSON p pl value <?> Key inl
1836− | key == inr = InR <$> liftParseJSON p pl value <?> Key inl
1837− where
1838− inl, inr :: Text
1839− inl = "InL"
1840− inr = "InR"
1841−
1842− liftParseJSON _ _ _ = fail $
1843− "parsing Sum failed, expected an object with a single property " ++
1844− "where the property key should be either " ++
1845− "\"InL\" or \"InR\""
1846− {-# INLINE liftParseJSON #-}
1847−
1848−instance (FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Sum f g a) where
1849− parseJSON = parseJSON1
1850− {-# INLINE parseJSON #-}
1851−
18521259-------------------------------------------------------------------------------
18531260-- containers
18541261-------------------------------------------------------------------------------
18551262
18561263instance FromJSON1 Seq.Seq where
1857− liftParseJSON p _ = withArray "Seq" $
1264+ liftParseJSON p _ = withArray "Seq a" $
18581265 fmap Seq.fromList .
18591266 Tr.sequence . zipWith (parseIndexedJSON p) [0..] . V.toList
18601267 {-# INLINE liftParseJSON #-}
@@ -1888,15 +1295,15 @@ instance FromJSON a => FromJSON (IntMap.IntMap a) where
18881295
18891296instance (FromJSONKey k, Ord k) => FromJSON1 (M.Map k) where
18901297 liftParseJSON p _ = case fromJSONKey of
1891− FromJSONKeyCoerce _ -> withObject "Map" $
1298+ FromJSONKeyCoerce _-> withObject "Map k v" $
18921299 fmap (H.foldrWithKey (M.insert . unsafeCoerce) M.empty) . H.traverseWithKey (\k v -> p v <?> Key k)
1893− FromJSONKeyText f -> withObject "Map" $
1300+ FromJSONKeyText f -> withObject "Map k v" $
18941301 fmap (H.foldrWithKey (M.insert . f) M.empty) . H.traverseWithKey (\k v -> p v <?> Key k)
1895− FromJSONKeyTextParser f -> withObject "Map" $
1896− H.foldrWithKey (\k v m -> M.insert <$> f k <?> Key k <*> p v <?> Key k <*> m) (pure M.empty)
1897− FromJSONKeyValue f -> withArray "Map" $ \arr ->
1898− fmap M.fromList . Tr.sequence .
1899− zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr
1302+ FromJSONKeyTextParser f -> withObject "Map k v" $
1303+ H.foldrWithKey (\k v m -> M.insert <$> f k <*> (p v <?> Key k) <*> m) (pure M.empty)
1304+ FromJSONKeyValue f -> withArray "Map k v" $ \arr ->
1305+ M.fromList <$> (Tr.sequence .
1306+ zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr)
19001307 {-# INLINE liftParseJSON #-}
19011308
19021309instance (FromJSONKey k, Ord k, FromJSON v) => FromJSON (M.Map k v) where
@@ -1916,24 +1323,12 @@ instance (FromJSON v) => FromJSON (Tree.Tree v) where
19161323 parseJSON = parseJSON1
19171324 {-# INLINE parseJSON #-}
19181325
1919−-------------------------------------------------------------------------------
1920−-- uuid
1921−-------------------------------------------------------------------------------
1922−
1923−instance FromJSON UUID.UUID where
1924− parseJSON = withText "UUID" $
1925− maybe (fail "invalid UUID") pure . UUID.fromText
1926−
1927−instance FromJSONKey UUID.UUID where
1928− fromJSONKey = FromJSONKeyTextParser $
1929− maybe (fail "invalid UUID") pure . UUID.fromText
1930−
19311326-------------------------------------------------------------------------------
19321327-- vector
19331328-------------------------------------------------------------------------------
19341329
19351330instance FromJSON1 Vector where
1936− liftParseJSON p _ = withArray "Vector" $
1331+ liftParseJSON p _ = withArray "Vector a" $
19371332 V.mapM (uncurry $ parseIndexedJSON p) . V.indexed
19381333 {-# INLINE liftParseJSON #-}
19391334
@@ -1947,14 +1342,14 @@ vectorParseJSON s = withArray s $ fmap V.convert . V.mapM (uncurry $ parseIndexe
19471342{-# INLINE vectorParseJSON #-}
19481343
19491344instance (Storable a, FromJSON a) => FromJSON (VS.Vector a) where
1950− parseJSON = vectorParseJSON "Data.Vector.Storable.Vector"
1345+ parseJSON = vectorParseJSON "Data.Vector.Storable.Vector a"
19511346
19521347instance (VP.Prim a, FromJSON a) => FromJSON (VP.Vector a) where
1953− parseJSON = vectorParseJSON "Data.Vector.Primitive.Vector"
1348+ parseJSON = vectorParseJSON "Data.Vector.Primitive.Vector a"
19541349 {-# INLINE parseJSON #-}
19551350
19561351instance (VG.Vector VU.Vector a, FromJSON a) => FromJSON (VU.Vector a) where
1957− parseJSON = vectorParseJSON "Data.Vector.Unboxed.Vector"
1352+ parseJSON = vectorParseJSON "Data.Vector.Unboxed.Vector a"
19581353 {-# INLINE parseJSON #-}
19591354
19601355-------------------------------------------------------------------------------
@@ -1968,15 +1363,15 @@ instance (Eq a, Hashable a, FromJSON a) => FromJSON (HashSet.HashSet a) where
19681363
19691364instance (FromJSONKey k, Eq k, Hashable k) => FromJSON1 (H.HashMap k) where
19701365 liftParseJSON p _ = case fromJSONKey of
1971− FromJSONKeyCoerce _ -> withObject "HashMap ~Text" $
1366+ FromJSONKeyCoerce _ -> withObject "HashMap ~Text v" $
19721367 uc . H.traverseWithKey (\k v -> p v <?> Key k)
1973− FromJSONKeyText f -> withObject "HashMap" $
1368+ FromJSONKeyText f -> withObject "HashMap k v" $
19741369 fmap (mapKey f) . H.traverseWithKey (\k v -> p v <?> Key k)
1975− FromJSONKeyTextParser f -> withObject "HashMap" $
1976− H.foldrWithKey (\k v m -> H.insert <$> f k <?> Key k <*> p v <?> Key k <*> m) (pure H.empty)
1977− FromJSONKeyValue f -> withArray "Map" $ \arr ->
1978− fmap H.fromList . Tr.sequence .
1979− zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr
1370+ FromJSONKeyTextParser f -> withObject "HashMap k v" $
1371+ H.foldrWithKey (\k v m -> H.insert <$> f k <*> (p v <?> Key k) <*> m) (pure H.empty)
1372+ FromJSONKeyValue f -> withArray "Map k v" $ \arr ->
1373+ H.fromList <$> (Tr.sequence .
1374+ zipWith (parseIndexedJSONPair f p) [0..] . V.toList $ arr)
19801375 where
19811376 uc :: Parser (H.HashMap Text v) -> Parser (H.HashMap k v)
19821377 uc = unsafeCoerce
@@ -1997,33 +1392,11 @@ instance FromJSON DotNetTime where
19971392 parseJSON = withText "DotNetTime" $ \t ->
19981393 let (s,m) = T.splitAt (T.length t - 5) t
19991394 t' = T.concat [s,".",m]
2000− in case parseTimeM True defaultTimeLocale "/Date(%s%Q)/" (unpack t') of
1395+ in case parseTime defaultTimeLocale "/Date(%s%Q)/" (unpack t') of
20011396 Just d -> pure (DotNetTime d)
20021397 _ -> fail "could not parse .NET time"
20031398 {-# INLINE parseJSON #-}
20041399
2005−-------------------------------------------------------------------------------
2006−-- primitive
2007−-------------------------------------------------------------------------------
2008−
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
2013−
2014−instance FromJSON a => FromJSON (PM.SmallArray a) where
2015− parseJSON = fmap Exts.fromList . parseJSON
2016−
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
2020−
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
2024−#endif
2025−#endif
2026−
20271400-------------------------------------------------------------------------------
20281401-- time
20291402-------------------------------------------------------------------------------
@@ -2049,17 +1422,6 @@ instance FromJSONKey LocalTime where
20491422 fromJSONKey = FromJSONKeyTextParser (Time.run Time.localTime)
20501423
20511424
2052−-- | Supported string formats:
2053−--
2054−-- @YYYY-MM-DD HH:MM Z@
2055−-- @YYYY-MM-DD HH:MM:SS Z@
2056−-- @YYYY-MM-DD HH:MM:SS.SSS Z@
2057−--
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.
20631425instance FromJSON ZonedTime where
20641426 parseJSON = withText "ZonedTime" (Time.run Time.zonedTime)
20651427
@@ -2074,168 +1436,41 @@ instance FromJSONKey UTCTime where
20741436 fromJSONKey = FromJSONKeyTextParser (Time.run Time.utcTime)
20751437
20761438
2077−-- | This instance includes a bounds check to prevent maliciously
2078−-- large inputs to fill up the memory of the target system. You can
2079−-- newtype 'Scientific' and provide your own instance using
2080−-- 'withScientific' if you want to allow larger inputs.
1439+-- | /WARNING:/ Only parse lengths of time from trusted input
1440+-- since an attacker could easily fill up the memory of the target
1441+-- system by specifying a scientific number with a big exponent like
1442+-- @1e1000000000@.
20811443instance FromJSON NominalDiffTime where
2082− parseJSON = withBoundedScientific "NominalDiffTime" $ pure . realToFrac
1444+ parseJSON = withScientific "NominalDiffTime" $ pure . realToFrac
20831445 {-# INLINE parseJSON #-}
20841446
2085−
2086−-- | This instance includes a bounds check to prevent maliciously
2087−-- large inputs to fill up the memory of the target system. You can
2088−-- newtype 'Scientific' and provide your own instance using
2089−-- 'withScientific' if you want to allow larger inputs.
2090−instance FromJSON DiffTime where
2091− parseJSON = withBoundedScientific "DiffTime" $ pure . realToFrac
2092− {-# INLINE parseJSON #-}
2093−
2094−instance FromJSON SystemTime where
2095− parseJSON v = prependContext "SystemTime" $ do
2096− n <- parseJSON v
2097− let n' = floor (n * fromInteger (resolution n) :: Nano)
2098− let (secs, nano) = n' `divMod` resolution n
2099− return (MkSystemTime (fromInteger secs) (fromInteger nano))
2100−
2101−instance FromJSON CalendarDiffTime where
2102− parseJSON = withObject "CalendarDiffTime" $ \obj -> CalendarDiffTime
2103− <$> obj .: "months"
2104− <*> obj .: "time"
2105−
2106−instance FromJSON CalendarDiffDays where
2107− parseJSON = withObject "CalendarDiffDays" $ \obj -> CalendarDiffDays
2108− <$> obj .: "months"
2109− <*> obj .: "days"
2110−
2111−instance FromJSON DayOfWeek where
2112− parseJSON = withText "DaysOfWeek" parseDayOfWeek
2113−
2114−parseDayOfWeek :: T.Text -> Parser DayOfWeek
2115−parseDayOfWeek t = case T.toLower t of
2116− "monday" -> return Monday
2117− "tuesday" -> return Tuesday
2118− "wednesday" -> return Wednesday
2119− "thursday" -> return Thursday
2120− "friday" -> return Friday
2121− "saturday" -> return Saturday
2122− "sunday" -> return Sunday
2123− _ -> fail "Invalid week day"
2124−
2125−instance FromJSONKey DayOfWeek where
2126− fromJSONKey = FromJSONKeyTextParser parseDayOfWeek
2127−
21281447-------------------------------------------------------------------------------
21291448-- base Monoid/Semigroup
21301449-------------------------------------------------------------------------------
21311450
2132−instance FromJSON1 Monoid.Dual where
2133− liftParseJSON p _ = fmap Monoid.Dual . p
1451+instance FromJSON1 Dual where
1452+ liftParseJSON p _ = fmap Dual . p
21341453 {-# INLINE liftParseJSON #-}
21351454
2136−instance FromJSON a => FromJSON (Monoid.Dual a) where
1455+instance FromJSON a => FromJSON (Dual a) where
21371456 parseJSON = parseJSON1
21381457 {-# INLINE parseJSON #-}
21391458
21401459
2141−instance FromJSON1 Monoid.First where
2142− liftParseJSON p p' = fmap Monoid.First . liftParseJSON p p'
1460+instance FromJSON1 First where
1461+ liftParseJSON p p' = fmap First . liftParseJSON p p'
21431462 {-# INLINE liftParseJSON #-}
21441463
2145−instance FromJSON a => FromJSON (Monoid.First a) where
1464+instance FromJSON a => FromJSON (First a) where
21461465 parseJSON = parseJSON1
21471466 {-# INLINE parseJSON #-}
21481467
21491468
2150−instance FromJSON1 Monoid.Last where
2151− liftParseJSON p p' = fmap Monoid.Last . liftParseJSON p p'
1469+instance FromJSON1 Last where
1470+ liftParseJSON p p' = fmap Last . liftParseJSON p p'
21521471 {-# INLINE liftParseJSON #-}
21531472
2154−instance FromJSON a => FromJSON (Monoid.Last a) where
2155− parseJSON = parseJSON1
2156− {-# INLINE parseJSON #-}
2157−
2158−
2159−instance FromJSON1 Semigroup.Min where
2160− liftParseJSON p _ a = Semigroup.Min <$> p a
2161− {-# INLINE liftParseJSON #-}
2162−
2163− liftParseJSONList _ p a = fmap Semigroup.Min <$> p a
2164− {-# INLINE liftParseJSONList #-}
2165−
2166−instance (FromJSON a) => FromJSON (Semigroup.Min a) where
2167− parseJSON = parseJSON1
2168− {-# INLINE parseJSON #-}
2169−
2170− parseJSONList = liftParseJSONList parseJSON parseJSONList
2171− {-# INLINE parseJSONList #-}
2172−
2173−
2174−instance FromJSON1 Semigroup.Max where
2175− liftParseJSON p _ a = Semigroup.Max <$> p a
2176− {-# INLINE liftParseJSON #-}
2177−
2178− liftParseJSONList _ p a = fmap Semigroup.Max <$> p a
2179− {-# INLINE liftParseJSONList #-}
2180−
2181−instance (FromJSON a) => FromJSON (Semigroup.Max a) where
2182− parseJSON = parseJSON1
2183− {-# INLINE parseJSON #-}
2184−
2185− parseJSONList = liftParseJSONList parseJSON parseJSONList
2186− {-# INLINE parseJSONList #-}
2187−
2188−
2189−instance FromJSON1 Semigroup.First where
2190− liftParseJSON p _ a = Semigroup.First <$> p a
2191− {-# INLINE liftParseJSON #-}
2192−
2193− liftParseJSONList _ p a = fmap Semigroup.First <$> p a
2194− {-# INLINE liftParseJSONList #-}
2195−
2196−instance (FromJSON a) => FromJSON (Semigroup.First a) where
2197− parseJSON = parseJSON1
2198− {-# INLINE parseJSON #-}
2199−
2200− parseJSONList = liftParseJSONList parseJSON parseJSONList
2201− {-# INLINE parseJSONList #-}
2202−
2203−
2204−instance FromJSON1 Semigroup.Last where
2205− liftParseJSON p _ a = Semigroup.Last <$> p a
2206− {-# INLINE liftParseJSON #-}
2207−
2208− liftParseJSONList _ p a = fmap Semigroup.Last <$> p a
2209− {-# INLINE liftParseJSONList #-}
2210−
2211−instance (FromJSON a) => FromJSON (Semigroup.Last a) where
2212− parseJSON = parseJSON1
2213− {-# INLINE parseJSON #-}
2214−
2215− parseJSONList = liftParseJSONList parseJSON parseJSONList
2216− {-# INLINE parseJSONList #-}
2217−
2218−
2219−instance FromJSON1 Semigroup.WrappedMonoid where
2220− liftParseJSON p _ a = Semigroup.WrapMonoid <$> p a
2221− {-# INLINE liftParseJSON #-}
2222−
2223− liftParseJSONList _ p a = fmap Semigroup.WrapMonoid <$> p a
2224− {-# INLINE liftParseJSONList #-}
2225−
2226−instance (FromJSON a) => FromJSON (Semigroup.WrappedMonoid a) where
2227− parseJSON = parseJSON1
2228− {-# INLINE parseJSON #-}
2229−
2230− parseJSONList = liftParseJSONList parseJSON parseJSONList
2231− {-# INLINE parseJSONList #-}
2232−
2233−
2234−instance FromJSON1 Semigroup.Option where
2235− liftParseJSON p p' = fmap Semigroup.Option . liftParseJSON p p'
2236− {-# INLINE liftParseJSON #-}
2237−
2238−instance FromJSON a => FromJSON (Semigroup.Option a) where
1473+instance FromJSON a => FromJSON (Last a) where
22391474 parseJSON = parseJSON1
22401475 {-# INLINE parseJSON #-}
22411476
@@ -2243,21 +1478,11 @@ instance FromJSON a => FromJSON (Semigroup.Option a) where
22431478-- tagged
22441479-------------------------------------------------------------------------------
22451480
2246−instance FromJSON1 Proxy where
2247− {-# INLINE liftParseJSON #-}
2248− liftParseJSON _ _ = fromNull "Proxy" Proxy
2249−
22501481instance FromJSON (Proxy a) where
22511482 {-# INLINE parseJSON #-}
2252− parseJSON = fromNull "Proxy" Proxy
2253−
2254−fromNull :: String -> a -> Value -> Parser a
2255−fromNull _ a Null = pure a
2256−fromNull c _ v = prependContext c (typeMismatch "Null" v)
1483+ parseJSON Null = pure Proxy
1484+ parseJSON v = typeMismatch "Proxy" v
22571485
2258−instance FromJSON2 Tagged where
2259− liftParseJSON2 _ _ p _ = fmap Tagged . p
2260− {-# INLINE liftParseJSON2 #-}
22611486
22621487instance FromJSON1 (Tagged a) where
22631488 liftParseJSON p _ = fmap Tagged . p
@@ -2280,17 +1505,23 @@ instance (FromJSON a, FromJSON b, FromJSON c) => FromJSONKey (a,b,c)
22801505instance (FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSONKey (a,b,c,d)
22811506
22821507instance FromJSONKey Char where
2283− fromJSONKey = FromJSONKeyTextParser parseChar
1508+ fromJSONKey = FromJSONKeyTextParser $ \t ->
1509+ if T.length t == 1
1510+ then return (T.index t 0)
1511+ else typeMismatch "Expected Char but String didn't contain exactly one character" (String t)
22841512 fromJSONKeyList = FromJSONKeyText T.unpack
22851513
22861514instance (FromJSONKey a, FromJSON a) => FromJSONKey [a] where
22871515 fromJSONKey = fromJSONKeyList
22881516
1517+instance (FromJSONKey a, FromJSON a) => FromJSONKey (Identity a) where
1518+ fromJSONKey = mapFromJSONKeyFunction Identity fromJSONKey
1519+
22891520-------------------------------------------------------------------------------
22901521-- Tuple instances, see tuple-instances-from.hs
22911522-------------------------------------------------------------------------------
22921523
2293−instance FromJSON2 (,) where
1524+instance FromJSON2 ((,) ) where
22941525 liftParseJSON2 pA _ pB _ = withArray "(a, b)" $ \t ->
22951526 let n = V.length t
22961527 in if n == 2