Copyright | (c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank Inc. |
---|---|
License | BSD3 |
Maintainer | Bryan O'Sullivan <bos@serpentine.com> |
Stability | experimental |
Portability | portable |
Safe Haskell | Safe-Inferred |
Language | Haskell2010 |
Types and functions for working efficiently with JSON data.
(A note on naming: in Greek mythology, Aeson was the father of Jason.)
Synopsis
- decode :: FromJSON a => ByteString -> Maybe a
- decode' :: FromJSON a => ByteString -> Maybe a
- eitherDecode :: FromJSON a => ByteString -> Either String a
- eitherDecode' :: FromJSON a => ByteString -> Either String a
- encode :: ToJSON a => a -> ByteString
- encodeFile :: ToJSON a => FilePath -> a -> IO ()
- decodeStrict :: FromJSON a => ByteString -> Maybe a
- decodeFileStrict :: FromJSON a => FilePath -> IO (Maybe a)
- decodeStrict' :: FromJSON a => ByteString -> Maybe a
- decodeFileStrict' :: FromJSON a => FilePath -> IO (Maybe a)
- eitherDecodeStrict :: FromJSON a => ByteString -> Either String a
- eitherDecodeFileStrict :: FromJSON a => FilePath -> IO (Either String a)
- eitherDecodeStrict' :: FromJSON a => ByteString -> Either String a
- eitherDecodeFileStrict' :: FromJSON a => FilePath -> IO (Either String a)
- decodeStrictText :: FromJSON a => Text -> Maybe a
- eitherDecodeStrictText :: FromJSON a => Text -> Either String a
- newtype AesonException = AesonException String
- throwDecode :: forall a m. (FromJSON a, MonadThrow m) => ByteString -> m a
- throwDecodeStrict :: forall a m. (FromJSON a, MonadThrow m) => ByteString -> m a
- throwDecodeStrictText :: forall a m. (FromJSON a, MonadThrow m) => Text -> m a
- throwDecode' :: forall a m. (FromJSON a, MonadThrow m) => ByteString -> m a
- throwDecodeStrict' :: forall a m. (FromJSON a, MonadThrow m) => ByteString -> m a
- data Value
- type Encoding = Encoding' Value
- fromEncoding :: Encoding' tag -> Builder
- type Array = Vector Value
- type Object = KeyMap Value
- data Key
- newtype DotNetTime = DotNetTime {}
- class FromJSON a where
- parseJSON :: Value -> Parser a
- parseJSONList :: Value -> Parser [a]
- omittedField :: Maybe a
- data Result a
- fromJSON :: FromJSON a => Value -> Result a
- class ToJSON a where
- toJSON :: a -> Value
- toEncoding :: a -> Encoding
- toJSONList :: [a] -> Value
- toEncodingList :: [a] -> Encoding
- omitField :: a -> Bool
- class KeyValue e kv | kv -> e where
- (.=) :: ToJSON v => Key -> v -> kv
- explicitToField :: (v -> e) -> Key -> v -> kv
- class KeyValue e kv => KeyValueOmit e kv | kv -> e where
- (<?>) :: Parser a -> JSONPathElement -> Parser a
- type JSONPath = [JSONPathElement]
- class ToJSONKey a where
- toJSONKey :: ToJSONKeyFunction a
- toJSONKeyList :: ToJSONKeyFunction [a]
- data ToJSONKeyFunction a
- = ToJSONKeyText !(a -> Key) !(a -> Encoding' Key)
- | ToJSONKeyValue !(a -> Value) !(a -> Encoding)
- class FromJSONKey a where
- data FromJSONKeyFunction a where
- FromJSONKeyCoerce :: Coercible Text a => FromJSONKeyFunction a
- FromJSONKeyText :: !(Text -> a) -> FromJSONKeyFunction a
- FromJSONKeyTextParser :: !(Text -> Parser a) -> FromJSONKeyFunction a
- FromJSONKeyValue :: !(Value -> Parser a) -> FromJSONKeyFunction a
- class GetConName f => GToJSONKey f
- genericToJSONKey :: (Generic a, GToJSONKey (Rep a)) => JSONKeyOptions -> ToJSONKeyFunction a
- class (ConstructorNames f, SumFromString f) => GFromJSONKey f
- genericFromJSONKey :: forall a. (Generic a, GFromJSONKey (Rep a)) => JSONKeyOptions -> FromJSONKeyFunction a
- class FromJSON1 f where
- parseJSON1 :: (FromJSON1 f, FromJSON a) => Value -> Parser (f a)
- omittedField1 :: (FromJSON1 f, FromJSON a) => Maybe (f a)
- class FromJSON2 f where
- liftParseJSON2 :: Maybe a -> (Value -> Parser a) -> (Value -> Parser [a]) -> Maybe b -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (f a b)
- liftParseJSONList2 :: Maybe a -> (Value -> Parser a) -> (Value -> Parser [a]) -> Maybe b -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [f a b]
- liftOmittedField2 :: Maybe a -> Maybe b -> Maybe (f a b)
- parseJSON2 :: (FromJSON2 f, FromJSON a, FromJSON b) => Value -> Parser (f a b)
- omittedField2 :: (FromJSON2 f, FromJSON a, FromJSON b) => Maybe (f a b)
- class ToJSON1 f where
- liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> f a -> Value
- liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [f a] -> Value
- liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding
- liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [f a] -> Encoding
- liftOmitField :: (a -> Bool) -> f a -> Bool
- toJSON1 :: (ToJSON1 f, ToJSON a) => f a -> Value
- toEncoding1 :: (ToJSON1 f, ToJSON a) => f a -> Encoding
- omitField1 :: (ToJSON1 f, ToJSON a) => f a -> Bool
- class ToJSON2 f where
- liftToJSON2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> f a b -> Value
- liftToJSONList2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> [f a b] -> Value
- liftToEncoding2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> f a b -> Encoding
- liftToEncodingList2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> [f a b] -> Encoding
- liftOmitField2 :: (a -> Bool) -> (b -> Bool) -> f a b -> Bool
- toJSON2 :: (ToJSON2 f, ToJSON a, ToJSON b) => f a b -> Value
- toEncoding2 :: (ToJSON2 f, ToJSON a, ToJSON b) => f a b -> Encoding
- omitField2 :: (ToJSON2 f, ToJSON a, ToJSON b) => f a b -> Bool
- class GFromJSON arity f
- data FromArgs arity a
- type GToJSON = GToJSON' Value
- type GToEncoding = GToJSON' Encoding
- class GToJSON' enc arity f
- data ToArgs res arity a
- data Zero
- data One
- genericToJSON :: (Generic a, GToJSON' Value Zero (Rep a)) => Options -> a -> Value
- genericLiftToJSON :: (Generic1 f, GToJSON' Value One (Rep1 f)) => Options -> (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> f a -> Value
- genericToEncoding :: (Generic a, GToJSON' Encoding Zero (Rep a)) => Options -> a -> Encoding
- genericLiftToEncoding :: (Generic1 f, GToJSON' Encoding One (Rep1 f)) => Options -> (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding
- genericParseJSON :: (Generic a, GFromJSON Zero (Rep a)) => Options -> Value -> Parser a
- genericLiftParseJSON :: (Generic1 f, GFromJSON One (Rep1 f)) => Options -> Maybe a -> (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a)
- data Options
- defaultOptions :: Options
- fieldLabelModifier :: Options -> String -> String
- constructorTagModifier :: Options -> String -> String
- allNullaryToStringTag :: Options -> Bool
- omitNothingFields :: Options -> Bool
- allowOmittedFields :: Options -> Bool
- sumEncoding :: Options -> SumEncoding
- unwrapUnaryRecords :: Options -> Bool
- tagSingleConstructors :: Options -> Bool
- rejectUnknownFields :: Options -> Bool
- data SumEncoding
- camelTo2 :: Char -> String -> String
- defaultTaggedObject :: SumEncoding
- data JSONKeyOptions
- keyModifier :: JSONKeyOptions -> String -> String
- defaultJSONKeyOptions :: JSONKeyOptions
- withObject :: String -> (Object -> Parser a) -> Value -> Parser a
- withText :: String -> (Text -> Parser a) -> Value -> Parser a
- withArray :: String -> (Array -> Parser a) -> Value -> Parser a
- withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
- withBool :: String -> (Bool -> Parser a) -> Value -> Parser a
- withEmbeddedJSON :: String -> (Value -> Parser a) -> Value -> Parser a
- data Series
- pairs :: Series -> Encoding
- foldable :: (Foldable t, ToJSON a) => t a -> Encoding
- (.:) :: FromJSON a => Object -> Key -> Parser a
- (.:?) :: FromJSON a => Object -> Key -> Parser (Maybe a)
- (.:!) :: FromJSON a => Object -> Key -> Parser (Maybe a)
- (.!=) :: Parser (Maybe a) -> a -> Parser a
- (.:?=) :: FromJSON a => Object -> Key -> Parser a
- (.:!=) :: FromJSON a => Object -> Key -> Parser a
- object :: [Pair] -> Value
- parseIndexedJSON :: (Value -> Parser a) -> Int -> Value -> Parser a
How to use this library
This section contains basic information on the different ways to work with data using this library. These range from simple but inflexible, to complex but flexible.
The most common way to use the library is to define a data type,
corresponding to some JSON data you want to work with, and then
write either a FromJSON
instance, a ToJSON
instance, or both
for that type.
For example, given this JSON data:
{ "name": "Joe", "age": 12 }
we create a matching data type:
{-# LANGUAGE DeriveGeneric #-} import GHC.Generics data Person = Person { name :: Text , age :: Int } deriving (Generic, Show)
The LANGUAGE
pragma and Generic
instance let us write empty
FromJSON
and ToJSON
instances for which the compiler will
generate sensible default implementations.
instanceToJSON
Person where -- No need to provide atoJSON
implementation. -- For efficiency, we write a simpletoEncoding
implementation, as -- the default version usestoJSON
.toEncoding
=genericToEncoding
defaultOptions
instanceFromJSON
Person -- No need to provide aparseJSON
implementation.
We can now encode a value like so:
>>> encode (Person {name = "Joe", age = 12}) "{\"name\":\"Joe\",\"age\":12}"
Writing instances by hand
When necessary, we can write ToJSON
and FromJSON
instances by
hand. This is valuable when the JSON-on-the-wire and Haskell data
are different or otherwise need some more carefully managed
translation. Let's revisit our JSON data:
{ "name": "Joe", "age": 12 }
We once again create a matching data type, without bothering to add
a Generic
instance this time:
data Person = Person { name :: Text , age :: Int } deriving Show
To decode data, we need to define a FromJSON
instance:
{-# LANGUAGE OverloadedStrings #-} instance FromJSON Person where parseJSON = withObject "Person" $ \v -> Person <$> v .: "name" <*> v .: "age"
We can now parse the JSON data like so:
>>> decode "{\"name\":\"Joe\",\"age\":12}" :: Maybe Person Just (Person {name = "Joe", age = 12})
To encode data, we need to define a ToJSON
instance. Let's begin
with an instance written entirely by hand.
instance ToJSON Person where -- this generates aValue
toJSON
(Person name age) =object
["name".=
name, "age".=
age] -- this encodes directly to a bytestring BuildertoEncoding
(Person name age) =pairs
("name".=
name
<>
"age".=
age)
We can now encode a value like so:
>>> encode (Person {name = "Joe", age = 12}) "{\"name\":\"Joe\",\"age\":12}"
There are predefined FromJSON
and ToJSON
instances for many
types. Here's an example using lists and Int
s:
>>> decode "[1,2,3]" :: Maybe [Int] Just [1,2,3]
And here's an example using the Map
type to get a map of
Int
s.
>>> decode "{\"foo\":1,\"bar\":2}" :: Maybe (Map String Int) Just (fromList [("bar",2),("foo",1)])
Working with the AST
Sometimes you want to work with JSON data directly, without first
converting it to a custom data type. This can be useful if you want
to e.g. convert JSON data to YAML data, without knowing what the
contents of the original JSON data was. The Value
type, which is
an instance of FromJSON
, is used to represent an arbitrary JSON
AST (abstract syntax tree). Example usage:
>>> decode "{\"foo\": 123}" :: Maybe Value Just (Object (fromList [("foo",Number 123)]))
>>> decode "{\"foo\": [\"abc\",\"def\"]}" :: Maybe Value Just (Object (fromList [("foo",Array (fromList [String "abc",String "def"]))]))
Once you have a Value
you can write functions to traverse it and
make arbitrary transformations.
Decoding to a Haskell value
We can decode to any instance of FromJSON
:
λ> decode "[1,2,3]" :: Maybe [Int] Just [1,2,3]
Alternatively, there are instances for standard data types, so you
can use them directly. For example, use the Map
type to
get a map of Int
s.
λ> import Data.Map λ> decode "{\"foo\":1,\"bar\":2}" :: Maybe (Map String Int) Just (fromList [("bar",2),("foo",1)])
Decoding a mixed-type object
The above approach with maps of course will not work for mixed-type objects that don't follow a strict schema, but there are a couple of approaches available for these.
The Object
type contains JSON objects:
λ> decode "{\"name\":\"Dave\",\"age\":2}" :: Maybe Object Just (fromList [("name",String "Dave"),("age",Number 2)])
You can extract values from it with a parser using parse
,
parseEither
or, in this example, parseMaybe
:
λ> do result <- decode "{\"name\":\"Dave\",\"age\":2}" flip parseMaybe result $ \obj -> do age <- obj .: "age" name <- obj .: "name" return (name ++ ": " ++ show (age*2)) Just "Dave: 4"
Considering that any type that implements FromJSON
can be used
here, this is quite a powerful way to parse JSON. See the
documentation in FromJSON
for how to implement this class for
your own data types.
The downside is that you have to write the parser yourself; the upside is that you have complete control over the way the JSON is parsed.
Encoding and decoding
Decoding is a two-step process.
- When decoding a value, the process is reversed: the bytes are
converted to a
Value
, then theFromJSON
class is used to convert to the desired type.
There are two ways to encode a value.
- Convert to a
Value
usingtoJSON
, then possibly further encode. This was the only method available in aeson 0.9 and earlier. - Directly encode (to what will become a
ByteString
) usingtoEncoding
. This is much more efficient (about 3x faster, and less memory intensive besides), but is only available in aeson 0.10 and newer.
For convenience, the encode
and decode
functions combine both
steps.
Direct encoding
In older versions of this library, encoding a Haskell value
involved converting to an intermediate Value
, then encoding that.
A "direct" encoder converts straight from a source Haskell value
to a ByteString
without constructing an intermediate Value
.
This approach is faster than toJSON
, and allocates less memory.
The toEncoding
method makes it possible to implement direct
encoding with low memory overhead.
To complicate matters, the default implementation of toEncoding
uses toJSON
. Why? The toEncoding
method was added to this
library much more recently than toJSON
. Using toJSON
ensures
that packages written against older versions of this library will
compile and produce correct output, but they will not see any
speedup from direct encoding.
To write a minimal implementation of direct encoding, your type
must implement GHC's Generic
class, and your code should look
like this:
toEncoding
=genericToEncoding
defaultOptions
What if you have more elaborate encoding needs? For example, perhaps you need to change the names of object keys, omit parts of a value.
To encode to a JSON "object", use the pairs
function.
toEncoding
(Person name age) =pairs
("name".=
name
<>
"age".=
age)
Any container type that implements Foldable
can be encoded to a
JSON "array" using foldable
.
> import Data.Sequence as Seq > encode (Seq.fromList [1,2,3]) "[1,2,3]"
Remarks on specific encodings
Time
This module contains instances of ToJSON
and FromJSON
for types from
the time library.
Those instances encode time as JSON strings in
ISO 8601 formats, with the
following general form for UTCTime
and
ZonedTime
, while other time types use subsets of those
fields:
[+,-]YYYY-MM-DDThh:mm[:ss[.sss]]Z
where
[+,-]
is an optional sign,+
or-
.YYYY
is the year, which must have at least 4 digits to prevent Y2K problems. Years from0000
to0999
must thus be zero-padded.MM
is a two-digit month.DD
is a two-digit day.T
is a literal'T'
character separating the date and the time of day. It may be a space instead.hh
is a two-digit hour.mm
is a two-digit minute.ss
is a two-digit second.sss
is a decimal fraction of a second; it may have any nonzero number of digits.Z
is a time zone; it may be preceded by an optional space.
For more information, see ISO 8601 time, and attoparsec-iso8601 (where the relevant parsers are defined).
Main encoding and decoding functions
decode :: FromJSON a => ByteString -> Maybe a Source #
Efficiently deserialize a JSON value from a lazy ByteString
.
If this fails due to incomplete or invalid input, Nothing
is
returned.
decode' :: FromJSON a => ByteString -> Maybe a Source #
Efficiently deserialize a JSON value from a lazy ByteString
.
If this fails due to incomplete or invalid input, Nothing
is
returned.
Since 2.2.0.0
an alias for decode
.
eitherDecode :: FromJSON a => ByteString -> Either String a Source #
Like decode
but returns an error message when decoding fails.
eitherDecode' :: FromJSON a => ByteString -> Either String a Source #
Like decode'
but returns an error message when decoding fails.
Since 2.2.0.0
an alias for eitherDecode
.
encode :: ToJSON a => a -> ByteString Source #
Efficiently serialize a JSON value as a lazy ByteString
.
This is implemented in terms of the ToJSON
class's toEncoding
method.
encodeFile :: ToJSON a => FilePath -> a -> IO () Source #
Efficiently serialize a JSON value as a lazy ByteString
and write it to a file.
Variants for strict bytestrings
decodeStrict :: FromJSON a => ByteString -> Maybe a Source #
Efficiently deserialize a JSON value from a strict ByteString
.
If this fails due to incomplete or invalid input, Nothing
is
returned.
decodeFileStrict :: FromJSON a => FilePath -> IO (Maybe a) Source #
Efficiently deserialize a JSON value from a file.
If this fails due to incomplete or invalid input, Nothing
is
returned.
The input file's content must consist solely of a JSON document, with no trailing data except for whitespace.
This function parses immediately, but defers conversion. See
json
for details.
decodeStrict' :: FromJSON a => ByteString -> Maybe a Source #
Efficiently deserialize a JSON value from a strict ByteString
.
If this fails due to incomplete or invalid input, Nothing
is
returned.
Since 2.2.0.0
an alias for decodeStrict
.
decodeFileStrict' :: FromJSON a => FilePath -> IO (Maybe a) Source #
Efficiently deserialize a JSON value from a file.
If this fails due to incomplete or invalid input, Nothing
is
returned.
Since 2.2.0.0
an alias for decodeFileStrict
.
eitherDecodeStrict :: FromJSON a => ByteString -> Either String a Source #
Like decodeStrict
but returns an error message when decoding fails.
eitherDecodeFileStrict :: FromJSON a => FilePath -> IO (Either String a) Source #
Like decodeFileStrict
but returns an error message when decoding fails.
eitherDecodeStrict' :: FromJSON a => ByteString -> Either String a Source #
Like decodeStrict'
but returns an error message when decoding fails.
Since 2.2.0.0
an alias for eitherDecodeStrict
.
eitherDecodeFileStrict' :: FromJSON a => FilePath -> IO (Either String a) Source #
Like decodeFileStrict'
but returns an error message when decoding fails.
Since 2.2.0.0
an alias for eitherDecodeFileStrict'
.
Variants for strict text
decodeStrictText :: FromJSON a => Text -> Maybe a Source #
Efficiently deserialize a JSON value from a strict ByteString
.
If this fails due to incomplete or invalid input, Nothing
is
returned.
Since: 2.2.1.0
eitherDecodeStrictText :: FromJSON a => Text -> Either String a Source #
Like decodeStrictText
but returns an error message when decoding fails.
Since: 2.2.1.0
Exception throwing variants
newtype AesonException Source #
Exception thrown by throwDecode
and variants.
Since: 2.1.2.0
Instances
Exception AesonException Source # | |
Defined in Data.Aeson.Types.Internal | |
Show AesonException Source # | |
Defined in Data.Aeson.Types.Internal showsPrec :: Int -> AesonException -> ShowS # show :: AesonException -> String # showList :: [AesonException] -> ShowS # |
throwDecode :: forall a m. (FromJSON a, MonadThrow m) => ByteString -> m a Source #
Like decode
but throws an AesonException
when decoding fails.
throwDecode
is in aeson
since 2.1.2.0, but this variant is added later.
throwDecodeStrict :: forall a m. (FromJSON a, MonadThrow m) => ByteString -> m a Source #
Like decodeStrict
but throws an AesonException
when decoding fails.
throwDecodeStrictText :: forall a m. (FromJSON a, MonadThrow m) => Text -> m a Source #
Like decodeStrictText
but throws an AesonException
when decoding fails.
Since: 2.2.1.0
throwDecode' :: forall a m. (FromJSON a, MonadThrow m) => ByteString -> m a Source #
Like decode'
but throws an AesonException
when decoding fails.
Since 2.2.0.0
an alias for throwDecode
.
Since: 2.1.2.0
throwDecodeStrict' :: forall a m. (FromJSON a, MonadThrow m) => ByteString -> m a Source #
Like decodeStrict'
but throws an AesonException
when decoding fails.
Since 2.2.0.0
an alias for throwDecodeStrict
.
Since: 2.1.2.0
Core JSON types
A JSON value represented as a Haskell value.
Instances
Arbitrary Value Source # | Since: 2.0.3.0 |
CoArbitrary Value Source # | Since: 2.0.3.0 |
Defined in Data.Aeson.Types.Internal coarbitrary :: Value -> Gen b -> Gen b # | |
Function Value Source # | Since: 2.0.3.0 |
FromJSON Value Source # | |
ToJSON Value Source # | |
Data Value Source # | |
Defined in Data.Aeson.Types.Internal 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 # 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 Source # | |
Defined in Data.Aeson.Types.Internal fromString :: String -> Value # | |
Generic Value Source # | |
Read Value Source # | |
Show Value Source # | Since version 1.5.6.0 version object values are printed in lexicographic key order
|
NFData Value Source # | |
Defined in Data.Aeson.Types.Internal | |
Eq Value Source # | |
Ord Value Source # | The ordering is total, consistent with Since: 1.5.2.0 |
Hashable Value Source # | |
Defined in Data.Aeson.Types.Internal | |
KeyValue Encoding Series Source # | |
KeyValueOmit Encoding Series Source # | |
Lift Value Source # | Since: 0.11.0.0 |
GToJSON' Encoding arity (U1 :: TYPE LiftedRep -> Type) Source # | |
GToJSON' Encoding arity (V1 :: TYPE LiftedRep -> Type) Source # | |
GToJSON' Value arity (U1 :: TYPE LiftedRep -> Type) Source # | |
GToJSON' Value arity (V1 :: TYPE LiftedRep -> Type) Source # | |
ToJSON1 f => GToJSON' Encoding One (Rec1 f) Source # | |
ToJSON1 f => GToJSON' Value One (Rec1 f) Source # | |
(EncodeProduct arity a, EncodeProduct arity b) => GToJSON' Encoding arity (a :*: b) Source # | |
ToJSON a => GToJSON' Encoding arity (K1 i a :: TYPE LiftedRep -> Type) Source # | |
(WriteProduct arity a, WriteProduct arity b, ProductSize a, ProductSize b) => GToJSON' Value arity (a :*: b) Source # | |
ToJSON a => GToJSON' Value arity (K1 i a :: TYPE LiftedRep -> Type) Source # | |
(ToJSON1 f, GToJSON' Encoding One g) => GToJSON' Encoding One (f :.: g) Source # | |
(ToJSON1 f, GToJSON' Value One g) => GToJSON' Value One (f :.: g) Source # | |
value ~ Value => KeyValue Value (KeyMap value) Source # | Constructs a singleton |
value ~ Value => KeyValueOmit Value (KeyMap value) Source # | |
(key ~ Key, value ~ Value) => KeyValue Value (key, value) Source # | |
type Rep Value Source # | |
Defined in Data.Aeson.Types.Internal type Rep Value = D1 ('MetaData "Value" "Data.Aeson.Types.Internal" "aeson-2.2.1.0-GU03yYEaVbfFZQFiWWRWc5" '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)))) |
fromEncoding :: Encoding' tag -> Builder Source #
Acquire the underlying bytestring builder.
Instances
Convenience types
newtype DotNetTime Source #
A newtype wrapper for UTCTime
that uses the same non-standard
serialization format as Microsoft .NET, whose
System.DateTime
type is by default serialized to JSON as in the following example:
/Date(1302547608878)/
The number represents milliseconds since the Unix epoch.
DotNetTime | |
|
Instances
Type conversion
class FromJSON a where Source #
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
(ormzero
) 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 writeText
literals. {-# LANGUAGE OverloadedStrings #-} data Coord = Coord { x :: Double, y :: Double } instanceFromJSON
Coord whereparseJSON
(Object
v) = Coord<$>
v.:
"x"<*>
v.:
"y" -- We do not expect a non-Object
value here. -- We could useempty
to fail, buttypeMismatch
-- 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:
instanceFromJSON
Coord whereparseJSON
=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
clause to your
datatype and declare a Generic
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 } derivingGeneric
instanceFromJSON
Coord
or using the DerivingVia extension
deriving viaGenerically
Coord instanceFromJSON
Coord
The default implementation will be equivalent to
parseJSON =
; if you need different
options, you can customize the generic decoding by defining:genericParseJSON
defaultOptions
customOptions =defaultOptions
{fieldLabelModifier
=map
toUpper
} instanceFromJSON
Coord whereparseJSON
=genericParseJSON
customOptions
Nothing
parseJSON :: Value -> Parser a Source #
parseJSONList :: Value -> Parser [a] Source #
omittedField :: Maybe a Source #
Default value for optional fields.
Used by (
operator, and Generics and TH deriving
with .:?=
)
(default).allowOmittedFields
= True
Since: 2.2.0.0
Instances
The result of running a Parser
.
Instances
MonadFail Result Source # | |
Defined in Data.Aeson.Types.Internal | |
Foldable Result Source # | |
Defined in Data.Aeson.Types.Internal fold :: Monoid m => Result m -> m # foldMap :: Monoid m => (a -> m) -> Result a -> m # foldMap' :: Monoid m => (a -> m) -> Result a -> m # foldr :: (a -> b -> b) -> b -> Result a -> b # foldr' :: (a -> b -> b) -> b -> Result a -> b # foldl :: (b -> a -> b) -> b -> Result a -> b # foldl' :: (b -> a -> b) -> b -> Result a -> b # foldr1 :: (a -> a -> a) -> Result a -> a # foldl1 :: (a -> a -> a) -> Result a -> a # elem :: Eq a => a -> Result a -> Bool # maximum :: Ord a => Result a -> a # minimum :: Ord a => Result a -> a # | |
Traversable Result Source # | |
Alternative Result Source # | |
Applicative Result Source # | |
Functor Result Source # | |
Monad Result Source # | |
MonadPlus Result Source # | |
Monoid (Result a) Source # | |
Semigroup (Result a) Source # | |
Show a => Show (Result a) Source # | |
NFData a => NFData (Result a) Source # | |
Defined in Data.Aeson.Types.Internal | |
Eq a => Eq (Result a) Source # | |
fromJSON :: FromJSON a => Value -> Result a Source #
Convert a value from JSON, failing if the types do not match.
A type that can be converted to JSON.
Instances in general must specify toJSON
and should (but don't need
to) specify toEncoding
.
An example type and instance:
-- Allow ourselves to writeText
literals. {-# LANGUAGE OverloadedStrings #-} data Coord = Coord { x :: Double, y :: Double } instanceToJSON
Coord wheretoJSON
(Coord x y) =object
["x".=
x, "y".=
y]toEncoding
(Coord x y) =pairs
("x".=
x<>
"y".=
y)
Instead of manually writing your ToJSON
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
toJSON
.
To use the second, simply add a deriving
clause to your
datatype and declare a Generic
ToJSON
instance. If you require nothing other than
defaultOptions
, it is sufficient to write (and this is the only
alternative where the default toJSON
implementation is sufficient):
{-# LANGUAGE DeriveGeneric #-} import GHC.Generics data Coord = Coord { x :: Double, y :: Double } derivingGeneric
instanceToJSON
Coord wheretoEncoding
=genericToEncoding
defaultOptions
or more conveniently using the DerivingVia extension
deriving viaGenerically
Coord instanceToJSON
Coord
If on the other hand you wish to customize the generic decoding, you have to implement both methods:
customOptions =defaultOptions
{fieldLabelModifier
=map
toUpper
} instanceToJSON
Coord wheretoJSON
=genericToJSON
customOptionstoEncoding
=genericToEncoding
customOptions
Previous versions of this library only had the toJSON
method. Adding
toEncoding
had two reasons:
toEncoding
is more efficient for the common case that the output oftoJSON
is directly serialized to aByteString
. Further, expressing either method in terms of the other would be non-optimal.- The choice of defaults allows a smooth transition for existing users:
Existing instances that do not define
toEncoding
still compile and have the correct semantics. This is ensured by making the default implementation oftoEncoding
usetoJSON
. This produces correct results, but since it performs an intermediate conversion to aValue
, it will be less efficient than directly emitting anEncoding
. (this also means that specifying nothing more thaninstance ToJSON Coord
would be sufficient as a generically decoding instance, but there probably exists no good reason to not specifytoEncoding
in new instances.)
Nothing
Convert a Haskell value to a JSON-friendly intermediate type.
toEncoding :: a -> Encoding Source #
Encode a Haskell value as JSON.
The default implementation of this method creates an
intermediate Value
using toJSON
. This provides
source-level compatibility for people upgrading from older
versions of this library, but obviously offers no performance
advantage.
To benefit from direct encoding, you must provide an
implementation for this method. The easiest way to do so is by
having your types implement Generic
using the DeriveGeneric
extension, and then have GHC generate a method body as follows.
instanceToJSON
Coord wheretoEncoding
=genericToEncoding
defaultOptions
toJSONList :: [a] -> Value Source #
toEncodingList :: [a] -> Encoding Source #
omitField :: a -> Bool Source #
Defines when it is acceptable to omit a field of this type from a record.
Used by (
operator, and Generics and TH deriving
with .?=
)
.omitNothingFields
= True
Since: 2.2.0.0
Instances
class KeyValue e kv | kv -> e where Source #
A key-value pair for encoding a JSON object.
(.=) :: ToJSON v => Key -> v -> kv infixr 8 Source #
explicitToField :: (v -> e) -> Key -> v -> kv Source #
Since: 2.2.0.0
Instances
KeyValue Encoding Series Source # | |
value ~ Value => KeyValue Value (KeyMap value) Source # | Constructs a singleton |
(key ~ Key, value ~ Value) => KeyValue Value (key, value) Source # | |
class KeyValue e kv => KeyValueOmit e kv | kv -> e where Source #
An optional key-value pair for envoding to a JSON object
Since: 2.2.0.0
(.?=) :: ToJSON v => Key -> v -> kv infixr 8 Source #
explicitToFieldOmit :: (v -> Bool) -> (v -> e) -> Key -> v -> kv Source #
(<?>) :: Parser a -> JSONPathElement -> Parser a Source #
Add JSON Path context to a parser
When parsing a complex structure, it helps to annotate (sub)parsers with context, so that if an error occurs, you can find its location.
withObject "Person" $ \o -> Person <$> o .: "name" <?> Key "name" <*> o .: "age" <?> Key "age"
(Standard methods like (.:)
already do this.)
With such annotations, if an error occurs, you will get a JSON Path location of that error.
Since 0.10
type JSONPath = [JSONPathElement] Source #
Keys for maps
class ToJSONKey a where Source #
Typeclass for types that can be used as the key of a map-like container
(like Map
or HashMap
). For example, since Text
has a ToJSONKey
instance and Char
has a ToJSON
instance, we can encode a value of
type Map
Text
Char
:
>>>
LBC8.putStrLn $ encode $ Map.fromList [("foo" :: Text, 'a')]
{"foo":"a"}
Since Int
also has a ToJSONKey
instance, we can similarly write:
>>>
LBC8.putStrLn $ encode $ Map.fromList [(5 :: Int, 'a')]
{"5":"a"}
JSON documents only accept strings as object keys. For any type
from base
that has a natural textual representation, it can be
expected that its ToJSONKey
instance will choose that representation.
For data types that lack a natural textual representation, an alternative is provided. The map-like container is represented as a JSON array instead of a JSON object. Each value in the array is an array with exactly two values. The first is the key and the second is the value.
For example, values of type '[Text]' cannot be encoded to a
string, so a Map
with keys of type '[Text]' is encoded as follows:
>>>
LBC8.putStrLn $ encode $ Map.fromList [(["foo","bar","baz" :: Text], 'a')]
[[["foo","bar","baz"],"a"]]
The default implementation of ToJSONKey
chooses this method of
encoding a key, using the ToJSON
instance of the type.
To use your own data type as the key in a map, all that is needed
is to write a ToJSONKey
(and possibly a FromJSONKey
) instance
for it. If the type cannot be trivially converted to and from Text
,
it is recommended that ToJSONKeyValue
is used. Since the default
implementations of the typeclass methods can build this from a
ToJSON
instance, there is nothing that needs to be written:
data Foo = Foo { fooAge :: Int, fooName :: Text } deriving (Eq,Ord,Generic) instance ToJSON Foo instance ToJSONKey Foo
That's it. We can now write:
>>>
let m = Map.fromList [(Foo 4 "bar",'a'),(Foo 6 "arg",'b')]
>>>
LBC8.putStrLn $ encode m
[[{"fooName":"bar","fooAge":4},"a"],[{"fooName":"arg","fooAge":6},"b"]]
The next case to consider is if we have a type that is a
newtype wrapper around Text
. The recommended approach is to use
generalized newtype deriving:
newtype RecordId = RecordId { getRecordId :: Text } deriving (Eq,Ord,ToJSONKey)
Then we may write:
>>>
LBC8.putStrLn $ encode $ Map.fromList [(RecordId "abc",'a')]
{"abc":"a"}
Simple sum types are a final case worth considering. Suppose we have:
data Color = Red | Green | Blue deriving (Show,Read,Eq,Ord)
It is possible to get the ToJSONKey
instance for free as we did
with Foo
. However, in this case, we have a natural way to go to
and from Text
that does not require any escape sequences. So
ToJSONKeyText
can be used instead of ToJSONKeyValue
to encode maps
as objects instead of arrays of pairs. This instance may be
implemented using generics as follows:
instanceToJSONKey
Color wheretoJSONKey
=genericToJSONKey
defaultJSONKeyOptions
Low-level implementations
The Show
instance can be used to help write ToJSONKey
:
instance ToJSONKey Color where toJSONKey = ToJSONKeyText f g where f = Text.pack . show g = text . Text.pack . show -- text function is from Data.Aeson.Encoding
The situation of needing to turning function a -> Text
into
a ToJSONKeyFunction
is common enough that a special combinator
is provided for it. The above instance can be rewritten as:
instance ToJSONKey Color where toJSONKey = toJSONKeyText (Text.pack . show)
The performance of the above instance can be improved by
not using Value
as an intermediate step when converting to
Text
. One option for improving performance would be to use
template haskell machinery from the text-show
package. However,
even with the approach, the Encoding
(a wrapper around a bytestring
builder) is generated by encoding the Text
to a ByteString
,
an intermediate step that could be avoided. The fastest possible
implementation would be:
-- Assuming that OverloadedStrings is enabled instance ToJSONKey Color where toJSONKey = ToJSONKeyText f g where f x = case x of {Red -> "Red";Green ->"Green";Blue -> "Blue"} g x = case x of {Red -> text "Red";Green -> text "Green";Blue -> text "Blue"} -- text function is from Data.Aeson.Encoding
This works because GHC can lift the encoded values out of the case statements, which means that they are only evaluated once. This approach should only be used when there is a serious need to maximize performance.
Nothing
toJSONKey :: ToJSONKeyFunction a Source #
Strategy for rendering the key for a map-like container.
default toJSONKey :: ToJSON a => ToJSONKeyFunction a Source #
toJSONKeyList :: ToJSONKeyFunction [a] Source #
This is similar in spirit to the showsList
method of Show
.
It makes it possible to give Value
keys special treatment
without using OverlappingInstances
. End users should always
be able to use the default implementation of this method.
default toJSONKeyList :: ToJSON a => ToJSONKeyFunction [a] Source #
Instances
data ToJSONKeyFunction a Source #
ToJSONKeyText !(a -> Key) !(a -> Encoding' Key) | key is encoded to string, produces object |
ToJSONKeyValue !(a -> Value) !(a -> Encoding) | key is encoded to value, produces array |
Instances
Contravariant ToJSONKeyFunction Source # | |
Defined in Data.Aeson.Types.ToJSON contramap :: (a' -> a) -> ToJSONKeyFunction a -> ToJSONKeyFunction a' # (>$) :: b -> ToJSONKeyFunction b -> ToJSONKeyFunction a # |
class FromJSONKey a where Source #
Read the docs for ToJSONKey
first. This class is a conversion
in the opposite direction. If you have a newtype wrapper around Text
,
the recommended way to define instances is with generalized newtype deriving:
newtype SomeId = SomeId { getSomeId :: Text } deriving (Eq,Ord,Hashable,FromJSONKey)
If you have a sum of nullary constructors, you may use the generic implementation:
data Color = Red | Green | Blue deriving Generic instanceFromJSONKey
Color wherefromJSONKey
=genericFromJSONKey
defaultJSONKeyOptions
Nothing
fromJSONKey :: FromJSONKeyFunction a Source #
Strategy for parsing the key of a map-like container.
default fromJSONKey :: FromJSON a => FromJSONKeyFunction a Source #
fromJSONKeyList :: FromJSONKeyFunction [a] Source #
This is similar in spirit to the readList
method of Read
.
It makes it possible to give Value
keys special treatment
without using OverlappingInstances
. End users should always
be able to use the default implementation of this method.
default fromJSONKeyList :: FromJSON a => FromJSONKeyFunction [a] Source #
Instances
data FromJSONKeyFunction a where Source #
This type is related to ToJSONKeyFunction
. If FromJSONKeyValue
is used in the
FromJSONKey
instance, then ToJSONKeyValue
should be used in the ToJSONKey
instance. The other three data constructors for this type all correspond to
ToJSONKeyText
. Strictly speaking, FromJSONKeyTextParser
is more powerful than
FromJSONKeyText
, which is in turn more powerful than FromJSONKeyCoerce
.
For performance reasons, these exist as three options instead of one.
FromJSONKeyCoerce | |
FromJSONKeyText | |
| |
FromJSONKeyTextParser | |
| |
FromJSONKeyValue | |
|
Instances
Functor FromJSONKeyFunction Source # | Only law abiding up to interpretation |
Defined in Data.Aeson.Types.FromJSON fmap :: (a -> b) -> FromJSONKeyFunction a -> FromJSONKeyFunction b # (<$) :: a -> FromJSONKeyFunction b -> FromJSONKeyFunction a # |
Generic keys
class GetConName f => GToJSONKey f Source #
Instances
GetConName f => GToJSONKey (f :: k -> Type) Source # | |
Defined in Data.Aeson.Types.ToJSON |
genericToJSONKey :: (Generic a, GToJSONKey (Rep a)) => JSONKeyOptions -> ToJSONKeyFunction a Source #
class (ConstructorNames f, SumFromString f) => GFromJSONKey f Source #
Instances
(ConstructorNames f, SumFromString f) => GFromJSONKey f Source # | |
Defined in Data.Aeson.Types.FromJSON |
genericFromJSONKey :: forall a. (Generic a, GFromJSONKey (Rep a)) => JSONKeyOptions -> FromJSONKeyFunction a Source #
fromJSONKey
for Generic
types.
These types must be sums of nullary constructors, whose names will be used
as keys for JSON objects.
See also genericToJSONKey
.
Example
data Color = Red | Green | Blue derivingGeneric
instanceFromJSONKey
Color wherefromJSONKey
=genericFromJSONKey
defaultJSONKeyOptions
Liftings to unary and binary type constructors
class FromJSON1 f where Source #
Lifting of the FromJSON
class to unary type constructors.
Instead of manually writing your FromJSON1
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
liftParseJSON
.
To use the second, simply add a deriving
clause to your
datatype and declare a Generic1
FromJSON1
instance for your datatype without giving
a definition for liftParseJSON
.
For example:
{-# LANGUAGE DeriveGeneric #-} import GHC.Generics data Pair a b = Pair { pairFst :: a, pairSnd :: b } derivingGeneric1
instanceFromJSON
a =>FromJSON1
(Pair a)
or
deriving viaGenerically1
(Pair a) instanceFromJSON1
(Pair a)
If the default implementation doesn't give exactly the results you want,
you can customize the generic decoding with only a tiny amount of
effort, using genericLiftParseJSON
with your preferred Options
:
customOptions =defaultOptions
{fieldLabelModifier
=map
toUpper
} instanceFromJSON
a =>FromJSON1
(Pair a) whereliftParseJSON
=genericLiftParseJSON
customOptions
Nothing
liftParseJSON :: Maybe a -> (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a) Source #
default liftParseJSON :: (Generic1 f, GFromJSON One (Rep1 f)) => Maybe a -> (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a) Source #
liftParseJSONList :: Maybe a -> (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [f a] Source #
liftOmittedField :: Maybe a -> Maybe (f a) Source #
Instances
parseJSON1 :: (FromJSON1 f, FromJSON a) => Value -> Parser (f a) Source #
Lift the standard parseJSON
function through the type constructor.
class FromJSON2 f where Source #
Lifting of the FromJSON
class to binary type constructors.
Instead of manually writing your FromJSON2
instance, Data.Aeson.TH
provides Template Haskell functions which will derive an instance at compile time.
liftParseJSON2 :: Maybe a -> (Value -> Parser a) -> (Value -> Parser [a]) -> Maybe b -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (f a b) Source #
liftParseJSONList2 :: Maybe a -> (Value -> Parser a) -> (Value -> Parser [a]) -> Maybe b -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [f a b] Source #
liftOmittedField2 :: Maybe a -> Maybe b -> Maybe (f a b) Source #
Instances
parseJSON2 :: (FromJSON2 f, FromJSON a, FromJSON b) => Value -> Parser (f a b) Source #
Lift the standard parseJSON
function through the type constructor.
class ToJSON1 f where Source #
Lifting of the ToJSON
class to unary type constructors.
Instead of manually writing your ToJSON1
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
toJSON1
.
To use the second, simply add a deriving
clause to your
datatype and declare a Generic1
ToJSON1
instance for your datatype without giving
definitions for liftToJSON
or liftToEncoding
.
For example:
{-# LANGUAGE DeriveGeneric #-} import GHC.Generics data Pair a b = Pair { pairFst :: a, pairSnd :: b } derivingGeneric1
instanceToJSON
a =>ToJSON1
(Pair a)
If the default implementation doesn't give exactly the results you want,
you can customize the generic encoding with only a tiny amount of
effort, using genericLiftToJSON
and genericLiftToEncoding
with
your preferred Options
:
customOptions =defaultOptions
{fieldLabelModifier
=map
toUpper
} instanceToJSON
a =>ToJSON1
(Pair a) whereliftToJSON
=genericLiftToJSON
customOptionsliftToEncoding
=genericLiftToEncoding
customOptions
See also ToJSON
.
Nothing
liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> f a -> Value Source #
default liftToJSON :: (Generic1 f, GToJSON' Value One (Rep1 f)) => (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> f a -> Value Source #
liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [f a] -> Value Source #
liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding Source #
default liftToEncoding :: (Generic1 f, GToJSON' Encoding One (Rep1 f)) => (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding Source #
liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [f a] -> Encoding Source #
liftOmitField :: (a -> Bool) -> f a -> Bool Source #
Since: 2.2.0.0
Instances
ToJSON1 KeyMap Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> KeyMap a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [KeyMap a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> KeyMap a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [KeyMap a] -> Encoding Source # | |
ToJSON1 Identity Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Identity a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Identity a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Identity a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Identity a] -> Encoding Source # | |
ToJSON1 First Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> First a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [First a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> First a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [First a] -> Encoding Source # | |
ToJSON1 Last Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Last a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Last a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Last a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Last a] -> Encoding Source # | |
ToJSON1 Down Source # | Since: 2.2.0.0 |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Down a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Down a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Down a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Down a] -> Encoding Source # | |
ToJSON1 First Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> First a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [First a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> First a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [First a] -> Encoding Source # | |
ToJSON1 Last Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Last a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Last a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Last a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Last a] -> Encoding Source # | |
ToJSON1 Max Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Max a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Max a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Max a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Max a] -> Encoding Source # | |
ToJSON1 Min Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Min a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Min a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Min a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Min a] -> Encoding Source # | |
ToJSON1 WrappedMonoid Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> WrappedMonoid a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [WrappedMonoid a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> WrappedMonoid a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [WrappedMonoid a] -> Encoding Source # liftOmitField :: (a -> Bool) -> WrappedMonoid a -> Bool Source # | |
ToJSON1 Dual Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Dual a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Dual a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Dual a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Dual a] -> Encoding Source # | |
ToJSON1 IntMap Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> IntMap a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [IntMap a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> IntMap a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [IntMap a] -> Encoding Source # | |
ToJSON1 Seq Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Seq a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Seq a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Seq a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Seq a] -> Encoding Source # | |
ToJSON1 Set Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Set a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Set a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Set a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Set a] -> Encoding Source # | |
ToJSON1 Tree Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Tree a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Tree a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Tree a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Tree a] -> Encoding Source # | |
ToJSON1 DNonEmpty Source # | Since: 1.5.3.0 |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> DNonEmpty a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [DNonEmpty a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> DNonEmpty a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [DNonEmpty a] -> Encoding Source # liftOmitField :: (a -> Bool) -> DNonEmpty a -> Bool Source # | |
ToJSON1 DList Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> DList a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [DList a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> DList a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [DList a] -> Encoding Source # | |
ToJSON1 Maybe Source # | Since: 1.5.3.0 |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Maybe a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Maybe a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Maybe a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Maybe a] -> Encoding Source # | |
ToJSON1 HashSet Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> HashSet a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [HashSet a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> HashSet a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [HashSet a] -> Encoding Source # | |
ToJSON1 Vector Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Vector a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Vector a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Vector a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Vector a] -> Encoding Source # | |
ToJSON1 NonEmpty Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> NonEmpty a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [NonEmpty a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> NonEmpty a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [NonEmpty a] -> Encoding Source # | |
ToJSON1 Maybe Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Maybe a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Maybe a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Maybe a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Maybe a] -> Encoding Source # | |
ToJSON1 Solo Source # | Since: 2.0.2.0 |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Solo a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Solo a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Solo a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Solo a] -> Encoding Source # | |
ToJSON1 [] Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [a] -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [[a]] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [a] -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [[a]] -> Encoding Source # liftOmitField :: (a -> Bool) -> [a] -> Bool Source # | |
ToJSON a => ToJSON1 (Either a) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> Either a a0 -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [Either a a0] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> Either a a0 -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [Either a a0] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> Either a a0 -> Bool Source # | |
ToJSON1 (Proxy :: TYPE LiftedRep -> Type) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Proxy a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Proxy a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Proxy a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Proxy a] -> Encoding Source # | |
ToJSONKey k => ToJSON1 (Map k) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Map k a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Map k a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Map k a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Map k a] -> Encoding Source # | |
ToJSON a => ToJSON1 (Either a) Source # | Since: 1.5.3.0 |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> Either a a0 -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [Either a a0] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> Either a a0 -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [Either a a0] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> Either a a0 -> Bool Source # | |
ToJSON a => ToJSON1 (These a) Source # | Since: 1.5.3.0 |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> These a a0 -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [These a a0] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> These a a0 -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [These a a0] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> These a a0 -> Bool Source # | |
ToJSON a => ToJSON1 (Pair a) Source # | Since: 1.5.3.0 |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> Pair a a0 -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [Pair a a0] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> Pair a a0 -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [Pair a a0] -> Encoding Source # | |
ToJSON a => ToJSON1 (These a) Source # | Since: 1.5.1.0 |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> These a a0 -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [These a a0] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> These a a0 -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [These a a0] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> These a a0 -> Bool Source # | |
ToJSONKey k => ToJSON1 (HashMap k) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> HashMap k a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [HashMap k a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> HashMap k a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [HashMap k a] -> Encoding Source # liftOmitField :: (a -> Bool) -> HashMap k a -> Bool Source # | |
ToJSON a => ToJSON1 ((,) a) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (a, a0) -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [(a, a0)] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, a0) -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, a0)] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> (a, a0) -> Bool Source # | |
ToJSON a => ToJSON1 (Const a :: TYPE LiftedRep -> Type) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> Const a a0 -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [Const a a0] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> Const a a0 -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [Const a a0] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> Const a a0 -> Bool Source # | |
(Generic1 f, GToJSON' Value One (Rep1 f), GToJSON' Encoding One (Rep1 f)) => ToJSON1 (Generically1 f) Source # | Since: 2.1.0.0 |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Generically1 f a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Generically1 f a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Generically1 f a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Generically1 f a] -> Encoding Source # liftOmitField :: (a -> Bool) -> Generically1 f a -> Bool Source # | |
ToJSON1 (Tagged a) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> Tagged a a0 -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [Tagged a a0] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> Tagged a a0 -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [Tagged a a0] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> Tagged a a0 -> Bool Source # | |
(ToJSON1 f, ToJSON1 g) => ToJSON1 (These1 f g) Source # | Since: 1.5.1.0 |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> These1 f g a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [These1 f g a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> These1 f g a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [These1 f g a] -> Encoding Source # liftOmitField :: (a -> Bool) -> These1 f g a -> Bool Source # | |
(ToJSON a, ToJSON b) => ToJSON1 ((,,) a b) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (a, b, a0) -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [(a, b, a0)] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, a0) -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, a0)] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> (a, b, a0) -> Bool Source # | |
(ToJSON1 f, ToJSON1 g) => ToJSON1 (Product f g) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Product f g a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Product f g a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Product f g a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Product f g a] -> Encoding Source # liftOmitField :: (a -> Bool) -> Product f g a -> Bool Source # | |
(ToJSON1 f, ToJSON1 g) => ToJSON1 (Sum f g) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Sum f g a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Sum f g a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Sum f g a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Sum f g a] -> Encoding Source # | |
(ToJSON a, ToJSON b, ToJSON c) => ToJSON1 ((,,,) a b c) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, a0) -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, a0)] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, a0) -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, a0)] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> (a, b, c, a0) -> Bool Source # | |
(ToJSON1 f, ToJSON1 g) => ToJSON1 (Compose f g) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Compose f g a -> Value Source # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Compose f g a] -> Value Source # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Compose f g a -> Encoding Source # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Compose f g a] -> Encoding Source # liftOmitField :: (a -> Bool) -> Compose f g a -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d) => ToJSON1 ((,,,,) a b c d) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, a0) -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, a0)] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, a0) -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, a0)] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> (a, b, c, d, a0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e) => ToJSON1 ((,,,,,) a b c d e) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, a0) -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, a0)] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, a0) -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, a0)] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> (a, b, c, d, e, a0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f) => ToJSON1 ((,,,,,,) a b c d e f) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, f, a0) -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, f, a0)] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, f, a0) -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, f, a0)] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> (a, b, c, d, e, f, a0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g) => ToJSON1 ((,,,,,,,) a b c d e f g) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, f, g, a0) -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, f, g, a0)] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, f, g, a0) -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, f, g, a0)] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> (a, b, c, d, e, f, g, a0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h) => ToJSON1 ((,,,,,,,,) a b c d e f g h) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, f, g, h, a0) -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, f, g, h, a0)] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, f, g, h, a0) -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, f, g, h, a0)] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> (a, b, c, d, e, f, g, h, a0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i) => ToJSON1 ((,,,,,,,,,) a b c d e f g h i) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, f, g, h, i, a0) -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, f, g, h, i, a0)] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, a0) -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, a0)] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> (a, b, c, d, e, f, g, h, i, a0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j) => ToJSON1 ((,,,,,,,,,,) a b c d e f g h i j) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, f, g, h, i, j, a0) -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, a0)] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, a0) -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, a0)] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> (a, b, c, d, e, f, g, h, i, j, a0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k) => ToJSON1 ((,,,,,,,,,,,) a b c d e f g h i j k) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, a0) -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, a0)] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, a0) -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, a0)] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> (a, b, c, d, e, f, g, h, i, j, k, a0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l) => ToJSON1 ((,,,,,,,,,,,,) a b c d e f g h i j k l) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, l, a0) -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, l, a0)] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, l, a0) -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, l, a0)] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> (a, b, c, d, e, f, g, h, i, j, k, l, a0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l, ToJSON m) => ToJSON1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a0) -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, a0)] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a0) -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, a0)] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l, ToJSON m, ToJSON n) => ToJSON1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0) -> Value Source # liftToJSONList :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0)] -> Value Source # liftToEncoding :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0) -> Encoding Source # liftToEncodingList :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0)] -> Encoding Source # liftOmitField :: (a0 -> Bool) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0) -> Bool Source # |
toJSON1 :: (ToJSON1 f, ToJSON a) => f a -> Value Source #
Lift the standard toJSON
function through the type constructor.
toEncoding1 :: (ToJSON1 f, ToJSON a) => f a -> Encoding Source #
Lift the standard toEncoding
function through the type constructor.
class ToJSON2 f where Source #
Lifting of the ToJSON
class to binary type constructors.
Instead of manually writing your ToJSON2
instance, Data.Aeson.TH
provides Template Haskell functions which will derive an instance at compile time.
The compiler cannot provide a default generic implementation for liftToJSON2
,
unlike toJSON
and liftToJSON
.
liftToJSON2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> f a b -> Value Source #
liftToJSONList2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> [f a b] -> Value Source #
liftToEncoding2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> f a b -> Encoding Source #
liftToEncodingList2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> [f a b] -> Encoding Source #
liftOmitField2 :: (a -> Bool) -> (b -> Bool) -> f a b -> Bool Source #
Since: 2.2.0.0
Instances
ToJSON2 Either Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> Either a b -> Value Source # liftToJSONList2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> [Either a b] -> Value Source # liftToEncoding2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> Either a b -> Encoding Source # liftToEncodingList2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> [Either a b] -> Encoding Source # liftOmitField2 :: (a -> Bool) -> (b -> Bool) -> Either a b -> Bool Source # | |
ToJSON2 Either Source # | Since: 1.5.3.0 |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> Either a b -> Value Source # liftToJSONList2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> [Either a b] -> Value Source # liftToEncoding2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> Either a b -> Encoding Source # liftToEncodingList2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> [Either a b] -> Encoding Source # liftOmitField2 :: (a -> Bool) -> (b -> Bool) -> Either a b -> Bool Source # | |
ToJSON2 These Source # | Since: 1.5.3.0 |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> These a b -> Value Source # liftToJSONList2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> [These a b] -> Value Source # liftToEncoding2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> These a b -> Encoding Source # liftToEncodingList2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> [These a b] -> Encoding Source # liftOmitField2 :: (a -> Bool) -> (b -> Bool) -> These a b -> Bool Source # | |
ToJSON2 Pair Source # | Since: 1.5.3.0 |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> Pair a b -> Value Source # liftToJSONList2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> [Pair a b] -> Value Source # liftToEncoding2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> Pair a b -> Encoding Source # liftToEncodingList2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> [Pair a b] -> Encoding Source # liftOmitField2 :: (a -> Bool) -> (b -> Bool) -> Pair a b -> Bool Source # | |
ToJSON2 These Source # | Since: 1.5.1.0 |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> These a b -> Value Source # liftToJSONList2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> [These a b] -> Value Source # liftToEncoding2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> These a b -> Encoding Source # liftToEncodingList2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> [These a b] -> Encoding Source # liftOmitField2 :: (a -> Bool) -> (b -> Bool) -> These a b -> Bool Source # | |
ToJSON2 (,) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> (a, b) -> Value Source # liftToJSONList2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> [(a, b)] -> Value Source # liftToEncoding2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, b) -> Encoding Source # liftToEncodingList2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, b)] -> Encoding Source # liftOmitField2 :: (a -> Bool) -> (b -> Bool) -> (a, b) -> Bool Source # | |
ToJSON2 (Const :: Type -> TYPE LiftedRep -> Type) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> Const a b -> Value Source # liftToJSONList2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> [Const a b] -> Value Source # liftToEncoding2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> Const a b -> Encoding Source # liftToEncodingList2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> [Const a b] -> Encoding Source # liftOmitField2 :: (a -> Bool) -> (b -> Bool) -> Const a b -> Bool Source # | |
ToJSON2 (Tagged :: TYPE LiftedRep -> Type -> Type) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> Tagged a b -> Value Source # liftToJSONList2 :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> [Tagged a b] -> Value Source # liftToEncoding2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> Tagged a b -> Encoding Source # liftToEncodingList2 :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> [Tagged a b] -> Encoding Source # liftOmitField2 :: (a -> Bool) -> (b -> Bool) -> Tagged a b -> Bool Source # | |
ToJSON a => ToJSON2 ((,,) a) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> (a, a0, b) -> Value Source # liftToJSONList2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b -> Bool) -> (b -> Value) -> ([b] -> Value) -> [(a, a0, b)] -> Value Source # liftToEncoding2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, a0, b) -> Encoding Source # liftToEncodingList2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b -> Bool) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, a0, b)] -> Encoding Source # liftOmitField2 :: (a0 -> Bool) -> (b -> Bool) -> (a, a0, b) -> Bool Source # | |
(ToJSON a, ToJSON b) => ToJSON2 ((,,,) a b) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, a0, b0) -> Value Source # liftToJSONList2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, a0, b0)] -> Value Source # liftToEncoding2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, a0, b0) -> Encoding Source # liftToEncodingList2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, a0, b0)] -> Encoding Source # liftOmitField2 :: (a0 -> Bool) -> (b0 -> Bool) -> (a, b, a0, b0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c) => ToJSON2 ((,,,,) a b c) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, a0, b0) -> Value Source # liftToJSONList2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, a0, b0)] -> Value Source # liftToEncoding2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, a0, b0) -> Encoding Source # liftToEncodingList2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, a0, b0)] -> Encoding Source # liftOmitField2 :: (a0 -> Bool) -> (b0 -> Bool) -> (a, b, c, a0, b0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d) => ToJSON2 ((,,,,,) a b c d) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, a0, b0) -> Value Source # liftToJSONList2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, a0, b0)] -> Value Source # liftToEncoding2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, a0, b0) -> Encoding Source # liftToEncodingList2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, a0, b0)] -> Encoding Source # liftOmitField2 :: (a0 -> Bool) -> (b0 -> Bool) -> (a, b, c, d, a0, b0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e) => ToJSON2 ((,,,,,,) a b c d e) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, a0, b0) -> Value Source # liftToJSONList2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, a0, b0)] -> Value Source # liftToEncoding2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, e, a0, b0) -> Encoding Source # liftToEncodingList2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, e, a0, b0)] -> Encoding Source # liftOmitField2 :: (a0 -> Bool) -> (b0 -> Bool) -> (a, b, c, d, e, a0, b0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f) => ToJSON2 ((,,,,,,,) a b c d e f) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, f, a0, b0) -> Value Source # liftToJSONList2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, f, a0, b0)] -> Value Source # liftToEncoding2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, e, f, a0, b0) -> Encoding Source # liftToEncodingList2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, e, f, a0, b0)] -> Encoding Source # liftOmitField2 :: (a0 -> Bool) -> (b0 -> Bool) -> (a, b, c, d, e, f, a0, b0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g) => ToJSON2 ((,,,,,,,,) a b c d e f g) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, f, g, a0, b0) -> Value Source # liftToJSONList2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, f, g, a0, b0)] -> Value Source # liftToEncoding2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, e, f, g, a0, b0) -> Encoding Source # liftToEncodingList2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, e, f, g, a0, b0)] -> Encoding Source # liftOmitField2 :: (a0 -> Bool) -> (b0 -> Bool) -> (a, b, c, d, e, f, g, a0, b0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h) => ToJSON2 ((,,,,,,,,,) a b c d e f g h) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, f, g, h, a0, b0) -> Value Source # liftToJSONList2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, f, g, h, a0, b0)] -> Value Source # liftToEncoding2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, e, f, g, h, a0, b0) -> Encoding Source # liftToEncodingList2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, e, f, g, h, a0, b0)] -> Encoding Source # liftOmitField2 :: (a0 -> Bool) -> (b0 -> Bool) -> (a, b, c, d, e, f, g, h, a0, b0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i) => ToJSON2 ((,,,,,,,,,,) a b c d e f g h i) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, f, g, h, i, a0, b0) -> Value Source # liftToJSONList2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, f, g, h, i, a0, b0)] -> Value Source # liftToEncoding2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, a0, b0) -> Encoding Source # liftToEncodingList2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, a0, b0)] -> Encoding Source # liftOmitField2 :: (a0 -> Bool) -> (b0 -> Bool) -> (a, b, c, d, e, f, g, h, i, a0, b0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j) => ToJSON2 ((,,,,,,,,,,,) a b c d e f g h i j) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, f, g, h, i, j, a0, b0) -> Value Source # liftToJSONList2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, a0, b0)] -> Value Source # liftToEncoding2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, a0, b0) -> Encoding Source # liftToEncodingList2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, a0, b0)] -> Encoding Source # liftOmitField2 :: (a0 -> Bool) -> (b0 -> Bool) -> (a, b, c, d, e, f, g, h, i, j, a0, b0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k) => ToJSON2 ((,,,,,,,,,,,,) a b c d e f g h i j k) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, a0, b0) -> Value Source # liftToJSONList2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, a0, b0)] -> Value Source # liftToEncoding2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, a0, b0) -> Encoding Source # liftToEncodingList2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, a0, b0)] -> Encoding Source # liftOmitField2 :: (a0 -> Bool) -> (b0 -> Bool) -> (a, b, c, d, e, f, g, h, i, j, k, a0, b0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l) => ToJSON2 ((,,,,,,,,,,,,,) a b c d e f g h i j k l) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, l, a0, b0) -> Value Source # liftToJSONList2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, l, a0, b0)] -> Value Source # liftToEncoding2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, l, a0, b0) -> Encoding Source # liftToEncodingList2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, l, a0, b0)] -> Encoding Source # liftOmitField2 :: (a0 -> Bool) -> (b0 -> Bool) -> (a, b, c, d, e, f, g, h, i, j, k, l, a0, b0) -> Bool Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l, ToJSON m) => ToJSON2 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a0, b0) -> Value Source # liftToJSONList2 :: (a0 -> Bool) -> (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Bool) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, a0, b0)] -> Value Source # liftToEncoding2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a0, b0) -> Encoding Source # liftToEncodingList2 :: (a0 -> Bool) -> (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Bool) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, a0, b0)] -> Encoding Source # liftOmitField2 :: (a0 -> Bool) -> (b0 -> Bool) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a0, b0) -> Bool Source # |
toJSON2 :: (ToJSON2 f, ToJSON a, ToJSON b) => f a b -> Value Source #
Lift the standard toJSON
function through the type constructor.
toEncoding2 :: (ToJSON2 f, ToJSON a, ToJSON b) => f a b -> Encoding Source #
Lift the standard toEncoding
function through the type constructor.
Generic JSON classes and options
class GFromJSON arity f Source #
Class of generic representation types that can be converted from JSON.
gParseJSON
Instances
GFromJSON One Par1 Source # | |
Defined in Data.Aeson.Types.FromJSON | |
GFromJSON arity (V1 :: Type -> Type) Source # | |
Defined in Data.Aeson.Types.FromJSON | |
FromJSON1 f => GFromJSON One (Rec1 f) Source # | |
Defined in Data.Aeson.Types.FromJSON | |
(GFromJSON' arity a, Datatype d) => GFromJSON arity (D1 d a) Source # | |
Defined in Data.Aeson.Types.FromJSON | |
FromJSON a => GFromJSON arity (K1 i a :: Type -> Type) Source # | |
Defined in Data.Aeson.Types.FromJSON | |
(FromJSON1 f, GFromJSON One g) => GFromJSON One (f :.: g) Source # | |
Defined in Data.Aeson.Types.FromJSON | |
GFromJSON arity a => GFromJSON arity (M1 i c a) Source # | |
Defined in Data.Aeson.Types.FromJSON |
type GToEncoding = GToJSON' Encoding Source #
class GToJSON' enc arity f Source #
Class of generic representation types that can be converted to JSON.
gToJSON
Instances
GToJSON' enc One Par1 Source # | |
GToJSON' Encoding arity (U1 :: TYPE LiftedRep -> Type) Source # | |
GToJSON' Encoding arity (V1 :: TYPE LiftedRep -> Type) Source # | |
GToJSON' Value arity (U1 :: TYPE LiftedRep -> Type) Source # | |
GToJSON' Value arity (V1 :: TYPE LiftedRep -> Type) Source # | |
ToJSON1 f => GToJSON' Encoding One (Rec1 f) Source # | |
ToJSON1 f => GToJSON' Value One (Rec1 f) Source # | |
(EncodeProduct arity a, EncodeProduct arity b) => GToJSON' Encoding arity (a :*: b) Source # | |
ToJSON a => GToJSON' Encoding arity (K1 i a :: TYPE LiftedRep -> Type) Source # | |
(WriteProduct arity a, WriteProduct arity b, ProductSize a, ProductSize b) => GToJSON' Value arity (a :*: b) Source # | |
ToJSON a => GToJSON' Value arity (K1 i a :: TYPE LiftedRep -> Type) Source # | |
(AllNullary (a :+: b) allNullary, SumToJSON enc arity (a :+: b) allNullary) => GToJSON' enc arity (a :+: b) Source # | |
Defined in Data.Aeson.Types.ToJSON | |
ConsToJSON enc arity a => GToJSON' enc arity (C1 c a) Source # | |
Defined in Data.Aeson.Types.ToJSON | |
(ConsToJSON enc arity a, AllNullary (C1 c a) allNullary, SumToJSON enc arity (C1 c a) allNullary) => GToJSON' enc arity (D1 d (C1 c a)) Source # | |
(ToJSON1 f, GToJSON' Encoding One g) => GToJSON' Encoding One (f :.: g) Source # | |
(ToJSON1 f, GToJSON' Value One g) => GToJSON' Value One (f :.: g) Source # | |
GToJSON' enc arity a => GToJSON' enc arity (M1 i c a) Source # | |
Defined in Data.Aeson.Types.ToJSON |
A type-level indicator that ToJSON1
or FromJSON1
is being derived generically.
Instances
GFromJSON One Par1 Source # | |
Defined in Data.Aeson.Types.FromJSON | |
GToJSON' enc One Par1 Source # | |
ToJSON1 f => GToJSON' Encoding One (Rec1 f) Source # | |
ToJSON1 f => GToJSON' Value One (Rec1 f) Source # | |
(ToJSON1 f, GToJSON' Encoding One g) => GToJSON' Encoding One (f :.: g) Source # | |
(ToJSON1 f, GToJSON' Value One g) => GToJSON' Value One (f :.: g) Source # | |
FromJSON1 f => GFromJSON One (Rec1 f) Source # | |
Defined in Data.Aeson.Types.FromJSON | |
(FromJSON1 f, GFromJSON One g) => GFromJSON One (f :.: g) Source # | |
Defined in Data.Aeson.Types.FromJSON |
genericToJSON :: (Generic a, GToJSON' Value Zero (Rep a)) => Options -> a -> Value Source #
A configurable generic JSON creator. This function applied to
defaultOptions
is used as the default for toJSON
when the type
is an instance of Generic
.
genericLiftToJSON :: (Generic1 f, GToJSON' Value One (Rep1 f)) => Options -> (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> f a -> Value Source #
A configurable generic JSON creator. This function applied to
defaultOptions
is used as the default for liftToJSON
when the type
is an instance of Generic1
.
genericToEncoding :: (Generic a, GToJSON' Encoding Zero (Rep a)) => Options -> a -> Encoding Source #
A configurable generic JSON encoder. This function applied to
defaultOptions
is used as the default for toEncoding
when the type
is an instance of Generic
.
genericLiftToEncoding :: (Generic1 f, GToJSON' Encoding One (Rep1 f)) => Options -> (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding Source #
A configurable generic JSON encoder. This function applied to
defaultOptions
is used as the default for liftToEncoding
when the type
is an instance of Generic1
.
genericParseJSON :: (Generic a, GFromJSON Zero (Rep a)) => Options -> Value -> Parser a Source #
A configurable generic JSON decoder. This function applied to
defaultOptions
is used as the default for parseJSON
when the
type is an instance of Generic
.
genericLiftParseJSON :: (Generic1 f, GFromJSON One (Rep1 f)) => Options -> Maybe a -> (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a) Source #
A configurable generic JSON decoder. This function applied to
defaultOptions
is used as the default for liftParseJSON
when the
type is an instance of Generic1
.
Generic and TH encoding configuration
Options that specify how to encode/decode your datatype to/from JSON.
Options can be set using record syntax on defaultOptions
with the fields
below.
defaultOptions :: Options Source #
Default encoding Options
:
Options
{fieldLabelModifier
= id ,constructorTagModifier
= id ,allNullaryToStringTag
= True ,omitNothingFields
= False ,allowOmittedFields
= True ,sumEncoding
=defaultTaggedObject
,unwrapUnaryRecords
= False ,tagSingleConstructors
= False ,rejectUnknownFields
= False }
Options fields
fieldLabelModifier :: Options -> String -> String Source #
Function applied to field labels. Handy for removing common record prefixes for example.
constructorTagModifier :: Options -> String -> String Source #
Function applied to constructor tags which could be handy for lower-casing them for example.
allNullaryToStringTag :: Options -> Bool Source #
If True
the constructors of a datatype, with all
nullary constructors, will be encoded to just a string with
the constructor tag. If False
the encoding will always
follow the sumEncoding
.
omitNothingFields :: Options -> Bool Source #
If True
, record fields with a Nothing
value will be
omitted from the resulting object. If False
, the resulting
object will include those fields mapping to null
.
In aeson-2.2
this flag is generalised to omit all values with
.
If omitField
x = TrueFalse
, the resulting object will include those fields encoded as specified.
Note that this does not affect parsing: Maybe
fields are
optional regardless of the value of omitNothingFields
.
allowOmittedFieds
controls parsing behavior.
allowOmittedFields :: Options -> Bool Source #
sumEncoding :: Options -> SumEncoding Source #
Specifies how to encode constructors of a sum datatype.
unwrapUnaryRecords :: Options -> Bool Source #
Hide the field name when a record constructor has only one field, like a newtype.
tagSingleConstructors :: Options -> Bool Source #
Encode types with a single constructor as sums,
so that allNullaryToStringTag
and sumEncoding
apply.
rejectUnknownFields :: Options -> Bool Source #
Applies only to FromJSON
instances. If a field appears in
the parsed object map, but does not appear in the target object, parsing
will fail, with an error message indicating which fields were unknown.
Options utilities
data SumEncoding Source #
Specifies how to encode constructors of a sum datatype.
TaggedObject | A constructor will be encoded to an object with a field
|
UntaggedValue | Constructor names won't be encoded. Instead only the contents of the constructor will be encoded as if the type had a single constructor. JSON encodings have to be disjoint for decoding to work properly. When decoding, constructors are tried in the order of definition. If some encodings overlap, the first one defined will succeed. Note: Nullary constructors are encoded as strings (using
Note: Only the last error is kept when decoding, so in the case of malformed JSON, only an error for the last constructor will be reported. |
ObjectWithSingleField | A constructor will be encoded to an object with a single
field named after the constructor tag (modified by the
|
TwoElemArray | A constructor will be encoded to a 2-element array where the
first element is the tag of the constructor (modified by the
|
Instances
Show SumEncoding Source # | |
Defined in Data.Aeson.Types.Internal showsPrec :: Int -> SumEncoding -> ShowS # show :: SumEncoding -> String # showList :: [SumEncoding] -> ShowS # | |
Eq SumEncoding Source # | |
Defined in Data.Aeson.Types.Internal (==) :: SumEncoding -> SumEncoding -> Bool # (/=) :: SumEncoding -> SumEncoding -> Bool # |
camelTo2 :: Char -> String -> String Source #
Better version of camelTo
. Example where it works better:
camelTo '_' "CamelAPICase" == "camel_apicase" camelTo2 '_' "CamelAPICase" == "camel_api_case"
defaultTaggedObject :: SumEncoding Source #
Default TaggedObject
SumEncoding
options:
defaultTaggedObject =TaggedObject
{tagFieldName
= "tag" ,contentsFieldName
= "contents" }
Options for object keys
data JSONKeyOptions Source #
Options for encoding keys with genericFromJSONKey
and
genericToJSONKey
.
keyModifier :: JSONKeyOptions -> String -> String Source #
Function applied to keys. Its result is what goes into the encoded
Value
.
Example
The following instances encode the constructor Bar
to lower-case keys
"bar"
.
data Foo = Bar derivingGeneric
opts ::JSONKeyOptions
opts =defaultJSONKeyOptions
{keyModifier
=toLower
} instanceToJSONKey
Foo wheretoJSONKey
=genericToJSONKey
opts instanceFromJSONKey
Foo wherefromJSONKey
=genericFromJSONKey
opts
defaultJSONKeyOptions :: JSONKeyOptions Source #
Default JSONKeyOptions
:
defaultJSONKeyOptions =JSONKeyOptions
{keyModifier
=id
}
Inspecting Value
s
Value
swithObject :: String -> (Object -> Parser a) -> Value -> Parser a Source #
applies withObject
name f valuef
to the Object
when value
is an Object
and fails otherwise.
Error message example
withObject "MyType" f (String "oops") -- Error: "parsing MyType failed, expected Object, but encountered String"
withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a Source #
applies withScientific
name f valuef
to the Scientific
number
when value
is a Number
and fails using typeMismatch
otherwise.
Warning: If you are converting from a scientific to an unbounded
type such as Integer
you may want to add a restriction on the
size of the exponent (see withBoundedScientific
) to prevent
malicious input from filling up the memory of the target system.
Error message example
withScientific "MyType" f (String "oops") -- Error: "parsing MyType failed, expected Number, but encountered String"
withEmbeddedJSON :: String -> (Value -> Parser a) -> Value -> Parser a Source #
Decode a nested JSON-encoded string.
Constructors and accessors
A series of values that, when encoded, should be separated by
commas. Since 0.11.0.0, the .=
operator is overloaded to create
either (Text, Value)
or Series
. You can use Series when
encoding directly to a bytestring builder as in the following
example:
toEncoding (Person name age) = pairs ("name" .= name <> "age" .= age)
(.:) :: FromJSON a => Object -> Key -> Parser a Source #
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) Source #
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 Source #
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"
(.:?=) :: FromJSON a => Object -> Key -> Parser a Source #
Retrieve the value associated with the given key of an Object
.
If the key is not present and the omittedField
is
for some Just
xx
,
the result will be that x
.
Since: 2.2.0.0
(.:!=) :: FromJSON a => Object -> Key -> Parser a Source #
Retrieve the value associated with the given key of an Object
.
If the key is not present or the field is null
and the omittedField
is
for some Just
xx
,
the result will be that x
.
This differs from .:?=
by attempting to parse Null
the same as any
other JSON value, instead of using omittedField
when it's Just
.
Since: 2.2.0.0