yaml-0.8.22: Support for parsing and rendering YAML documents.

Safe Haskell | None
Language | Haskell98

Data.Yaml.TH

Contents

- Decoding
- Re-exports from Data.Yaml

Synopsis

- decodeFile :: forall a. (Lift a, FromJSON a) => FilePath -> Q (TExp a)
- data Value :: *
  - = Object ~Object
  - | Array ~Array
  - | String ~Text
  - | Number ~Scientific
  - | Bool ~Bool
  - | Null
- data Parser a :: * -> *
- type Object = HashMap Text Value
- type Array = Vector Value
- object :: [Pair] -> Value
- array :: [Value] -> Value
- (.=) :: KeyValue kv => forall v. ToJSON v => Text -> v -> kv
- (.:) :: FromJSON a => Object -> Text -> Parser a
- (.:?) :: FromJSON a => Object -> Text -> Parser (Maybe a)
- (.!=) :: Parser (Maybe a) -> a -> Parser a
- class FromJSON a where
  - parseJSON :: Value -> Parser a
  - parseJSONList :: Value -> Parser [a]

# Decoding

decodeFile :: forall a. (Lift a, FromJSON a) => FilePath -> Q (TExp a) #

Decode a `yaml` file at compile time. Only available on GHC version `7.8.1` or higher.

#### Examples

    {-# LANGUAGE TemplateHaskell #-}

    config :: Config
    config = $$(decodeFile "config.yaml")

Since: 0.8.19.0

# Re-exports from Data.Yaml

data Value :: * #

A JSON value represented as a Haskell value.

Constructors

Object ~Object |
Array ~Array |
String ~Text |
Number ~Scientific |
Bool ~Bool |
Null |

Instances

Eq Value |
Methods (==) :: Value -> Value -> Bool # (/=) :: Value -> Value -> Bool #
Data Value |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Value -> c Value # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Value # toConstr :: Value -> Constr # dataTypeOf :: Value -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Value) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Value) # gmapT :: (forall b. Data b => b -> b) -> Value -> Value # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r # gmapQ :: (forall d. Data d => d -> u) -> Value -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Value -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Value -> m Value # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Value -> m Value # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Value -> m Value #
Read Value |
Methods readsPrec :: Int -> ReadS Value # readList :: ReadS [Value] # readPrec :: ReadPrec Value # readListPrec :: ReadPrec [Value] #
Show Value |
Methods showsPrec :: Int -> Value -> ShowS # show :: Value -> String # showList :: [Value] -> ShowS #
IsString Value |
Methods fromString :: String -> Value #
Lift Value |
Methods lift :: Value -> Q Exp #
Hashable Value |
Methods hashWithSalt :: Int -> Value -> Int # hash :: Value -> Int #
FromJSON Value |
Methods parseJSON :: Value -> Parser Value # parseJSONList :: Value -> Parser [Value] #
ToJSON Value |
Methods toJSON :: Value -> Value # toEncoding :: Value -> Encoding # toJSONList :: [Value] -> Value # toEncodingList :: [Value] -> Encoding #
KeyValue Pair |
Methods (.=) :: ToJSON v => Text -> v -> Pair #
NFData Value |
Methods rnf :: Value -> () #

data Parser a :: * -> * #

A JSON parser.

Instances

Monad Parser |
Methods (>>=) :: Parser a -> (a -> Parser b) -> Parser b # (>>) :: Parser a -> Parser b -> Parser b # return :: a -> Parser a # fail :: String -> Parser a #
Functor Parser |
Methods fmap :: (a -> b) -> Parser a -> Parser b # (<$) :: a -> Parser b -> Parser a #
MonadFail Parser |
Methods fail :: String -> Parser a #
Applicative Parser |
Methods pure :: a -> Parser a # (<*>) :: Parser (a -> b) -> Parser a -> Parser b # (*>) :: Parser a -> Parser b -> Parser b # (<*) :: Parser a -> Parser b -> Parser a #
Alternative Parser |
Methods empty :: Parser a # (<|>) :: Parser a -> Parser a -> Parser a # some :: Parser a -> Parser [a] # many :: Parser a -> Parser [a] #
MonadPlus Parser |
Methods mzero :: Parser a # mplus :: Parser a -> Parser a -> Parser a #
Semigroup (Parser a) |
Methods (<>) :: Parser a -> Parser a -> Parser a # sconcat :: NonEmpty (Parser a) -> Parser a # stimes :: Integral b => b -> Parser a -> Parser a #
Monoid (Parser a) |
Methods mempty :: Parser a # mappend :: Parser a -> Parser a -> Parser a # mconcat :: [Parser a] -> Parser a #

type Object = HashMap Text Value #

A JSON "object" (key/value map).

type Array = Vector Value #

A JSON "array" (sequence).

object :: [Pair] -> Value #

Create a `Value` from a list of name/value `Pair`s. If duplicate keys arise, earlier keys and their associated values win.

array :: [Value] -> Value #

(.=) :: KeyValue kv => forall v. ToJSON v => Text -> v -> kv #

(.:) :: FromJSON a => Object -> Text -> Parser a #

Retrieve the value associated with the given key of an `Object`. The result is `empty` if the key is not present or the value cannot be converted to the desired type.

This accessor is appropriate if the key and value must be present in an object for it to be valid. If the key and value are optional, use `.:?` instead.

(.:?) :: FromJSON a => Object -> Text -> Parser (Maybe a) #

Retrieve the value associated with the given key of an `Object`. The result is `Nothing` if the key is not present or if its value is `Null`, or `empty` if the value cannot be converted to the desired type.

This accessor is most useful if the key and value can be absent from an object without affecting its validity. If the key and value are mandatory, use `.:` instead.

(.!=) :: Parser (Maybe a) -> a -> Parser a #

Helper for use in combination with `.:?` to provide default values for optional JSON object fields.

This combinator is most useful if the key and value can be absent from an object without affecting its validity and we know a default value to assign in that case. If the key and value are mandatory, use `.:` instead.

Example usage:

     v1 <- o .:? "opt_field_with_dfl" .!= "default_val"
     v2 <- o .:  "mandatory_field"
     v3 <- o .:? "opt_field2"

class FromJSON a where #

A type that can be converted from JSON, with the possibility of failure.

In many cases, you can get the compiler to generate parsing code for you (see below). To begin, let's cover writing an instance by hand.

There are various reasons a conversion could fail. For example, an `Object` could be missing a required key, an `Array` could be of the wrong size, or a value could be of an incompatible type.

The basic ways to signal a failed conversion are as follows:

- `empty` and `mzero` work, but are terse and uninformative
- `fail` yields a custom error message
- `typeMismatch` produces an informative message for cases when the value encountered is not of the expected type

An example type and instance:

    -- Allow ourselves to write Text literals.
    {-# LANGUAGE OverloadedStrings #-}

    data Coord = Coord { x :: Double, y :: Double }

    instance FromJSON Coord where
      parseJSON (Object v) = Coord    <$>
                             v .: "x" <*>
                             v .: "y"

      -- We do not expect a non-Object value here.
      -- We could use mzero to fail, but typeMismatch
      -- gives a much more informative error message.
      parseJSON invalid    = typeMismatch "Coord" invalid

Instead of manually writing your `FromJSON` instance, there are two options to do it automatically:

- Data.Aeson.TH provides Template Haskell functions which will derive an instance at compile time. The generated instance is optimized for your type so will probably be more efficient than the following two options:
- The compiler can provide a default generic implementation for `parseJSON`.

To use the second, simply add a `deriving `Generic`` clause to your datatype and declare a `FromJSON` instance for your datatype without giving a definition for `parseJSON`.

For example, the previous example can be simplified to just:

    {-# LANGUAGE DeriveGeneric #-}

    import GHC.Generics

    data Coord = Coord { x :: Double, y :: Double } deriving Generic

    instance FromJSON Coord

If `DefaultSignatures` doesn't give exactly the results you want, you can customize the generic decoding with only a tiny amount of effort, using `genericParseJSON` with your preferred `Options`:

    instance FromJSON Coord where
        parseJSON = genericParseJSON defaultOptions

Minimal complete definition

Nothing

Instances

FromJSON Bool |
Methods parseJSON :: Value -> Parser Bool # parseJSONList :: Value -> Parser [Bool] #
FromJSON Char |
Methods parseJSON :: Value -> Parser Char # parseJSONList :: Value -> Parser [Char] #
FromJSON Double |
Methods parseJSON :: Value -> Parser Double # parseJSONList :: Value -> Parser [Double] #
FromJSON Float |
Methods parseJSON :: Value -> Parser Float # parseJSONList :: Value -> Parser [Float] #
FromJSON Int |
Methods parseJSON :: Value -> Parser Int # parseJSONList :: Value -> Parser [Int] #
FromJSON Int8 |
Methods parseJSON :: Value -> Parser Int8 # parseJSONList :: Value -> Parser [Int8] #
FromJSON Int16 |
Methods parseJSON :: Value -> Parser Int16 # parseJSONList :: Value -> Parser [Int16] #
FromJSON Int32 |
Methods parseJSON :: Value -> Parser Int32 # parseJSONList :: Value -> Parser [Int32] #
FromJSON Int64 |
Methods parseJSON :: Value -> Parser Int64 # parseJSONList :: Value -> Parser [Int64] #
FromJSON Integer | WARNING: Only parse Integers from trusted input since an attacker could easily fill up the memory of the target system by specifying a scientific number with a big exponent like `1e1000000000`.
Methods parseJSON :: Value -> Parser Integer # parseJSONList :: Value -> Parser [Integer] #
FromJSON Ordering |
Methods parseJSON :: Value -> Parser Ordering # parseJSONList :: Value -> Parser [Ordering] #
FromJSON Word |
Methods parseJSON :: Value -> Parser Word # parseJSONList :: Value -> Parser [Word] #
FromJSON Word8 |
Methods parseJSON :: Value -> Parser Word8 # parseJSONList :: Value -> Parser [Word8] #
FromJSON Word16 |
Methods parseJSON :: Value -> Parser Word16 # parseJSONList :: Value -> Parser [Word16] #
FromJSON Word32 |
Methods parseJSON :: Value -> Parser Word32 # parseJSONList :: Value -> Parser [Word32] #
FromJSON Word64 |
Methods parseJSON :: Value -> Parser Word64 # parseJSONList :: Value -> Parser [Word64] #
FromJSON () |
Methods parseJSON :: Value -> Parser () # parseJSONList :: Value -> Parser [()] #
FromJSON Scientific |
Methods parseJSON :: Value -> Parser Scientific # parseJSONList :: Value -> Parser [Scientific] #
FromJSON Number |
Methods parseJSON :: Value -> Parser Number # parseJSONList :: Value -> Parser [Number] #
FromJSON Text |
Methods parseJSON :: Value -> Parser Text # parseJSONList :: Value -> Parser [Text] #
FromJSON UTCTime |
Methods parseJSON :: Value -> Parser UTCTime # parseJSONList :: Value -> Parser [UTCTime] #
FromJSON Value |
Methods parseJSON :: Value -> Parser Value # parseJSONList :: Value -> Parser [Value] #
FromJSON DotNetTime |
Methods parseJSON :: Value -> Parser DotNetTime # parseJSONList :: Value -> Parser [DotNetTime] #
FromJSON Text |
Methods parseJSON :: Value -> Parser Text # parseJSONList :: Value -> Parser [Text] #
FromJSON Natural |
Methods parseJSON :: Value -> Parser Natural # parseJSONList :: Value -> Parser [Natural] #
FromJSON Version |
Methods parseJSON :: Value -> Parser Version # parseJSONList :: Value -> Parser [Version] #
FromJSON IntSet |
Methods parseJSON :: Value -> Parser IntSet # parseJSONList :: Value -> Parser [IntSet] #
FromJSON LocalTime |
Methods parseJSON :: Value -> Parser LocalTime # parseJSONList :: Value -> Parser [LocalTime] #
FromJSON ZonedTime |
Methods parseJSON :: Value -> Parser ZonedTime # parseJSONList :: Value -> Parser [ZonedTime] #
FromJSON TimeOfDay |
Methods parseJSON :: Value -> Parser TimeOfDay # parseJSONList :: Value -> Parser [TimeOfDay] #
FromJSON NominalDiffTime | WARNING: Only parse lengths of time from trusted input since an attacker could easily fill up the memory of the target system by specifying a scientific number with a big exponent like `1e1000000000`.
Methods parseJSON :: Value -> Parser NominalDiffTime # parseJSONList :: Value -> Parser [NominalDiffTime] #
FromJSON Day |
Methods parseJSON :: Value -> Parser Day # parseJSONList :: Value -> Parser [Day] #
FromJSON a => FromJSON [a] |
Methods parseJSON :: Value -> Parser [a] # parseJSONList :: Value -> Parser [[a]] #
FromJSON a => FromJSON (Maybe a) |
Methods parseJSON :: Value -> Parser (Maybe a) # parseJSONList :: Value -> Parser [Maybe a] #
(FromJSON a, Integral a) => FromJSON (Ratio a) |
Methods parseJSON :: Value -> Parser (Ratio a) # parseJSONList :: Value -> Parser [Ratio a] #
FromJSON a => FromJSON (Identity a) |
Methods parseJSON :: Value -> Parser (Identity a) # parseJSONList :: Value -> Parser [Identity a] #
FromJSON a => FromJSON (Min a) |
Methods parseJSON :: Value -> Parser (Min a) # parseJSONList :: Value -> Parser [Min a] #
FromJSON a => FromJSON (Max a) |
Methods parseJSON :: Value -> Parser (Max a) # parseJSONList :: Value -> Parser [Max a] #
FromJSON a => FromJSON (First a) |
Methods parseJSON :: Value -> Parser (First a) # parseJSONList :: Value -> Parser [First a] #
FromJSON a => FromJSON (Last a) |
Methods parseJSON :: Value -> Parser (Last a) # parseJSONList :: Value -> Parser [Last a] #
FromJSON a => FromJSON (WrappedMonoid a) |
Methods parseJSON :: Value -> Parser (WrappedMonoid a) # parseJSONList :: Value -> Parser [WrappedMonoid a] #
FromJSON a => FromJSON (Option a) |
Methods parseJSON :: Value -> Parser (Option a) # parseJSONList :: Value -> Parser [Option a] #
FromJSON a => FromJSON (NonEmpty a) |
Methods parseJSON :: Value -> Parser (NonEmpty a) # parseJSONList :: Value -> Parser [NonEmpty a] #
HasResolution a => FromJSON (Fixed a) | WARNING: Only parse fixed-precision numbers from trusted input since an attacker could easily fill up the memory of the target system by specifying a scientific number with a big exponent like `1e1000000000`.
Methods parseJSON :: Value -> Parser (Fixed a) # parseJSONList :: Value -> Parser [Fixed a] #
FromJSON a => FromJSON (Dual a) |
Methods parseJSON :: Value -> Parser (Dual a) # parseJSONList :: Value -> Parser [Dual a] #
FromJSON a => FromJSON (First a) |
Methods parseJSON :: Value -> Parser (First a) # parseJSONList :: Value -> Parser [First a] #
FromJSON a => FromJSON (Last a) |
Methods parseJSON :: Value -> Parser (Last a) # parseJSONList :: Value -> Parser [Last a] #
FromJSON v => FromJSON (Tree v) |
Methods parseJSON :: Value -> Parser (Tree v) # parseJSONList :: Value -> Parser [Tree v] #
FromJSON a => FromJSON (Seq a) |
Methods parseJSON :: Value -> Parser (Seq a) # parseJSONList :: Value -> Parser [Seq a] #
FromJSON a => FromJSON (IntMap a) |
Methods parseJSON :: Value -> Parser (IntMap a) # parseJSONList :: Value -> Parser [IntMap a] #
(Ord a, FromJSON a) => FromJSON (Set a) |
Methods parseJSON :: Value -> Parser (Set a) # parseJSONList :: Value -> Parser [Set a] #
FromJSON a => FromJSON (DList a) |
Methods parseJSON :: Value -> Parser (DList a) # parseJSONList :: Value -> Parser [DList a] #
(Eq a, Hashable a, FromJSON a) => FromJSON (HashSet a) |
Methods parseJSON :: Value -> Parser (HashSet a) # parseJSONList :: Value -> Parser [HashSet a] #
FromJSON a => FromJSON (Vector a) |
Methods parseJSON :: Value -> Parser (Vector a) # parseJSONList :: Value -> Parser [Vector a] #
(Vector Vector a, FromJSON a) => FromJSON (Vector a) |
Methods parseJSON :: Value -> Parser (Vector a) # parseJSONList :: Value -> Parser [Vector a] #
(Storable a, FromJSON a) => FromJSON (Vector a) |
Methods parseJSON :: Value -> Parser (Vector a) # parseJSONList :: Value -> Parser [Vector a] #
(Prim a, FromJSON a) => FromJSON (Vector a) |
Methods parseJSON :: Value -> Parser (Vector a) # parseJSONList :: Value -> Parser [Vector a] #
(FromJSON a, FromJSON b) => FromJSON (Either a b) |
Methods parseJSON :: Value -> Parser (Either a b) # parseJSONList :: Value -> Parser [Either a b] #
(FromJSON a, FromJSON b) => FromJSON (a, b) |
Methods parseJSON :: Value -> Parser (a, b) # parseJSONList :: Value -> Parser [(a, b)] #
(FromJSON v, FromJSONKey k, Eq k, Hashable k) => FromJSON (HashMap k v) |
Methods parseJSON :: Value -> Parser (HashMap k v) # parseJSONList :: Value -> Parser [HashMap k v] #
(FromJSONKey k, Ord k, FromJSON v) => FromJSON (Map k v) |
Methods parseJSON :: Value -> Parser (Map k v) # parseJSONList :: Value -> Parser [Map k v] #
FromJSON (Proxy k a) |
Methods parseJSON :: Value -> Parser (Proxy k a) # parseJSONList :: Value -> Parser [Proxy k a] #
(FromJSON a, FromJSON b, FromJSON c) => FromJSON (a, b, c) |
Methods parseJSON :: Value -> Parser (a, b, c) # parseJSONList :: Value -> Parser [(a, b, c)] #
FromJSON a => FromJSON (Const k a b) |
Methods parseJSON :: Value -> Parser (Const k a b) # parseJSONList :: Value -> Parser [Const k a b] #
FromJSON b => FromJSON (Tagged k a b) |
Methods parseJSON :: Value -> Parser (Tagged k a b) # parseJSONList :: Value -> Parser [Tagged k a b] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSON (a, b, c, d) |
Methods parseJSON :: Value -> Parser (a, b, c, d) # parseJSONList :: Value -> Parser [(a, b, c, d)] #
(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Sum * f g a) |
Methods parseJSON :: Value -> Parser (Sum * f g a) # parseJSONList :: Value -> Parser [Sum * f g a] #
(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Product * f g a) |
Methods parseJSON :: Value -> Parser (Product * f g a) # parseJSONList :: Value -> Parser [Product * f g a] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e) => FromJSON (a, b, c, d, e) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e) # parseJSONList :: Value -> Parser [(a, b, c, d, e)] #
(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Compose * * f g a) |
Methods parseJSON :: Value -> Parser (Compose * * f g a) # parseJSONList :: Value -> Parser [Compose * * f g a] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f) => FromJSON (a, b, c, d, e, f) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g) => FromJSON (a, b, c, d, e, f, g) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h) => FromJSON (a, b, c, d, e, f, g, h) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i) => FromJSON (a, b, c, d, e, f, g, h, i) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j) => FromJSON (a, b, c, d, e, f, g, h, i, j) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k) => FromJSON (a, b, c, d, e, f, g, h, i, j, k) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l, m) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m, FromJSON n) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l, m, n) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m, FromJSON n, FromJSON o) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) |
Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] #