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 | None |
Language | Haskell2010 |
Types for working with JSON data.
Synopsis
- data Value
- type Encoding = Encoding' Value
- unsafeToEncoding :: Builder -> Encoding' a
- fromEncoding :: Encoding' tag -> Builder
- data Series
- type Array = Vector Value
- emptyArray :: Value
- type Pair = (Text, Value)
- type Object = HashMap Text Value
- emptyObject :: Value
- newtype DotNetTime = DotNetTime {}
- typeMismatch :: String -> Value -> Parser a
- data Parser a
- data Result a
- class FromJSON a where
- fromJSON :: FromJSON a => Value -> Result a
- parse :: (a -> Parser b) -> a -> Result b
- parseEither :: (a -> Parser b) -> a -> Either String b
- parseMaybe :: (a -> Parser b) -> a -> Maybe b
- class ToJSON a where
- toJSON :: a -> Value
- toEncoding :: a -> Encoding
- toJSONList :: [a] -> Value
- toEncodingList :: [a] -> Encoding
- class KeyValue kv where
- modifyFailure :: (String -> String) -> Parser a -> Parser a
- parserThrowError :: JSONPath -> String -> Parser a
- parserCatchError :: Parser a -> (JSONPath -> String -> Parser a) -> Parser a
- class ToJSONKey a where
- toJSONKey :: ToJSONKeyFunction a
- toJSONKeyList :: ToJSONKeyFunction [a]
- data ToJSONKeyFunction a
- = ToJSONKeyText !(a -> Text) !(a -> Encoding' Text)
- | ToJSONKeyValue !(a -> Value) !(a -> Encoding)
- toJSONKeyText :: (a -> Text) -> ToJSONKeyFunction a
- contramapToJSONKeyFunction :: (b -> a) -> ToJSONKeyFunction a -> ToJSONKeyFunction b
- class FromJSONKey a where
- data FromJSONKeyFunction a
- = FromJSONKeyCoerce !(CoerceText a)
- | FromJSONKeyText !(Text -> a)
- | FromJSONKeyTextParser !(Text -> Parser a)
- | FromJSONKeyValue !(Value -> Parser a)
- fromJSONKeyCoerce :: Coercible Text a => FromJSONKeyFunction a
- coerceFromJSONKeyFunction :: Coercible a b => FromJSONKeyFunction a -> FromJSONKeyFunction b
- mapFromJSONKeyFunction :: (a -> b) -> FromJSONKeyFunction a -> FromJSONKeyFunction b
- class FromJSON1 f where
- parseJSON1 :: (FromJSON1 f, FromJSON a) => Value -> Parser (f a)
- class FromJSON2 f where
- parseJSON2 :: (FromJSON2 f, FromJSON a, FromJSON b) => Value -> Parser (f a b)
- class ToJSON1 f where
- liftToJSON :: (a -> Value) -> ([a] -> Value) -> f a -> Value
- liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [f a] -> Value
- liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding
- liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [f a] -> Encoding
- toJSON1 :: (ToJSON1 f, ToJSON a) => f a -> Value
- toEncoding1 :: (ToJSON1 f, ToJSON a) => f a -> Encoding
- class ToJSON2 f where
- liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> f a b -> Value
- liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [f a b] -> Value
- liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> f a b -> Encoding
- liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [f a b] -> Encoding
- toJSON2 :: (ToJSON2 f, ToJSON a, ToJSON b) => f a b -> Value
- toEncoding2 :: (ToJSON2 f, ToJSON a, ToJSON b) => f a b -> Encoding
- class GFromJSON arity f where
- gParseJSON :: Options -> FromArgs arity a -> Value -> Parser (f a)
- data FromArgs arity a where
- type GToJSON = GToJSON Value
- type GToEncoding = GToJSON Encoding
- data ToArgs res arity a where
- 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 -> 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 -> 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 -> (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a)
- 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
- pairs :: Series -> Encoding
- foldable :: (Foldable t, ToJSON a) => t a -> Encoding
- (.:) :: FromJSON a => Object -> Text -> Parser a
- (.:?) :: FromJSON a => Object -> Text -> Parser (Maybe a)
- (.:!) :: FromJSON a => Object -> Text -> Parser (Maybe a)
- (.!=) :: Parser (Maybe a) -> a -> Parser a
- object :: [Pair] -> Value
- parseField :: FromJSON a => Object -> Text -> Parser a
- parseFieldMaybe :: FromJSON a => Object -> Text -> Parser (Maybe a)
- parseFieldMaybe' :: FromJSON a => Object -> Text -> Parser (Maybe a)
- explicitParseField :: (Value -> Parser a) -> Object -> Text -> Parser a
- explicitParseFieldMaybe :: (Value -> Parser a) -> Object -> Text -> Parser (Maybe a)
- explicitParseFieldMaybe' :: (Value -> Parser a) -> Object -> Text -> Parser (Maybe a)
- listEncoding :: (a -> Encoding) -> [a] -> Encoding
- listValue :: (a -> Value) -> [a] -> Value
- listParser :: (Value -> Parser a) -> Value -> Parser [a]
- data Options
- fieldLabelModifier :: Options -> String -> String
- constructorTagModifier :: Options -> String -> String
- allNullaryToStringTag :: Options -> Bool
- omitNothingFields :: Options -> Bool
- sumEncoding :: Options -> SumEncoding
- unwrapUnaryRecords :: Options -> Bool
- tagSingleConstructors :: Options -> Bool
- data SumEncoding
- camelTo :: Char -> String -> String
- camelTo2 :: Char -> String -> String
- defaultOptions :: Options
- defaultTaggedObject :: SumEncoding
Core JSON types
A JSON value represented as a Haskell value.
Instances
unsafeToEncoding :: Builder -> Encoding' a Source #
Make Encoding from Builder.
Use with care! You have to make sure that the passed Builder is a valid JSON Encoding!
fromEncoding :: Encoding' tag -> Builder Source #
Acquire the underlying bytestring builder.
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)
emptyArray :: Value Source #
The empty array.
emptyObject :: Value Source #
The empty object.
Convenience types and functions
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
:: String | The name of the type you are trying to parse. |
-> Value | The actual value encountered. |
-> Parser a |
Fail parsing due to a type mismatch, with a descriptive message.
Example usage:
instance FromJSON Coord where parseJSON (Object
v) = {- type matches, life is good -} parseJSON wat =typeMismatch
"Coord" wat
Type conversion
A JSON parser. N.B. This might not fit your usual understanding of
"parser". Instead you might like to think of Parser
as a "parse result",
i.e. a parser to which the input has already been applied.
The result of running a Parser
.
Instances
Monad Result Source # | |
Functor Result Source # | |
MonadFail Result Source # | |
Defined in Data.Aeson.Types.Internal | |
Applicative Result Source # | |
Foldable Result Source # | |
Defined in Data.Aeson.Types.Internal fold :: Monoid m => Result m -> 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 # | |
MonadPlus Result Source # | |
Eq a => Eq (Result a) Source # | |
Show a => Show (Result a) Source # | |
Semigroup (Result a) Source # | |
Monoid (Result a) Source # | |
NFData a => NFData (Result a) Source # | |
Defined in Data.Aeson.Types.Internal |
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:
empty
andmzero
work, but are terse and uninformative;fail
yields a custom error message;typeMismatch
produces an informative message for cases when the value encountered is not of the expected type.
An example type and instance using typeMismatch
:
-- 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 usemzero
to fail, buttypeMismatch
-- gives a much more informative error message.parseJSON
invalid =typeMismatch
"Coord" invalid
For this common case of only being concerned with a single
type of JSON value, the functions withObject
, withNumber
, 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
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 #
parseJSON :: (Generic a, GFromJSON Zero (Rep a)) => Value -> Parser a Source #
parseJSONList :: Value -> Parser [a] Source #
Instances
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
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 of
toJSON
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.
toJSON :: (Generic a, GToJSON Value Zero (Rep a)) => a -> Value Source #
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 #
Instances
class KeyValue kv where Source #
A key-value pair for encoding a JSON object.
modifyFailure :: (String -> String) -> Parser a -> Parser a Source #
If the inner Parser
failed, modify the failure message using the
provided function. This allows you to create more descriptive error messages.
For example:
parseJSON (Object o) = modifyFailure ("Parsing of the Foo value failed: " ++) (Foo <$> o .: "someField")
Since 0.6.2.0
parserThrowError :: JSONPath -> String -> Parser a Source #
Throw a parser error with an additional path.
Since: 1.2.1.0
parserCatchError :: Parser a -> (JSONPath -> String -> Parser a) -> Parser a Source #
A handler function to handle previous errors and return to normal execution.
Since: 1.2.1.0
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, in
this example, ToJSONKeyText
will be used instead of ToJSONKeyValue
.
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.
toJSONKey :: ToJSON a => ToJSONKeyFunction a Source #
Strategy for rendering the key for a map-like container.
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.
toJSONKeyList :: ToJSON a => ToJSONKeyFunction [a] Source #
Instances
data ToJSONKeyFunction a Source #
ToJSONKeyText !(a -> Text) !(a -> Encoding' Text) | 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 -> b) -> ToJSONKeyFunction b -> ToJSONKeyFunction a # (>$) :: b -> ToJSONKeyFunction b -> ToJSONKeyFunction a # |
toJSONKeyText :: (a -> Text) -> ToJSONKeyFunction a Source #
Helper for creating textual keys.
instanceToJSONKey
MyKey wheretoJSONKey
=toJSONKeyText
myKeyToText where myKeyToText = Text.pack . show -- or showt from text-show
contramapToJSONKeyFunction :: (b -> a) -> ToJSONKeyFunction a -> ToJSONKeyFunction b Source #
Contravariant map, as ToJSONKeyFunction
is a contravariant functor.
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)
Nothing
fromJSONKey :: FromJSONKeyFunction a Source #
Strategy for parsing the key of a map-like container.
fromJSONKey :: FromJSON a => FromJSONKeyFunction a Source #
Strategy for parsing the key of a map-like container.
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.
fromJSONKeyList :: FromJSON a => FromJSONKeyFunction [a] Source #
Instances
data FromJSONKeyFunction a 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 !(CoerceText a) | uses |
FromJSONKeyText !(Text -> a) | conversion from |
FromJSONKeyTextParser !(Text -> Parser a) | conversion from |
FromJSONKeyValue !(Value -> Parser a) | conversion for non-textual keys |
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 # |
fromJSONKeyCoerce :: Coercible Text a => FromJSONKeyFunction a Source #
Construct FromJSONKeyFunction
for types coercible from Text
. This
conversion is still unsafe, as Hashable
and Eq
instances of a
should be
compatible with Text
i.e. hash values should be equal for wrapped values as well.
This property will always be maintained if the Hashable
and Eq
instances
are derived with generalized newtype deriving.
compatible with Text
i.e. hash values be equal for wrapped values as well.
On pre GHC 7.8 this is unconstrainted function.
coerceFromJSONKeyFunction :: Coercible a b => FromJSONKeyFunction a -> FromJSONKeyFunction b Source #
Semantically the same as coerceFromJSONKeyFunction = fmap coerce = coerce
.
See note on fromJSONKeyCoerce
.
mapFromJSONKeyFunction :: (a -> b) -> FromJSONKeyFunction a -> FromJSONKeyFunction b Source #
Same as fmap
. Provided for the consistency with ToJSONKeyFunction
.
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)
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 :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a) Source #
liftParseJSON :: (Generic1 f, GFromJSON One (Rep1 f)) => (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a) Source #
liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [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 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (f a b) Source #
liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [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 = 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 -> Value) -> ([a] -> Value) -> f a -> Value Source #
liftToJSON :: (Generic1 f, GToJSON Value One (Rep1 f)) => (a -> Value) -> ([a] -> Value) -> f a -> Value Source #
liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [f a] -> Value Source #
liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding Source #
liftToEncoding :: (Generic1 f, GToJSON Encoding One (Rep1 f)) => (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding Source #
liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [f a] -> Encoding Source #
Instances
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 -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> f a b -> Value Source #
liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [f a b] -> Value Source #
liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> f a b -> Encoding Source #
liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [f a b] -> Encoding Source #
Instances
ToJSON2 Either Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> Either a b -> Value Source # liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [Either a b] -> Value Source # liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> Either a b -> Encoding Source # liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [Either a b] -> Encoding Source # | |
ToJSON2 (,) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> (a, b) -> Value Source # liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [(a, b)] -> Value Source # liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, b) -> Encoding Source # liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, b)] -> Encoding Source # | |
ToJSON a => ToJSON2 ((,,) a) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a0 -> Value) -> ([a0] -> Value) -> (b -> Value) -> ([b] -> Value) -> (a, a0, b) -> Value Source # liftToJSONList2 :: (a0 -> Value) -> ([a0] -> Value) -> (b -> Value) -> ([b] -> Value) -> [(a, a0, b)] -> Value Source # liftToEncoding2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, a0, b) -> Encoding Source # liftToEncodingList2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, a0, b)] -> Encoding Source # | |
ToJSON2 (Const :: Type -> Type -> Type) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> Const a b -> Value Source # liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [Const a b] -> Value Source # liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> Const a b -> Encoding Source # liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [Const a b] -> Encoding Source # | |
ToJSON2 (Tagged :: Type -> Type -> Type) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> Tagged a b -> Value Source # liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [Tagged a b] -> Value Source # liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> Tagged a b -> Encoding Source # liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [Tagged a b] -> Encoding Source # | |
(ToJSON a, ToJSON b) => ToJSON2 ((,,,) a b) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, a0, b0) -> Value Source # liftToJSONList2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, a0, b0)] -> Value Source # liftToEncoding2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, a0, b0) -> Encoding Source # liftToEncodingList2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, a0, b0)] -> Encoding Source # | |
(ToJSON a, ToJSON b, ToJSON c) => ToJSON2 ((,,,,) a b c) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, a0, b0) -> Value Source # liftToJSONList2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, a0, b0)] -> Value Source # liftToEncoding2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, a0, b0) -> Encoding Source # liftToEncodingList2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, a0, b0)] -> Encoding Source # | |
(ToJSON a, ToJSON b, ToJSON c, ToJSON d) => ToJSON2 ((,,,,,) a b c d) Source # | |
Defined in Data.Aeson.Types.ToJSON liftToJSON2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, a0, b0) -> Value Source # liftToJSONList2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, a0, b0)] -> Value Source # liftToEncoding2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, a0, b0) -> Encoding Source # liftToEncodingList2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, a0, b0)] -> Encoding 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 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, a0, b0) -> Value Source # liftToJSONList2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, a0, b0)] -> Value Source # liftToEncoding2 :: (a0 -> Encoding) -> ([a0] -> |