Data.Yaml.TH

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

Safe Haskell | None
Language | Haskell2010

Data.Yaml.TH

Contents

- Decoding
- Re-exports from Data.Yaml

Synopsis

- yamlQQ :: QuasiQuoter
- decodeFile :: (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 = KeyMap Value
- type Array = Vector Value
- object :: [Pair] -> Value
- array :: [Value] -> Value
- (.=) :: (KeyValue e kv, ToJSON v) => Key -> v -> kv
- (.:) :: FromJSON a => Object -> Key -> Parser a
- (.:?) :: FromJSON a => Object -> Key -> Parser (Maybe a)
- (.!=) :: Parser (Maybe a) -> a -> Parser a
- class FromJSON a where
  - parseJSON :: Value -> Parser a
  - parseJSONList :: Value -> Parser [a]
  - omittedField :: Maybe a

# Decoding

yamlQQ :: QuasiQuoter #

A `QuasiQuoter` for YAML.

#### Examples

Expand

    {-# LANGUAGE QuasiQuotes #-}
    import Data.Yaml.TH

    value :: Value
    value = [yamlQQ|
    name: John Doe
    age: 23
    |]

Since: 0.8.28.0

decodeFile :: (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

Expand

    {-# 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

Instances details

Arbitrary Value | Since: aeson-2.0.3.0
Instance details Defined in Data.Aeson.Types.Internal Methods arbitrary :: Gen Value # shrink :: Value -> [Value] #
CoArbitrary Value | Since: aeson-2.0.3.0
Instance details Defined in Data.Aeson.Types.Internal Methods coarbitrary :: Value -> Gen b -> Gen b #
Function Value | Since: aeson-2.0.3.0
Instance details Defined in Data.Aeson.Types.Internal Methods function :: (Value -> b) -> Value :-> b #
FromJSON Value |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Value # parseJSONList :: Value -> Parser [Value] # omittedField :: Maybe Value #
ToJSON Value |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Value -> Value # toEncoding :: Value -> Encoding # toJSONList :: [Value] -> Value # toEncodingList :: [Value] -> Encoding # omitField :: Value -> Bool #
NFData Value |
Instance details Defined in Data.Aeson.Types.Internal Methods rnf :: Value -> () #
Data Value |
Instance details Defined in Data.Aeson.Types.Internal 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 :: forall r r'. (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 #
IsString Value |
Instance details Defined in Data.Aeson.Types.Internal Methods fromString :: String -> Value #
Generic Value |
Instance details Defined in Data.Aeson.Types.Internal Associated Types
type Rep Value |
Instance details Defined in Data.Aeson.Types.Internal type Rep Value = D1 ('MetaData "Value" "Data.Aeson.Types.Internal" "aeson-2.2.3.0-7XnCskwqBum1iz93aA1K0B" 'False) ((C1 ('MetaCons "Object" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Object)) :+: (C1 ('MetaCons "Array" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Array)) :+: C1 ('MetaCons "String" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Text)))) :+: (C1 ('MetaCons "Number" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Scientific)) :+: (C1 ('MetaCons "Bool" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Bool)) :+: C1 ('MetaCons "Null" 'PrefixI 'False) (U1 :: Type -> Type))))
Methods from :: Value -> Rep Value x # to :: Rep Value x -> Value #
Read Value |
Instance details Defined in Data.Aeson.Types.Internal Methods readsPrec :: Int -> ReadS Value # readList :: ReadS [Value] # readPrec :: ReadPrec Value # readListPrec :: ReadPrec [Value] #
Show Value | Since version 1.5.6.0 version object values are printed in lexicographic key order
    >>> toJSON $ H.fromList [("a", True), ("z", False)]
    Object (fromList [("a",Bool True),("z",Bool False)])
    >>> toJSON $ H.fromList [("z", False), ("a", True)]
    Object (fromList [("a",Bool True),("z",Bool False)])
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> Value -> ShowS # show :: Value -> String # showList :: [Value] -> ShowS #
Eq Value |
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: Value -> Value -> Bool # (/=) :: Value -> Value -> Bool #
Ord Value | The ordering is total, consistent with `Eq` instance. However, nothing else about the ordering is specified, and it may change from environment to environment and version to version of either this package or its dependencies (`hashable` and 'unordered-containers'). Since: aeson-1.5.2.0
Instance details Defined in Data.Aeson.Types.Internal Methods compare :: Value -> Value -> Ordering # (<) :: Value -> Value -> Bool # (<=) :: Value -> Value -> Bool # (>) :: Value -> Value -> Bool # (>=) :: Value -> Value -> Bool # max :: Value -> Value -> Value # min :: Value -> Value -> Value #
Hashable Value |
Instance details Defined in Data.Aeson.Types.Internal Methods hashWithSalt :: Int -> Value -> Int # hash :: Value -> Int #
KeyValue Encoding Series |
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.=) :: ToJSON v => Key -> v -> Series # explicitToField :: (v -> Encoding) -> Key -> v -> Series #
KeyValueOmit Encoding Series |
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.?=) :: ToJSON v => Key -> v -> Series # explicitToFieldOmit :: (v -> Bool) -> (v -> Encoding) -> Key -> v -> Series #
Lift Value | Since: aeson-0.11.0.0
Instance details Defined in Data.Aeson.Types.Internal Methods lift :: Quote m => Value -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Value -> Code m Value #
(GToJSON' Encoding arity a, ConsToJSON Encoding arity a, Constructor c) => SumToJSON' TwoElemArray Encoding arity (C1 c a) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods sumToJSON' :: Options -> ToArgs Encoding arity a0 -> C1 c a a0 -> Tagged TwoElemArray Encoding
(GToJSON' Value arity a, ConsToJSON Value arity a, Constructor c) => SumToJSON' TwoElemArray Value arity (C1 c a) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods sumToJSON' :: Options -> ToArgs Value arity a0 -> C1 c a a0 -> Tagged TwoElemArray Value
GToJSON' Encoding arity (U1 :: Type -> Type) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Encoding arity a -> U1 a -> Encoding
GToJSON' Encoding arity (V1 :: Type -> Type) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Encoding arity a -> V1 a -> Encoding
GToJSON' Value arity (U1 :: Type -> Type) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Value arity a -> U1 a -> Value
GToJSON' Value arity (V1 :: Type -> Type) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Value arity a -> V1 a -> Value
ToJSON1 f => GToJSON' Encoding One (Rec1 f) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Encoding One a -> Rec1 f a -> Encoding
ToJSON1 f => GToJSON' Value One (Rec1 f) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Value One a -> Rec1 f a -> Value
(EncodeProduct arity a, EncodeProduct arity b) => GToJSON' Encoding arity (a :*: b) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Encoding arity a0 -> (a :*: b) a0 -> Encoding
ToJSON a => GToJSON' Encoding arity (K1 i a :: Type -> Type) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Encoding arity a0 -> K1 i a a0 -> Encoding
(WriteProduct arity a, WriteProduct arity b, ProductSize a, ProductSize b) => GToJSON' Value arity (a :*: b) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Value arity a0 -> (a :*: b) a0 -> Value
ToJSON a => GToJSON' Value arity (K1 i a :: Type -> Type) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Value arity a0 -> K1 i a a0 -> Value
(ToJSON1 f, GToJSON' Encoding One g) => GToJSON' Encoding One (f :.: g) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Encoding One a -> (f :.: g) a -> Encoding
(ToJSON1 f, GToJSON' Value One g) => GToJSON' Value One (f :.: g) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Value One a -> (f :.: g) a -> Value
FromPairs Value (DList Pair) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods fromPairs :: DList Pair -> Value
value ~ Value => KeyValue Value (KeyMap value) | Constructs a singleton `KeyMap`. For calling functions that demand an `Object` for constructing objects. To be used in conjunction with `mconcat`. Prefer to use `object` where possible.
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.=) :: ToJSON v => Key -> v -> KeyMap value # explicitToField :: (v -> Value) -> Key -> v -> KeyMap value #
value ~ Value => KeyValueOmit Value (KeyMap value) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.?=) :: ToJSON v => Key -> v -> KeyMap value # explicitToFieldOmit :: (v -> Bool) -> (v -> Value) -> Key -> v -> KeyMap value #
v ~ Value => KeyValuePair v (DList Pair) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods pair :: Key -> v -> DList Pair
(key ~ Key, value ~ Value) => KeyValue Value (key, value) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.=) :: ToJSON v => Key -> v -> (key, value) # explicitToField :: (v -> Value) -> Key -> v -> (key, value) #
type Rep Value |
Instance details Defined in Data.Aeson.Types.Internal type Rep Value = D1 ('MetaData "Value" "Data.Aeson.Types.Internal" "aeson-2.2.3.0-7XnCskwqBum1iz93aA1K0B" 'False) ((C1 ('MetaCons "Object" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Object)) :+: (C1 ('MetaCons "Array" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Array)) :+: C1 ('MetaCons "String" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Text)))) :+: (C1 ('MetaCons "Number" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Scientific)) :+: (C1 ('MetaCons "Bool" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Bool)) :+: C1 ('MetaCons "Null" 'PrefixI 'False) (U1 :: Type -> Type))))

data Parser a #

A JSON parser. N.B. This might not fit your usual understanding of "parser". Instead you might like to think of `Parser` as a "parse result", i.e. a parser to which the input has already been applied.

#### Instances

Instances details

Alternative Parser |
Instance details Defined in Data.Aeson.Types.Internal Methods empty :: Parser a # (<|>) :: Parser a -> Parser a -> Parser a # some :: Parser a -> Parser [a] # many :: Parser a -> Parser [a] #
Applicative Parser |
Instance details Defined in Data.Aeson.Types.Internal Methods pure :: a -> Parser a # (<*>) :: Parser (a -> b) -> Parser a -> Parser b # liftA2 :: (a -> b -> c) -> Parser a -> Parser b -> Parser c # (*>) :: Parser a -> Parser b -> Parser b # (<*) :: Parser a -> Parser b -> Parser a #
Functor Parser |
Instance details Defined in Data.Aeson.Types.Internal Methods fmap :: (a -> b) -> Parser a -> Parser b # (<$) :: a -> Parser b -> Parser a #
Monad Parser |
Instance details Defined in Data.Aeson.Types.Internal Methods (>>=) :: Parser a -> (a -> Parser b) -> Parser b # (>>) :: Parser a -> Parser b -> Parser b # return :: a -> Parser a #
MonadPlus Parser |
Instance details Defined in Data.Aeson.Types.Internal Methods mzero :: Parser a # mplus :: Parser a -> Parser a -> Parser a #
MonadFail Parser |
Instance details Defined in Data.Aeson.Types.Internal Methods fail :: String -> Parser a #
MonadFix Parser | Since: aeson-2.1.0.0
Instance details Defined in Data.Aeson.Types.Internal Methods mfix :: (a -> Parser a) -> Parser a #
Monoid (Parser a) |
Instance details Defined in Data.Aeson.Types.Internal Methods mempty :: Parser a # mappend :: Parser a -> Parser a -> Parser a # mconcat :: [Parser a] -> Parser a #
Semigroup (Parser a) |
Instance details Defined in Data.Aeson.Types.Internal Methods (<>) :: Parser a -> Parser a -> Parser a # sconcat :: NonEmpty (Parser a) -> Parser a # stimes :: Integral b => b -> Parser a -> Parser a #

type Object = KeyMap 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, later keys and their associated values win.

array :: [Value] -> Value #

Construct a new `Value` from a list of `Value`s.

(.=) :: (KeyValue e kv, ToJSON v) => Key -> v -> kv infixr 8 #

(.:) :: FromJSON a => Object -> Key -> 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 -> Key -> 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:

- `fail` yields a custom error message: it is the recommended way of reporting a failure;
- `empty` (or `mzero`) is uninformative: use it when the error is meant to be caught by some `(`<|>`)`;
- `typeMismatch` can be used to report a failure when the encountered value is not of the expected JSON type; `unexpected` is an appropriate alternative when more than one type may be expected, or to keep the expected type implicit.

`prependFailure` (or `modifyFailure`) add more information to a parser's error messages.

An example type and instance using `typeMismatch` and `prependFailure`:

    -- 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 empty to fail, but typeMismatch
        -- gives a much more informative error message.
        parseJSON invalid    =
            prependFailure "parsing Coord failed, "
                (typeMismatch "Object" invalid)

For this common case of only being concerned with a single type of JSON value, the functions `withObject`, `withScientific`, etc. are provided. Their use is to be preferred when possible, since they are more terse. Using `withObject`, we can rewrite the above instance (assuming the same language extension and data type) as:

    instance FromJSON Coord where
        parseJSON = withObject "Coord" $ \v -> Coord
            <$> v .: "x"
            <*> v .: "y"

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 it will probably be more efficient than the following option.
- 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

or using the DerivingVia extension

    deriving via Generically Coord instance FromJSON Coord

The default implementation will be equivalent to `parseJSON = `genericParseJSON` `defaultOptions``; if you need different options, you can customize the generic decoding by defining:

    customOptions = defaultOptions
                    { fieldLabelModifier = map toUpper
                    }

    instance FromJSON Coord where
        parseJSON = genericParseJSON customOptions

Minimal complete definition

Nothing

Methods

parseJSON :: Value -> Parser a #

default parseJSON :: (Generic a, GFromJSON Zero (Rep a)) => Value -> Parser a #

parseJSONList :: Value -> Parser [a] #

omittedField :: Maybe a #

Default value for optional fields. Used by `(`.:?=`)` operator, and Generics and TH deriving with ``allowOmittedFields` = True` (default).

Since: aeson-2.2.0.0

#### Instances

Instances details

FromJSON Key |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Key # parseJSONList :: Value -> Parser [Key] # omittedField :: Maybe Key #
FromJSON DotNetTime |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser DotNetTime # parseJSONList :: Value -> Parser [DotNetTime] # omittedField :: Maybe DotNetTime #
FromJSON Value |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Value # parseJSONList :: Value -> Parser [Value] # omittedField :: Maybe Value #
FromJSON IntSet |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser IntSet # parseJSONList :: Value -> Parser [IntSet] # omittedField :: Maybe IntSet #
FromJSON Void |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Void # parseJSONList :: Value -> Parser [Void] # omittedField :: Maybe Void #
FromJSON All | Since: aeson-2.2.3.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser All # parseJSONList :: Value -> Parser [All] # omittedField :: Maybe All #
FromJSON Any | Since: aeson-2.2.3.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Any # parseJSONList :: Value -> Parser [Any] # omittedField :: Maybe Any #
FromJSON Version |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Version # parseJSONList :: Value -> Parser [Version] # omittedField :: Maybe Version #
FromJSON CTime |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser CTime # parseJSONList :: Value -> Parser [CTime] # omittedField :: Maybe CTime #
FromJSON Int16 |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Int16 # parseJSONList :: Value -> Parser [Int16] # omittedField :: Maybe Int16 #
FromJSON Int32 |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Int32 # parseJSONList :: Value -> Parser [Int32] # omittedField :: Maybe Int32 #
FromJSON Int64 |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Int64 # parseJSONList :: Value -> Parser [Int64] # omittedField :: Maybe Int64 #
FromJSON Int8 |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Int8 # parseJSONList :: Value -> Parser [Int8] # omittedField :: Maybe Int8 #
FromJSON Word16 |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Word16 # parseJSONList :: Value -> Parser [Word16] # omittedField :: Maybe Word16 #
FromJSON Word32 |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Word32 # parseJSONList :: Value -> Parser [Word32] # omittedField :: Maybe Word32 #
FromJSON Word64 |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Word64 # parseJSONList :: Value -> Parser [Word64] # omittedField :: Maybe Word64 #
FromJSON Word8 |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Word8 # parseJSONList :: Value -> Parser [Word8] # omittedField :: Maybe Word8 #
FromJSON Ordering |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Ordering # parseJSONList :: Value -> Parser [Ordering] # omittedField :: Maybe Ordering #
FromJSON URI | Since: aeson-2.2.0.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser URI # parseJSONList :: Value -> Parser [URI] # omittedField :: Maybe URI #
FromJSON Scientific |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Scientific # parseJSONList :: Value -> Parser [Scientific] # omittedField :: Maybe Scientific #
FromJSON Text |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Text # parseJSONList :: Value -> Parser [Text] # omittedField :: Maybe Text #
FromJSON Text |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Text # parseJSONList :: Value -> Parser [Text] # omittedField :: Maybe Text #
FromJSON ShortText | Since: aeson-2.0.2.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser ShortText # parseJSONList :: Value -> Parser [ShortText] # omittedField :: Maybe ShortText #
FromJSON CalendarDiffDays |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser CalendarDiffDays # parseJSONList :: Value -> Parser [CalendarDiffDays] # omittedField :: Maybe CalendarDiffDays #
FromJSON Day |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Day # parseJSONList :: Value -> Parser [Day] # omittedField :: Maybe Day #
FromJSON Month |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Month # parseJSONList :: Value -> Parser [Month] # omittedField :: Maybe Month #
FromJSON Quarter |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Quarter # parseJSONList :: Value -> Parser [Quarter] # omittedField :: Maybe Quarter #
FromJSON QuarterOfYear |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser QuarterOfYear # parseJSONList :: Value -> Parser [QuarterOfYear] # omittedField :: Maybe QuarterOfYear #
FromJSON DayOfWeek |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser DayOfWeek # parseJSONList :: Value -> Parser [DayOfWeek] # omittedField :: Maybe DayOfWeek #
FromJSON DiffTime | This instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype `Scientific` and provide your own instance using `withScientific` if you want to allow larger inputs.
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser DiffTime # parseJSONList :: Value -> Parser [DiffTime] # omittedField :: Maybe DiffTime #
FromJSON NominalDiffTime | This instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype `Scientific` and provide your own instance using `withScientific` if you want to allow larger inputs.
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser NominalDiffTime # parseJSONList :: Value -> Parser [NominalDiffTime] # omittedField :: Maybe NominalDiffTime #
FromJSON SystemTime |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser SystemTime # parseJSONList :: Value -> Parser [SystemTime] # omittedField :: Maybe SystemTime #
FromJSON UTCTime |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser UTCTime # parseJSONList :: Value -> Parser [UTCTime] # omittedField :: Maybe UTCTime #
FromJSON CalendarDiffTime |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser CalendarDiffTime # parseJSONList :: Value -> Parser [CalendarDiffTime] # omittedField :: Maybe CalendarDiffTime #
FromJSON LocalTime |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser LocalTime # parseJSONList :: Value -> Parser [LocalTime] # omittedField :: Maybe LocalTime #
FromJSON TimeOfDay |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser TimeOfDay # parseJSONList :: Value -> Parser [TimeOfDay] # omittedField :: Maybe TimeOfDay #
FromJSON ZonedTime | Supported string formats: `YYYY-MM-DD HH:MMZ` `YYYY-MM-DD HH:MM:SSZ` `YYYY-MM-DD HH:MM:SS.SSSZ` The first space may instead be a `T`, and the second space is optional. The `Z` represents UTC. The `Z` may be replaced with a time zone offset of the form `+0000` or `-08:00`, where the first two digits are hours, the `:` is optional and the second two digits (also optional) are minutes.
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser ZonedTime # parseJSONList :: Value -> Parser [ZonedTime] # omittedField :: Maybe ZonedTime #
FromJSON UUID |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser UUID # parseJSONList :: Value -> Parser [UUID] # omittedField :: Maybe UUID #
FromJSON Integer | This instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype `Scientific` and provide your own instance using `withScientific` if you want to allow larger inputs.
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Integer # parseJSONList :: Value -> Parser [Integer] # omittedField :: Maybe Integer #
FromJSON Natural |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Natural # parseJSONList :: Value -> Parser [Natural] # omittedField :: Maybe Natural #
FromJSON () |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser () # parseJSONList :: Value -> Parser [()] # omittedField :: Maybe () #
FromJSON Bool |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Bool # parseJSONList :: Value -> Parser [Bool] # omittedField :: Maybe Bool #
FromJSON Char |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Char # parseJSONList :: Value -> Parser [Char] # omittedField :: Maybe Char #
FromJSON Double |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Double # parseJSONList :: Value -> Parser [Double] # omittedField :: Maybe Double #
FromJSON Float |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Float # parseJSONList :: Value -> Parser [Float] # omittedField :: Maybe Float #
FromJSON Int |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Int # parseJSONList :: Value -> Parser [Int] # omittedField :: Maybe Int #
FromJSON Word |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Word # parseJSONList :: Value -> Parser [Word] # omittedField :: Maybe Word #
FromJSON v => FromJSON (KeyMap v) | Since: aeson-2.0.1.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (KeyMap v) # parseJSONList :: Value -> Parser [KeyMap v] # omittedField :: Maybe (KeyMap v) #
FromJSON a => FromJSON (First a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (First a) # parseJSONList :: Value -> Parser [First a] # omittedField :: Maybe (First a) #
FromJSON a => FromJSON (Last a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Last a) # parseJSONList :: Value -> Parser [Last a] # omittedField :: Maybe (Last a) #
FromJSON a => FromJSON (Max a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Max a) # parseJSONList :: Value -> Parser [Max a] # omittedField :: Maybe (Max a) #
FromJSON a => FromJSON (Min a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Min a) # parseJSONList :: Value -> Parser [Min a] # omittedField :: Maybe (Min a) #
FromJSON a => FromJSON (WrappedMonoid a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (WrappedMonoid a) # parseJSONList :: Value -> Parser [WrappedMonoid a] # omittedField :: Maybe (WrappedMonoid a) #
FromJSON a => FromJSON (IntMap a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (IntMap a) # parseJSONList :: Value -> Parser [IntMap a] # omittedField :: Maybe (IntMap a) #
FromJSON a => FromJSON (Seq a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Seq a) # parseJSONList :: Value -> Parser [Seq a] # omittedField :: Maybe (Seq a) #
(Ord a, FromJSON a) => FromJSON (Set a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Set a) # parseJSONList :: Value -> Parser [Set a] # omittedField :: Maybe (Set a) #
FromJSON v => FromJSON (Tree v) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Tree v) # parseJSONList :: Value -> Parser [Tree v] # omittedField :: Maybe (Tree v) #
FromJSON1 f => FromJSON (Fix f) | Since: aeson-1.5.3.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Fix f) # parseJSONList :: Value -> Parser [Fix f] # omittedField :: Maybe (Fix f) #
(FromJSON1 f, Functor f) => FromJSON (Mu f) | Since: aeson-1.5.3.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Mu f) # parseJSONList :: Value -> Parser [Mu f] # omittedField :: Maybe (Mu f) #
(FromJSON1 f, Functor f) => FromJSON (Nu f) | Since: aeson-1.5.3.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Nu f) # parseJSONList :: Value -> Parser [Nu f] # omittedField :: Maybe (Nu f) #
FromJSON a => FromJSON (DNonEmpty a) | Since: aeson-1.5.3.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (DNonEmpty a) # parseJSONList :: Value -> Parser [DNonEmpty a] # omittedField :: Maybe (DNonEmpty a) #
FromJSON a => FromJSON (DList a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (DList a) # parseJSONList :: Value -> Parser [DList a] # omittedField :: Maybe (DList a) #
FromJSON a => FromJSON (NonEmpty a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (NonEmpty a) # parseJSONList :: Value -> Parser [NonEmpty a] # omittedField :: Maybe (NonEmpty a) #
FromJSON a => FromJSON (Identity a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Identity a) # parseJSONList :: Value -> Parser [Identity a] # omittedField :: Maybe (Identity a) #
FromJSON a => FromJSON (First a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (First a) # parseJSONList :: Value -> Parser [First a] # omittedField :: Maybe (First a) #
FromJSON a => FromJSON (Last a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Last a) # parseJSONList :: Value -> Parser [Last a] # omittedField :: Maybe (Last a) #
FromJSON a => FromJSON (Down a) | Since: aeson-2.2.0.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Down a) # parseJSONList :: Value -> Parser [Down a] # omittedField :: Maybe (Down a) #
FromJSON a => FromJSON (Dual a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Dual a) # parseJSONList :: Value -> Parser [Dual a] # omittedField :: Maybe (Dual a) #
FromJSON a => FromJSON (Product a) | Since: aeson-2.2.3.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Product a) # parseJSONList :: Value -> Parser [Product a] # omittedField :: Maybe (Product a) #
FromJSON a => FromJSON (Sum a) | Since: aeson-2.2.3.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Sum a) # parseJSONList :: Value -> Parser [Sum a] # omittedField :: Maybe (Sum a) #
(Generic a, GFromJSON Zero (Rep a)) => FromJSON (Generically a) | Since: aeson-2.1.0.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Generically a) # parseJSONList :: Value -> Parser [Generically a] # omittedField :: Maybe (Generically a) #
(FromJSON a, Integral a) => FromJSON (Ratio a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Ratio a) # parseJSONList :: Value -> Parser [Ratio a] # omittedField :: Maybe (Ratio a) #
FromJSON a => FromJSON (Array a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Array a) # parseJSONList :: Value -> Parser [Array a] # omittedField :: Maybe (Array a) #
(Prim a, FromJSON a) => FromJSON (PrimArray a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (PrimArray a) # parseJSONList :: Value -> Parser [PrimArray a] # omittedField :: Maybe (PrimArray a) #
FromJSON a => FromJSON (SmallArray a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (SmallArray a) # parseJSONList :: Value -> Parser [SmallArray a] # omittedField :: Maybe (SmallArray a) #
FromJSON a => FromJSON (Maybe a) | Since: aeson-1.5.3.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Maybe a) # parseJSONList :: Value -> Parser [Maybe a] # omittedField :: Maybe (Maybe a) #
(Eq a, Hashable a, FromJSON a) => FromJSON (HashSet a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (HashSet a) # parseJSONList :: Value -> Parser [HashSet a] # omittedField :: Maybe (HashSet a) #
FromJSON a => FromJSON (Vector a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Vector a) # parseJSONList :: Value -> Parser [Vector a] # omittedField :: Maybe (Vector a) #
(Prim a, FromJSON a) => FromJSON (Vector a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Vector a) # parseJSONList :: Value -> Parser [Vector a] # omittedField :: Maybe (Vector a) #
(Storable a, FromJSON a) => FromJSON (Vector a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Vector a) # parseJSONList :: Value -> Parser [Vector a] # omittedField :: Maybe (Vector a) #
(Vector Vector a, FromJSON a) => FromJSON (Vector a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Vector a) # parseJSONList :: Value -> Parser [Vector a] # omittedField :: Maybe (Vector a) #
FromJSON a => FromJSON (Maybe a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Maybe a) # parseJSONList :: Value -> Parser [Maybe a] # omittedField :: Maybe (Maybe a) #
FromJSON a => FromJSON (Solo a) | Since: aeson-2.0.2.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Solo a) # parseJSONList :: Value -> Parser [Solo a] # omittedField :: Maybe (Solo a) #
FromJSON a => FromJSON [a] |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser [a] # parseJSONList :: Value -> Parser [[a]] # omittedField :: Maybe [a] #
HasResolution a => FromJSON (Fixed a) | This instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype `Scientific` and provide your own instance using `withScientific` if you want to allow larger inputs.
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Fixed a) # parseJSONList :: Value -> Parser [Fixed a] # omittedField :: Maybe (Fixed a) #
(FromJSONKey k, Ord k, FromJSON v) => FromJSON (Map k v) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Map k v) # parseJSONList :: Value -> Parser [Map k v] # omittedField :: Maybe (Map k v) #
(FromJSON a, FromJSON b) => FromJSON (Either a b) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Either a b) # parseJSONList :: Value -> Parser [Either a b] # omittedField :: Maybe (Either a b) #
FromJSON (Proxy a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Proxy a) # parseJSONList :: Value -> Parser [Proxy a] # omittedField :: Maybe (Proxy a) #
(FromJSON a, FromJSON b) => FromJSON (Either a b) | Since: aeson-1.5.3.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Either a b) # parseJSONList :: Value -> Parser [Either a b] # omittedField :: Maybe (Either a b) #
(FromJSON a, FromJSON b) => FromJSON (These a b) | Since: aeson-1.5.3.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (These a b) # parseJSONList :: Value -> Parser [These a b] # omittedField :: Maybe (These a b) #
(FromJSON a, FromJSON b) => FromJSON (Pair a b) | Since: aeson-1.5.3.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Pair a b) # parseJSONList :: Value -> Parser [Pair a b] # omittedField :: Maybe (Pair a b) #
(FromJSON a, FromJSON b) => FromJSON (These a b) | Since: aeson-1.5.1.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (These a b) # parseJSONList :: Value -> Parser [These a b] # omittedField :: Maybe (These a b) #
(FromJSON v, FromJSONKey k, Eq k, Hashable k) => FromJSON (HashMap k v) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (HashMap k v) # parseJSONList :: Value -> Parser [HashMap k v] # omittedField :: Maybe (HashMap k v) #
(FromJSON a, FromJSON b) => FromJSON (a, b) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b) # parseJSONList :: Value -> Parser [(a, b)] # omittedField :: Maybe (a, b) #
FromJSON a => FromJSON (Const a b) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Const a b) # parseJSONList :: Value -> Parser [Const a b] # omittedField :: Maybe (Const a b) #
FromJSON b => FromJSON (Tagged a b) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Tagged a b) # parseJSONList :: Value -> Parser [Tagged a b] # omittedField :: Maybe (Tagged a b) #
(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (These1 f g a) | Since: aeson-1.5.1.0
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (These1 f g a) # parseJSONList :: Value -> Parser [These1 f g a] # omittedField :: Maybe (These1 f g a) #
(FromJSON a, FromJSON b, FromJSON c) => FromJSON (a, b, c) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c) # parseJSONList :: Value -> Parser [(a, b, c)] # omittedField :: Maybe (a, b, c) #
(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Product f g a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Product f g a) # parseJSONList :: Value -> Parser [Product f g a] # omittedField :: Maybe (Product f g a) #
(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Sum f g a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Sum f g a) # parseJSONList :: Value -> Parser [Sum f g a] # omittedField :: Maybe (Sum f g a) #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSON (a, b, c, d) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d) # parseJSONList :: Value -> Parser [(a, b, c, d)] # omittedField :: Maybe (a, b, c, d) #
(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Compose f g a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Compose f g a) # parseJSONList :: Value -> Parser [Compose f g a] # omittedField :: Maybe (Compose f g a) #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e) => FromJSON (a, b, c, d, e) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d, e) # parseJSONList :: Value -> Parser [(a, b, c, d, e)] # omittedField :: Maybe (a, b, c, d, e) #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f) => FromJSON (a, b, c, d, e, f) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d, e, f) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f)] # omittedField :: Maybe (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) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g)] # omittedField :: Maybe (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) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h)] # omittedField :: Maybe (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) |
Instance details Defined in Data.Aeson.Types.FromJSON 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)] # omittedField :: Maybe (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) |
Instance details Defined in Data.Aeson.Types.FromJSON 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)] # omittedField :: Maybe (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) |
Instance details Defined in Data.Aeson.Types.FromJSON 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)] # omittedField :: Maybe (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) |
Instance details Defined in Data.Aeson.Types.FromJSON 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)] # omittedField :: Maybe (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) |
Instance details Defined in Data.Aeson.Types.FromJSON 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)] # omittedField :: Maybe (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) |
Instance details Defined in Data.Aeson.Types.FromJSON 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)] # omittedField :: Maybe (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) |
Instance details Defined in Data.Aeson.Types.FromJSON 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)] # omittedField :: Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) #