| 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 |
Data.Aeson
Contents
Description
Types and functions for working efficiently with JSON data.
(A note on naming: in Greek mythology, Aeson was the father of Jason.)
- 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
- decodeStrict :: FromJSON a => ByteString -> Maybe a
- decodeStrict' :: FromJSON a => ByteString -> Maybe a
- eitherDecodeStrict :: FromJSON a => ByteString -> Either String a
- eitherDecodeStrict' :: FromJSON a => ByteString -> Either String a
- data Value
- type Encoding = Encoding' Value
- fromEncoding :: Encoding' tag -> Builder
- type Array = Vector Value
- type Object = HashMap Text Value
- newtype DotNetTime = DotNetTime {}
- class FromJSON a where
- data Result a
- fromJSON :: FromJSON a => Value -> Result a
- class ToJSON a where
- class KeyValue kv where
- class ToJSONKey a where
- data ToJSONKeyFunction a
- = ToJSONKeyText !(a -> Text) !(a -> Encoding' Text)
- | ToJSONKeyValue !(a -> Value) !(a -> Encoding)
- class FromJSONKey a where
- data FromJSONKeyFunction a
- = FromJSONKeyCoerce !(CoerceText a)
- | FromJSONKeyText !(Text -> a)
- | FromJSONKeyTextParser !(Text -> Parser a)
- | FromJSONKeyValue !(Value -> Parser a)
- 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
- toJSON1 :: (ToJSON1 f, ToJSON a) => f a -> Value
- toEncoding1 :: (ToJSON1 f, ToJSON a) => f a -> Encoding
- class ToJSON2 f where
- 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
- data FromArgs arity a where
- class GToJSON arity f where
- class GToEncoding arity f where
- data ToArgs res arity a where
- data Zero
- data One
- genericToJSON :: (Generic a, GToJSON Zero (Rep a)) => Options -> a -> Value
- genericLiftToJSON :: (Generic1 f, GToJSON One (Rep1 f)) => Options -> (a -> Value) -> ([a] -> Value) -> f a -> Value
- genericToEncoding :: (Generic a, GToEncoding Zero (Rep a)) => Options -> a -> Encoding
- genericLiftToEncoding :: (Generic1 f, GToEncoding 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)
- defaultOptions :: Options
- withObject :: String -> (Object -> Parser a) -> Value -> Parser a
- withText :: String -> (Text -> Parser a) -> Value -> Parser a
- withArray :: String -> (Array -> Parser a) -> Value -> Parser a
- withNumber :: String -> (Number -> Parser a) -> Value -> Parser a
- withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
- withBool :: String -> (Bool -> Parser a) -> Value -> Parser a
- data Series
- 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
- json :: Parser Value
- json' :: Parser Value
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 to 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.
instanceToJSONPerson where -- No need to provide atoJSONimplementation. -- For efficiency, we write a simpletoEncodingimplementation, as -- the default version usestoJSON.toEncoding=genericToEncodingdefaultOptionsinstanceFromJSONPerson -- No need to provide aparseJSONimplementation.
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 ShowTo decode data, we need to define a FromJSON instance:
{-# LANGUAGE OverloadedStrings #-}
instance FromJSON Person where
parseJSON (Object v) = Person <$>
v .: "name" <*>
v .: "age"
-- A non-Object value is of the wrong type, so fail.
parseJSON _ = emptyWe 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 a Value
toJSON (Person name age) =
object ["name" .= name, "age" .= age]
-- this encodes directly to a bytestring Builder
toEncoding (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 Ints:
>>> decode "[1,2,3]" :: Maybe [Int] Just [1,2,3]
And here's an example using the Map type to get a map of
Ints.
>>> 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 Ints.
λ> 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 theFromJSONclass is used to convert to the desired type.
There are two ways to encode a value.
- Convert to a
ValueusingtoJSON, 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=genericToEncodingdefaultOptions
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]"
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.
The input 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.
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.
The input must consist solely of a JSON document, with no trailing data except for whitespace.
This function parses and performs conversion immediately. See
json' for details.
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.
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.
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.
The input 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.
The input must consist solely of a JSON document, with no trailing data except for whitespace.
This function parses and performs conversion immediately. See
json' for details.
eitherDecodeStrict :: FromJSON a => ByteString -> Either String a Source #
Like decodeStrict 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.
Core JSON types
A JSON value represented as a Haskell value.
fromEncoding :: Encoding' tag -> Builder Source #
Acquire the underlying bytestring builder.
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.
Constructors
| DotNetTime | |
Fields
| |
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:
emptyandmzerowork, but are terse and uninformativefailyields a custom error messagetypeMismatchproduces an informative message for cases when the value encountered is not of the expected type
An example type and instance:
-- Allow ourselves to writeTextliterals. {-# LANGUAGE OverloadedStrings #-} data Coord = Coord { x :: Double, y :: Double } instance FromJSON Coord where parseJSON (Objectv) = Coord<$>v.:"x"<*>v.:"y" -- We do not expect a non-Objectvalue here. -- We could usemzeroto fail, buttypeMismatch-- gives a much more informative error message. parseJSON invalid =typeMismatch"Coord" invalid
Instead of manually writing your FromJSON instance, there are two options
to do it automatically:
- Data.Aeson.TH provides Template Haskell functions which will derive an instance at compile time. The generated instance is optimized for your type so will probably be more efficient than the following two options:
- The compiler can provide a default generic implementation for
parseJSON.
To use the second, simply add a deriving clause to your
datatype and declare a GenericFromJSON instance for your datatype without giving
a definition for parseJSON.
For example, the previous example can be simplified to just:
{-# LANGUAGE DeriveGeneric #-}
import GHC.Generics
data Coord = Coord { x :: Double, y :: Double } deriving Generic
instance FromJSON Coord
If DefaultSignatures doesn't give exactly the results you want,
you can customize the generic decoding with only a tiny amount of
effort, using genericParseJSON with your preferred Options:
instance FromJSON Coord where
parseJSON = genericParseJSON defaultOptions
Methods
parseJSON :: Value -> Parser a Source #
parseJSON :: (Generic a, GFromJSON Zero (Rep a)) => Value -> Parser a Source #
parseJSONList :: Value -> Parser [a] Source #
Instances
The result of running a Parser.
Instances
| Monad Result Source # | |
| Functor Result Source # | |
| MonadFail Result Source # | |
| Applicative Result Source # | |
| Foldable Result Source # | |
| 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 # | |
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.
An example type and instance:
-- Allow ourselves to writeTextliterals. {-# LANGUAGE OverloadedStrings #-} data Coord = Coord { x :: Double, y :: Double } instance ToJSON Coord where toJSON (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 will probably be more efficient than the following two options:
- 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 GenericToJSON instance for your datatype without giving
definitions for toJSON or toEncoding.
For example, the previous example can be simplified to a more minimal instance:
{-# LANGUAGE DeriveGeneric #-}
import GHC.Generics
data Coord = Coord { x :: Double, y :: Double } deriving Generic
instance ToJSON Coord where
toEncoding = genericToEncoding defaultOptions
Why do we provide an implementation for toEncoding here? The
toEncoding function is a relatively new addition to this class.
To allow users of older versions of this library to upgrade without
having to edit all of their instances or encounter surprising
incompatibilities, the default implementation of toEncoding uses
toJSON. This produces correct results, but since it performs an
intermediate conversion to a Value, it will be less efficient
than directly emitting an Encoding. Our one-liner definition of
toEncoding above bypasses the intermediate Value.
If DefaultSignatures doesn't give exactly the results you want,
you can customize the generic encoding with only a tiny amount of
effort, using genericToJSON and genericToEncoding with your
preferred Options:
instance ToJSON Coord where
toJSON = genericToJSON defaultOptions
toEncoding = genericToEncoding defaultOptions
Methods
Convert a Haskell value to a JSON-friendly intermediate type.
toJSON :: (Generic a, GToJSON 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.
instance ToJSON Coord where
toEncoding = 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.
Minimal complete definition
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 FooThat'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.EncodingThe 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 String 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.EncodingThis 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.
Methods
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 String 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 #
Constructors
| 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 |
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)Methods
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 String 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.
Constructors
| 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 |
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 will probably be more efficient than the following two options:
- 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 Generic1FromJSON1 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 } deriving Generic1
instance FromJSON a => FromJSON1 (Pair a)
If DefaultSignatures 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:
instance FromJSON a => FromJSON1 (Pair a) where
liftParseJSON = genericLiftParseJSON defaultOptions
Methods
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.
Minimal complete definition
Methods
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 will probably be more efficient than the following two options:
- 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 Generic1ToJSON1 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 } deriving Generic1
instance ToJSON a => ToJSON1 (Pair a)
If DefaultSignatures 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:
instance ToJSON a => ToJSON1 (Pair a) where
liftToJSON = genericLiftToJSON defaultOptions
liftToEncoding = genericLiftToEncoding defaultOptions
Methods
liftToJSON :: (a -> Value) -> ([a] -> Value) -> f a -> Value Source #
liftToJSON :: (Generic1 f, GToJSON 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, GToEncoding 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.
Minimal complete definition
Methods
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 :: (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 where Source #
Class of generic representation types that can be converted from JSON.
Minimal complete definition
Methods
gParseJSON :: Options -> FromArgs arity a -> Value -> Parser (f a) Source #
This method (applied to defaultOptions) is used as the
default generic implementation of parseJSON (if the arity is Zero)
or liftParseJSON (if the arity is One).
Instances
| GFromJSON arity U1 Source # | |
| GFromJSON One Par1 Source # | |
| FromJSON1 f => GFromJSON One (Rec1 f) Source # | |
| (AllNullary ((:+:) a b) allNullary, ParseSum * arity ((:+:) a b) allNullary) => GFromJSON arity ((:+:) a b) Source # | |
| (FromProduct arity a, FromProduct arity b, ProductSize a, ProductSize b) => GFromJSON arity ((:*:) a b) Source # | |
| ConsFromJSON arity a => GFromJSON arity (C1 c a) Source # | |
| FromJSON a => GFromJSON arity (K1 i a) Source # | |
| (FromJSON1 f, GFromJSON One g) => GFromJSON One ((:.:) f g) Source # | |
| GFromJSON arity a => GFromJSON arity (M1 i c a) Source # | |
class GToJSON arity f where Source #
Class of generic representation types that can be converted to JSON.
Minimal complete definition
Methods
gToJSON :: Options -> ToArgs Value arity a -> f a -> Value Source #
This method (applied to defaultOptions) is used as the
default generic implementation of toJSON (if the arity is Zero)
or liftToJSON (if the arity is One).
Instances
| GToJSON arity U1 Source # | |
| GToJSON One Par1 Source # | |
| ToJSON1 f => GToJSON One (Rec1 f) Source # | |
| (AllNullary ((:+:) a b) allNullary, SumToJSON * arity ((:+:) a b) allNullary) => GToJSON arity ((:+:) a b) Source # | |
| (WriteProduct arity a, WriteProduct arity b, ProductSize a, ProductSize b) => GToJSON arity ((:*:) a b) Source # | |
| ConsToJSON arity a => GToJSON arity (C1 c a) Source # | |
| ToJSON a => GToJSON arity (K1 i a) Source # | |
| (ToJSON1 f, GToJSON One g) => GToJSON One ((:.:) f g) Source # | |
| GToJSON arity a => GToJSON arity (M1 i c a) Source # | |
class GToEncoding arity f where Source #
Class of generic representation types that can be converted to
a JSON Encoding.
Minimal complete definition
Methods
gToEncoding :: Options -> ToArgs Encoding arity a -> f a -> Encoding Source #
This method (applied to defaultOptions) can be used as the
default generic implementation of toEncoding (if the arity is Zero)
or liftToEncoding (if the arity is One).
Instances
| GToEncoding arity U1 Source # | |
| GToEncoding One Par1 Source # | |
| ToJSON1 f => GToEncoding One (Rec1 f) Source # | |
| (AllNullary ((:+:) a b) allNullary, SumToEncoding * arity ((:+:) a b) allNullary) => GToEncoding arity ((:+:) a b) Source # | |
| (EncodeProduct arity a, EncodeProduct arity b) => GToEncoding arity ((:*:) a b) Source # | |
| ConsToEncoding arity a => GToEncoding arity (C1 c a) Source # | |
| ToJSON a => GToEncoding arity (K1 i a) Source # | |
| (ToJSON1 f, GToEncoding One g) => GToEncoding One ((:.:) f g) Source # | |
| GToEncoding arity a => GToEncoding arity (M1 i c a) Source # | |
A type-level indicator that ToJSON1 or FromJSON1 is being derived generically.
Instances
| GToEncoding One Par1 Source # | |
| GToJSON One Par1 Source # | |
| GFromJSON One Par1 Source # | |
| ToJSON1 f => GToEncoding One (Rec1 f) Source # | |
| ToJSON1 f => GToJSON One (Rec1 f) Source # | |
| FromJSON1 f => GFromJSON One (Rec1 f) Source # | |
| (ToJSON1 f, GToEncoding One g) => GToEncoding One ((:.:) f g) Source # | |
| (ToJSON1 f, GToJSON One g) => GToJSON One ((:.:) f g) Source # | |
| (FromJSON1 f, GFromJSON One g) => GFromJSON One ((:.:) f g) Source # | |
genericToJSON :: (Generic a, GToJSON 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 One (Rep1 f)) => Options -> (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, GToEncoding 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, GToEncoding One (Rep1 f)) => Options -> (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 -> (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.
defaultOptions :: Options Source #
Default encoding Options:
Options{fieldLabelModifier= id ,constructorTagModifier= id ,allNullaryToStringTag= True ,omitNothingFields= False ,sumEncoding=defaultTaggedObject,unwrapUnaryRecords= False }
Inspecting Values
ValueswithObject :: String -> (Object -> Parser a) -> Value -> Parser a Source #
withObject expected f value applies f to the Object when value is an Object
and fails using typeMismatch expected
withText :: String -> (Text -> Parser a) -> Value -> Parser a Source #
withText expected f value applies f to the Text when value is a String
and fails using typeMismatch expected
withArray :: String -> (Array -> Parser a) -> Value -> Parser a Source #
withArray expected f value applies f to the Array when value is an Array
and fails using typeMismatch expected
withNumber :: String -> (Number -> Parser a) -> Value -> Parser a Source #
Deprecated: Use withScientific instead
withNumber expected f value applies f to the Number when value is a Number.
and fails using typeMismatch expected
withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a Source #
withScientific expected f value applies f to the Scientific number when value is a Number.
and fails using typeMismatch expected
withBool :: String -> (Bool -> Parser a) -> Value -> Parser a Source #
withBool expected f value applies f to the Bool when value is a Bool
and fails using typeMismatch expected
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 -> Text -> 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 -> Text -> 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"
Parsing
Parse a top-level JSON value.
The conversion of a parsed value to a Haskell value is deferred until the Haskell value is needed. This may improve performance if only a subset of the results of conversions are needed, but at a cost in thunk allocation.
This function is an alias for value. In aeson 0.8 and earlier, it
parsed only object or array types, in conformance with the
now-obsolete RFC 4627.
json' :: Parser Value Source #
Parse a top-level JSON value.
This is a strict version of json which avoids building up thunks
during parsing; it performs all conversions immediately. Prefer
this version if most of the JSON data needs to be accessed.
This function is an alias for value'. In aeson 0.8 and earlier, it
parsed only object or array types, in conformance with the
now-obsolete RFC 4627.