aeson-1.1.2.0: Fast JSON parsing and encoding

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

- How to use this library
  - Writing instances by hand
  - Working with the AST
  - Decoding to a Haskell value
  - Decoding a mixed-type object
- Encoding and decoding
  - Direct encoding
  - Variants for strict bytestrings
- Core JSON types
- Convenience types
- Type conversion
  - Keys for maps
  - Liftings to unary and binary type constructors
  - Generic JSON classes and options
- Inspecting ``Value`s`
- Constructors and accessors
- Parsing

Description

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
- 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
  - = Object !Object
  - | Array !Array
  - | String !Text
  - | Number !Scientific
  - | Bool !Bool
  - | Null
- type Encoding = Encoding' Value
- fromEncoding :: Encoding' tag -> Builder
- type Array = Vector Value
- type Object = HashMap Text Value
- newtype DotNetTime = DotNetTime {
  - fromDotNetTime :: UTCTime
  }
- class FromJSON a where
- data Result a
  - = Error String
  - | Success 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
  - NoFromArgs :: FromArgs Zero a
  - From1Args :: (Value -> Parser a) -> (Value -> Parser [a]) -> FromArgs One a
- class GToJSON arity f where
- class GToEncoding arity f where
- data ToArgs res arity a where
  - NoToArgs :: ToArgs res Zero a
  - To1Args :: (a -> res) -> ([a] -> res) -> ToArgs res One a
- 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.

    instance ToJSON Person where
        -- No need to provide a toJSON implementation.

        -- For efficiency, we write a simple toEncoding implementation, as
        -- the default version uses toJSON.
        toEncoding = genericToEncoding defaultOptions

    instance FromJSON Person
        -- No need to provide a parseJSON 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 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 `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 the `FromJSON` class is used to convert to the desired type.

There are two ways to encode a value.

- Convert to a `Value` using `toJSON`, then possibly further encode. This was the only method available in aeson 0.9 and earlier.
- Directly encode (to what will become a `ByteString`) using `toEncoding`. 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]"

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

data Value Source #

A JSON value represented as a Haskell value.

Constructors

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

Instances

Eq Value Source # |
Methods (==) :: Value -> Value -> Bool # (/=) :: Value -> Value -> Bool #
Data Value Source # |

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Value -> c Value #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Value #

toConstr :: Value -> Constr #

dataTypeOf :: Value -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Value) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Value) #

gmapT :: (forall b. Data b => b -> b) -> Value -> Value #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r #

gmapQ :: (forall d. Data d => d -> u) -> Value -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Value -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Value -> m Value #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Value -> m Value #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Value -> m Value #

Read Value Source # |
Methods readsPrec :: Int -> ReadS Value # readList :: ReadS [Value] # readPrec :: ReadPrec Value # readListPrec :: ReadPrec [Value] #
Show Value Source # |
Methods showsPrec :: Int -> Value -> ShowS # show :: Value -> String # showList :: [Value] -> ShowS #
IsString Value Source # |
Methods fromString :: String -> Value #
Lift Value Source # |
Methods lift :: Value -> Q Exp #
NFData Value Source # |
Methods rnf :: Value -> () #
Hashable Value Source # |
Methods hashWithSalt :: Int -> Value -> Int # hash :: Value -> Int #
FromJSON Value Source # |
Methods parseJSON :: Value -> Parser Value Source # parseJSONList :: Value -> Parser [Value] Source #
KeyValue Pair Source # |
Methods (.=) :: ToJSON v => Text -> v -> Pair Source #
ToJSON Value Source # |
Methods toJSON :: Value -> Value Source # toEncoding :: Value -> Encoding Source # toJSONList :: [Value] -> Value Source # toEncodingList :: [Value] -> Encoding Source #

type Encoding = Encoding' Value Source #

Often used synonnym for `Encoding'`.

fromEncoding :: Encoding' tag -> Builder Source #

Acquire the underlying bytestring builder.

type Array = Vector Value Source #

A JSON "array" (sequence).

type Object = HashMap Text Value Source #

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

# 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

- fromDotNetTime :: UTCTime

  Acquire the underlying value.

Instances

Eq DotNetTime Source # |
Methods (==) :: DotNetTime -> DotNetTime -> Bool # (/=) :: DotNetTime -> DotNetTime -> Bool #
Ord DotNetTime Source # |
Methods compare :: DotNetTime -> DotNetTime -> Ordering # (<) :: DotNetTime -> DotNetTime -> Bool # (<=) :: DotNetTime -> DotNetTime -> Bool # (>) :: DotNetTime -> DotNetTime -> Bool # (>=) :: DotNetTime -> DotNetTime -> Bool # max :: DotNetTime -> DotNetTime -> DotNetTime # min :: DotNetTime -> DotNetTime -> DotNetTime #
Read DotNetTime Source # |
Methods readsPrec :: Int -> ReadS DotNetTime # readList :: ReadS [DotNetTime] # readPrec :: ReadPrec DotNetTime # readListPrec :: ReadPrec [DotNetTime] #
Show DotNetTime Source # |
Methods showsPrec :: Int -> DotNetTime -> ShowS # show :: DotNetTime -> String # showList :: [DotNetTime] -> ShowS #
FormatTime DotNetTime Source # |
Methods formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> DotNetTime -> String) #
FromJSON DotNetTime Source # |
Methods parseJSON :: Value -> Parser DotNetTime Source # parseJSONList :: Value -> Parser [DotNetTime] Source #
ToJSON DotNetTime Source # |
Methods toJSON :: DotNetTime -> Value Source # toEncoding :: DotNetTime -> Encoding Source # toJSONList :: [DotNetTime] -> Value Source # toEncodingList :: [DotNetTime] -> Encoding Source #

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

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

An example type and instance using `typeMismatch`:

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

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

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

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

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:

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

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

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

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

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

    {-# LANGUAGE DeriveGeneric #-}

    import GHC.Generics

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

    instance FromJSON Coord

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

    customOptions = defaultOptions
                    { fieldLabelModifier = map toUpper
                    }

    instance FromJSON Coord where
        parseJSON = genericParseJSON customOptions

Methods

parseJSON :: Value -> Parser a Source #

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

parseJSONList :: Value -> Parser [a] Source #

Instances

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

data Result a Source #

The result of running a `Parser`.

Constructors

Error String |
Success a |

Instances

Monad Result Source # |
Methods (>>=) :: Result a -> (a -> Result b) -> Result b # (>>) :: Result a -> Result b -> Result b # return :: a -> Result a # fail :: String -> Result a #
Functor Result Source # |
Methods fmap :: (a -> b) -> Result a -> Result b # (<$) :: a -> Result b -> Result a #
MonadFail Result Source # |
Methods fail :: String -> Result a #
Applicative Result Source # |
Methods pure :: a -> Result a # (<*>) :: Result (a -> b) -> Result a -> Result b # (*>) :: Result a -> Result b -> Result b # (<*) :: Result a -> Result b -> Result a #
Foldable Result Source # |

Methods

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 #

toList :: Result a -> [a] #

null :: Result a -> Bool #

length :: Result a -> Int #

elem :: Eq a => a -> Result a -> Bool #

maximum :: Ord a => Result a -> a #

minimum :: Ord a => Result a -> a #

sum :: Num a => Result a -> a #

product :: Num a => Result a -> a #

Traversable Result Source # |
Methods traverse :: Applicative f => (a -> f b) -> Result a -> f (Result b) # sequenceA :: Applicative f => Result (f a) -> f (Result a) # mapM :: Monad m => (a -> m b) -> Result a -> m (Result b) # sequence :: Monad m => Result (m a) -> m (Result a) #
Alternative Result Source # |
Methods empty :: Result a # (<|>) :: Result a -> Result a -> Result a # some :: Result a -> Result [a] # many :: Result a -> Result [a] #
MonadPlus Result Source # |
Methods mzero :: Result a # mplus :: Result a -> Result a -> Result a #
Eq a => Eq (Result a) Source # |
Methods (==) :: Result a -> Result a -> Bool # (/=) :: Result a -> Result a -> Bool #
Show a => Show (Result a) Source # |
Methods showsPrec :: Int -> Result a -> ShowS # show :: Result a -> String # showList :: [Result a] -> ShowS #
Semigroup (Result a) Source # |
Methods (<>) :: Result a -> Result a -> Result a # sconcat :: NonEmpty (Result a) -> Result a # stimes :: Integral b => b -> Result a -> Result a #
Monoid (Result a) Source # |
Methods mempty :: Result a # mappend :: Result a -> Result a -> Result a # mconcat :: [Result a] -> Result a #
NFData a => NFData (Result a) Source # |
Methods rnf :: Result a -> () #

fromJSON :: FromJSON a => Value -> Result a Source #

Convert a value from JSON, failing if the types do not match.

class ToJSON a where Source #

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 write Text literals.
    {-# 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 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 `Generic`` clause to your datatype and declare a `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 } deriving Generic

    instance ToJSON Coord where
        toEncoding = 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
                    }

    instance ToJSON Coord where
        toJSON     = genericToJSON customOptions
        toEncoding = genericToEncoding customOptions

Previous versions of this library only had the `toJSON` method. Adding `toEncoding` had to reasons:

1. toEncoding is more efficient for the common case that the output of `toJSON` is directly serialized to a `ByteString`. Further, expressing either method in terms of the other would be non-optimal.
2. 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 of `toEncoding` use `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`. (this also means that specifying nothing more than `instance ToJSON Coord` would be sufficient as a generically decoding instance, but there probably exists no good reason to not specify `toEncoding` in new instances.)

Methods

toJSON :: a -> Value Source #

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

ToJSON Bool Source # |
Methods toJSON :: Bool -> Value Source # toEncoding :: Bool -> Encoding Source # toJSONList :: [Bool] -> Value Source # toEncodingList :: [Bool] -> Encoding Source #
ToJSON Char Source # |
Methods toJSON :: Char -> Value Source # toEncoding :: Char -> Encoding Source # toJSONList :: [Char] -> Value Source # toEncodingList :: [Char] -> Encoding Source #
ToJSON Double Source # |
Methods toJSON :: Double -> Value Source # toEncoding :: Double -> Encoding Source # toJSONList :: [Double] -> Value Source # toEncodingList :: [Double] -> Encoding Source #
ToJSON Float Source # |
Methods toJSON :: Float -> Value Source # toEncoding :: Float -> Encoding Source # toJSONList :: [Float] -> Value Source # toEncodingList :: [Float] -> Encoding Source #
ToJSON Int Source # |
Methods toJSON :: Int -> Value Source # toEncoding :: Int -> Encoding Source # toJSONList :: [Int] -> Value Source # toEncodingList :: [Int] -> Encoding Source #
ToJSON Int8 Source # |
Methods toJSON :: Int8 -> Value Source # toEncoding :: Int8 -> Encoding Source # toJSONList :: [Int8] -> Value Source # toEncodingList :: [Int8] -> Encoding Source #
ToJSON Int16 Source # |
Methods toJSON :: Int16 -> Value Source # toEncoding :: Int16 -> Encoding Source # toJSONList :: [Int16] -> Value Source # toEncodingList :: [Int16] -> Encoding Source #
ToJSON Int32 Source # |
Methods toJSON :: Int32 -> Value Source # toEncoding :: Int32 -> Encoding Source # toJSONList :: [Int32] -> Value Source # toEncodingList :: [Int32] -> Encoding Source #
ToJSON Int64 Source # |
Methods toJSON :: Int64 -> Value Source # toEncoding :: Int64 -> Encoding Source # toJSONList :: [Int64] -> Value Source # toEncodingList :: [Int64] -> Encoding Source #
ToJSON Integer Source # |
Methods toJSON :: Integer -> Value Source # toEncoding :: Integer -> Encoding Source # toJSONList :: [Integer] -> Value Source # toEncodingList :: [Integer] -> Encoding Source #
ToJSON Ordering Source # |
Methods toJSON :: Ordering -> Value Source # toEncoding :: Ordering -> Encoding Source # toJSONList :: [Ordering] -> Value Source # toEncodingList :: [Ordering] -> Encoding Source #
ToJSON Word Source # |
Methods toJSON :: Word -> Value Source # toEncoding :: Word -> Encoding Source # toJSONList :: [Word] -> Value Source # toEncodingList :: [Word] -> Encoding Source #
ToJSON Word8 Source # |
Methods toJSON :: Word8 -> Value Source # toEncoding :: Word8 -> Encoding Source # toJSONList :: [Word8] -> Value Source # toEncodingList :: [Word8] -> Encoding Source #
ToJSON Word16 Source # |
Methods toJSON :: Word16 -> Value Source # toEncoding :: Word16 -> Encoding Source # toJSONList :: [Word16] -> Value Source # toEncodingList :: [Word16] -> Encoding Source #
ToJSON Word32 Source # |
Methods toJSON :: Word32 -> Value Source # toEncoding :: Word32 -> Encoding Source # toJSONList :: [Word32] -> Value Source # toEncodingList :: [Word32] -> Encoding Source #
ToJSON Word64 Source # |
Methods toJSON :: Word64 -> Value Source # toEncoding :: Word64 -> Encoding Source # toJSONList :: [Word64] -> Value Source # toEncodingList :: [Word64] -> Encoding Source #
ToJSON () Source # |
Methods toJSON :: () -> Value Source # toEncoding :: () -> Encoding Source # toJSONList :: [()] -> Value Source # toEncodingList :: [()] -> Encoding Source #
ToJSON Text Source # |
Methods toJSON :: Text -> Value Source # toEncoding :: Text -> Encoding Source # toJSONList :: [Text] -> Value Source # toEncodingList :: [Text] -> Encoding Source #
ToJSON Text Source # |
Methods toJSON :: Text -> Value Source # toEncoding :: Text -> Encoding Source # toJSONList :: [Text] -> Value Source # toEncodingList :: [Text] -> Encoding Source #
ToJSON Number Source # |
Methods toJSON :: Number -> Value Source # toEncoding :: Number -> Encoding Source # toJSONList :: [Number] -> Value Source # toEncodingList :: [Number] -> Encoding Source #
ToJSON Natural Source # |
Methods toJSON :: Natural -> Value Source # toEncoding :: Natural -> Encoding Source # toJSONList :: [Natural] -> Value Source # toEncodingList :: [Natural] -> Encoding Source #
ToJSON Version Source # |
Methods toJSON :: Version -> Value Source # toEncoding :: Version -> Encoding Source # toJSONList :: [Version] -> Value Source # toEncodingList :: [Version] -> Encoding Source #
ToJSON IntSet Source # |
Methods toJSON :: IntSet -> Value Source # toEncoding :: IntSet -> Encoding Source # toJSONList :: [IntSet] -> Value Source # toEncodingList :: [IntSet] -> Encoding Source #
ToJSON Scientific Source # |
Methods toJSON :: Scientific -> Value Source # toEncoding :: Scientific -> Encoding Source # toJSONList :: [Scientific] -> Value Source # toEncodingList :: [Scientific] -> Encoding Source #
ToJSON LocalTime Source # |
Methods toJSON :: LocalTime -> Value Source # toEncoding :: LocalTime -> Encoding Source # toJSONList :: [LocalTime] -> Value Source # toEncodingList :: [LocalTime] -> Encoding Source #
ToJSON ZonedTime Source # |
Methods toJSON :: ZonedTime -> Value Source # toEncoding :: ZonedTime -> Encoding Source # toJSONList :: [ZonedTime] -> Value Source # toEncodingList :: [ZonedTime] -> Encoding Source #
ToJSON TimeOfDay Source # |
Methods toJSON :: TimeOfDay -> Value Source # toEncoding :: TimeOfDay -> Encoding Source # toJSONList :: [TimeOfDay] -> Value Source # toEncodingList :: [TimeOfDay] -> Encoding Source #
ToJSON UTCTime Source # |
Methods toJSON :: UTCTime -> Value Source # toEncoding :: UTCTime -> Encoding Source # toJSONList :: [UTCTime] -> Value Source # toEncodingList :: [UTCTime] -> Encoding Source #
ToJSON NominalDiffTime Source # |
Methods toJSON :: NominalDiffTime -> Value Source # toEncoding :: NominalDiffTime -> Encoding Source # toJSONList :: [NominalDiffTime] -> Value Source # toEncodingList :: [NominalDiffTime] -> Encoding Source #
ToJSON Day Source # |
Methods toJSON :: Day -> Value Source # toEncoding :: Day -> Encoding Source # toJSONList :: [Day] -> Value Source # toEncodingList :: [Day] -> Encoding Source #
ToJSON UUID Source # |
Methods toJSON :: UUID -> Value Source # toEncoding :: UUID -> Encoding Source # toJSONList :: [UUID] -> Value Source # toEncodingList :: [UUID] -> Encoding Source #
ToJSON DotNetTime Source # |
Methods toJSON :: DotNetTime -> Value Source # toEncoding :: DotNetTime -> Encoding Source # toJSONList :: [DotNetTime] -> Value Source # toEncodingList :: [DotNetTime] -> Encoding Source #
ToJSON Value Source # |
Methods toJSON :: Value -> Value Source # toEncoding :: Value -> Encoding Source # toJSONList :: [Value] -> Value Source # toEncodingList :: [Value] -> Encoding Source #
ToJSON a => ToJSON [a] Source # |
Methods toJSON :: [a] -> Value Source # toEncoding :: [a] -> Encoding Source # toJSONList :: [[a]] -> Value Source # toEncodingList :: [[a]] -> Encoding Source #
ToJSON a => ToJSON (Maybe a) Source # |
Methods toJSON :: Maybe a -> Value Source # toEncoding :: Maybe a -> Encoding Source # toJSONList :: [Maybe a] -> Value Source # toEncodingList :: [Maybe a] -> Encoding Source #
(ToJSON a, Integral a) => ToJSON (Ratio a) Source # |
Methods toJSON :: Ratio a -> Value Source # toEncoding :: Ratio a -> Encoding Source # toJSONList :: [Ratio a] -> Value Source # toEncodingList :: [Ratio a] -> Encoding Source #
ToJSON a => ToJSON (Identity a) Source # |
Methods toJSON :: Identity a -> Value Source # toEncoding :: Identity a -> Encoding Source # toJSONList :: [Identity a] -> Value Source # toEncodingList :: [Identity a] -> Encoding Source #
ToJSON a => ToJSON (Min a) Source # |
Methods toJSON :: Min a -> Value Source # toEncoding :: Min a -> Encoding Source # toJSONList :: [Min a] -> Value Source # toEncodingList :: [Min a] -> Encoding Source #
ToJSON a => ToJSON (Max a) Source # |
Methods toJSON :: Max a -> Value Source # toEncoding :: Max a -> Encoding Source # toJSONList :: [Max a] -> Value Source # toEncodingList :: [Max a] -> Encoding Source #
ToJSON a => ToJSON (First a) Source # |
Methods toJSON :: First a -> Value Source # toEncoding :: First a -> Encoding Source # toJSONList :: [First a] -> Value Source # toEncodingList :: [First a] -> Encoding Source #
ToJSON a => ToJSON (Last a) Source # |
Methods toJSON :: Last a -> Value Source # toEncoding :: Last a -> Encoding Source # toJSONList :: [Last a] -> Value Source # toEncodingList :: [Last a] -> Encoding Source #
ToJSON a => ToJSON (WrappedMonoid a) Source # |
Methods toJSON :: WrappedMonoid a -> Value Source # toEncoding :: WrappedMonoid a -> Encoding Source # toJSONList :: [WrappedMonoid a] -> Value Source # toEncodingList :: [WrappedMonoid a] -> Encoding Source #
ToJSON a => ToJSON (Option a) Source # |
Methods toJSON :: Option a -> Value Source # toEncoding :: Option a -> Encoding Source # toJSONList :: [Option a] -> Value Source # toEncodingList :: [Option a] -> Encoding Source #
ToJSON a => ToJSON (NonEmpty a) Source # |
Methods toJSON :: NonEmpty a -> Value Source # toEncoding :: NonEmpty a -> Encoding Source # toJSONList :: [NonEmpty a] -> Value Source # toEncodingList :: [NonEmpty a] -> Encoding Source #
HasResolution a => ToJSON (Fixed a) Source # |
Methods toJSON :: Fixed a -> Value Source # toEncoding :: Fixed a -> Encoding Source # toJSONList :: [Fixed a] -> Value Source # toEncodingList :: [Fixed a] -> Encoding Source #
ToJSON a => ToJSON (Dual a) Source # |
Methods toJSON :: Dual a -> Value Source # toEncoding :: Dual a -> Encoding Source # toJSONList :: [Dual a] -> Value Source # toEncodingList :: [Dual a] -> Encoding Source #
ToJSON a => ToJSON (First a) Source # |
Methods toJSON :: First a -> Value Source # toEncoding :: First a -> Encoding Source # toJSONList :: [First a] -> Value Source # toEncodingList :: [First a] -> Encoding Source #
ToJSON a => ToJSON (Last a) Source # |
Methods toJSON :: Last a -> Value Source # toEncoding :: Last a -> Encoding Source # toJSONList :: [Last a] -> Value Source # toEncodingList :: [Last a] -> Encoding Source #
ToJSON a => ToJSON (IntMap a) Source # |
Methods toJSON :: IntMap a -> Value Source # toEncoding :: IntMap a -> Encoding Source # toJSONList :: [IntMap a] -> Value Source # toEncodingList :: [IntMap a] -> Encoding Source #
ToJSON v => ToJSON (Tree v) Source # |
Methods toJSON :: Tree v -> Value Source # toEncoding :: Tree v -> Encoding Source # toJSONList :: [Tree v] -> Value Source # toEncodingList :: [Tree v] -> Encoding Source #
ToJSON a => ToJSON (Seq a) Source # |
Methods toJSON :: Seq a -> Value Source # toEncoding :: Seq a -> Encoding Source # toJSONList :: [Seq a] -> Value Source # toEncodingList :: [Seq a] -> Encoding Source #
ToJSON a => ToJSON (Set a) Source # |
Methods toJSON :: Set a -> Value Source # toEncoding :: Set a -> Encoding Source # toJSONList :: [Set a] -> Value Source # toEncodingList :: [Set a] -> Encoding Source #
ToJSON a => ToJSON (DList a) Source # |
Methods toJSON :: DList a -> Value Source # toEncoding :: DList a -> Encoding Source # toJSONList :: [DList a] -> Value Source # toEncodingList :: [DList a] -> Encoding Source #
ToJSON a => ToJSON (HashSet a) Source # |
Methods toJSON :: HashSet a -> Value Source # toEncoding :: HashSet a -> Encoding Source # toJSONList :: [HashSet a] -> Value Source # toEncodingList :: [HashSet a] -> Encoding Source #
ToJSON a => ToJSON (Vector a) Source # |
Methods toJSON :: Vector a -> Value Source # toEncoding :: Vector a -> Encoding Source # toJSONList :: [Vector a] -> Value Source # toEncodingList :: [Vector a] -> Encoding Source #
(Storable a, ToJSON a) => ToJSON (Vector a) Source # |
Methods toJSON :: Vector a -> Value Source # toEncoding :: Vector a -> Encoding Source # toJSONList :: [Vector a] -> Value Source # toEncodingList :: [Vector a] -> Encoding Source #
(Vector Vector a, ToJSON a) => ToJSON (Vector a) Source # |
Methods toJSON :: Vector a -> Value Source # toEncoding :: Vector a -> Encoding Source # toJSONList :: [Vector a] -> Value Source # toEncodingList :: [Vector a] -> Encoding Source #
(Prim a, ToJSON a) => ToJSON (Vector a) Source # |
Methods toJSON :: Vector a -> Value Source # toEncoding :: Vector a -> Encoding Source # toJSONList :: [Vector a] -> Value Source # toEncodingList :: [Vector a] -> Encoding Source #
(ToJSON a, ToJSON b) => ToJSON (Either a b) Source # |
Methods toJSON :: Either a b -> Value Source # toEncoding :: Either a b -> Encoding Source # toJSONList :: [Either a b] -> Value Source # toEncodingList :: [Either a b] -> Encoding Source #
(ToJSON a, ToJSON b) => ToJSON (a, b) Source # |
Methods toJSON :: (a, b) -> Value Source # toEncoding :: (a, b) -> Encoding Source # toJSONList :: [(a, b)] -> Value Source # toEncodingList :: [(a, b)] -> Encoding Source #
ToJSON (Proxy k a) Source # |
Methods toJSON :: Proxy k a -> Value Source # toEncoding :: Proxy k a -> Encoding Source # toJSONList :: [Proxy k a] -> Value Source # toEncodingList :: [Proxy k a] -> Encoding Source #
(ToJSON v, ToJSONKey k) => ToJSON (Map k v) Source # |
Methods toJSON :: Map k v -> Value Source # toEncoding :: Map k v -> Encoding Source # toJSONList :: [Map k v] -> Value Source # toEncodingList :: [Map k v] -> Encoding Source #
(ToJSON v, ToJSONKey k) => ToJSON (HashMap k v) Source # |
Methods toJSON :: HashMap k v -> Value Source # toEncoding :: HashMap k v -> Encoding Source # toJSONList :: [HashMap k v] -> Value Source # toEncodingList :: [HashMap k v] -> Encoding Source #
(ToJSON a, ToJSON b, ToJSON c) => ToJSON (a, b, c) Source # |
Methods toJSON :: (a, b, c) -> Value Source # toEncoding :: (a, b, c) -> Encoding Source # toJSONList :: [(a, b, c)] -> Value Source # toEncodingList :: [(a, b, c)] -> Encoding Source #
ToJSON a => ToJSON (Const k a b) Source # |
Methods toJSON :: Const k a b -> Value Source # toEncoding :: Const k a b -> Encoding Source # toJSONList :: [Const k a b] -> Value Source # toEncodingList :: [Const k a b] -> Encoding Source #
ToJSON b => ToJSON (Tagged k a b) Source # |
Methods toJSON :: Tagged k a b -> Value Source # toEncoding :: Tagged k a b -> Encoding Source # toJSONList :: [Tagged k a b] -> Value Source # toEncodingList :: [Tagged k a b] -> Encoding Source #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d) => ToJSON (a, b, c, d) Source # |
Methods toJSON :: (a, b, c, d) -> Value Source # toEncoding :: (a, b, c, d) -> Encoding Source # toJSONList :: [(a, b, c, d)] -> Value Source # toEncodingList :: [(a, b, c, d)] -> Encoding Source #
(ToJSON1 f, ToJSON1 g, ToJSON a) => ToJSON (Sum * f g a) Source # |
Methods toJSON :: Sum * f g a -> Value Source # toEncoding :: Sum * f g a -> Encoding Source # toJSONList :: [Sum * f g a] -> Value Source # toEncodingList :: [Sum * f g a] -> Encoding Source #
(ToJSON1 f, ToJSON1 g, ToJSON a) => ToJSON (Product * f g a) Source # |
Methods toJSON :: Product * f g a -> Value Source # toEncoding :: Product * f g a -> Encoding Source # toJSONList :: [Product * f g a] -> Value Source # toEncodingList :: [Product * f g a] -> Encoding Source #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e) => ToJSON (a, b, c, d, e) Source # |
Methods toJSON :: (a, b, c, d, e) -> Value Source # toEncoding :: (a, b, c, d, e) -> Encoding Source # toJSONList :: [(a, b, c, d, e)] -> Value Source # toEncodingList :: [(a, b, c, d, e)] -> Encoding Source #
(ToJSON1 f, ToJSON1 g, ToJSON a) => ToJSON (Compose * * f g a) Source # |
Methods toJSON :: Compose * * f g a -> Value Source # toEncoding :: Compose * * f g a -> Encoding Source # toJSONList :: [Compose * * f g a] -> Value Source # toEncodingList :: [Compose * * f g a] -> Encoding Source #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f) => ToJSON (a, b, c, d, e, f) Source # |
Methods toJSON :: (a, b, c, d, e, f) -> Value Source # toEncoding :: (a, b, c, d, e, f) -> Encoding Source # toJSONList :: [(a, b, c, d, e, f)] -> Value Source # toEncodingList :: [(a, b, c, d, e, f)] -> Encoding Source #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g) => ToJSON (a, b, c, d, e, f, g) Source # |
Methods toJSON :: (a, b, c, d, e, f, g) -> Value Source # toEncoding :: (a, b, c, d, e, f, g) -> Encoding Source # toJSONList :: [(a, b, c, d, e, f, g)] -> Value Source # toEncodingList :: [(a, b, c, d, e, f, g)] -> Encoding Source #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h) => ToJSON (a, b, c, d, e, f, g, h) Source # |
Methods toJSON :: (a, b, c, d, e, f, g, h) -> Value Source # toEncoding :: (a, b, c, d, e, f, g, h) -> Encoding Source # toJSONList :: [(a, b, c, d, e, f, g, h)] -> Value Source # toEncodingList :: [(a, b, c, d, e, f, g, h)] -> Encoding Source #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i) => ToJSON (a, b, c, d, e, f, g, h, i) Source # |
Methods toJSON :: (a, b, c, d, e, f, g, h, i) -> Value Source # toEncoding :: (a, b, c, d, e, f, g, h, i) -> Encoding Source # toJSONList :: [(a, b, c, d, e, f, g, h, i)] -> Value Source # toEncodingList :: [(a, b, c, d, e, f, g, h, i)] -> Encoding Source #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j) => ToJSON (a, b, c, d, e, f, g, h, i, j) Source # |
Methods toJSON :: (a, b, c, d, e, f, g, h, i, j) -> Value Source # toEncoding :: (a, b, c, d, e, f, g, h, i, j) -> Encoding Source # toJSONList :: [(a, b, c, d, e, f, g, h, i, j)] -> Value Source # toEncodingList :: [(a, b, c, d, e, f, g, h, i, j)] -> Encoding Source #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k) => ToJSON (a, b, c, d, e, f, g, h, i, j, k) Source # |
Methods toJSON :: (a, b, c, d, e, f, g, h, i, j, k) -> Value Source # toEncoding :: (a, b, c, d, e, f, g, h, i, j, k) -> Encoding Source # toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> Value Source # toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> Encoding 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 (a, b, c, d, e, f, g, h, i, j, k, l) Source # |
Methods toJSON :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Value Source # toEncoding :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Encoding Source # toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> Value Source # toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> Encoding 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 (a, b, c, d, e, f, g, h, i, j, k, l, m) Source # |
Methods toJSON :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Value Source # toEncoding :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Encoding Source # toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> Value Source # toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> Encoding 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) => ToJSON (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source # |
Methods toJSON :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Value Source # toEncoding :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Encoding Source # toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> Value Source # toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> Encoding 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, ToJSON o) => ToJSON (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source # |
Methods toJSON :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Value Source # toEncoding :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Encoding Source # toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> Value Source # toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> Encoding Source #

class KeyValue kv where Source #

A key-value pair for encoding a JSON object.

Minimal complete definition

(.=)

Methods

(.=) :: ToJSON v => Text -> v -> kv infixr 8 Source #

Instances

KeyValue Pair Source # |
Methods (.=) :: ToJSON v => Text -> v -> Pair Source #
KeyValue Series Source # |
Methods (.=) :: ToJSON v => Text -> v -> Series 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, 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 `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.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.

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 #

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.

Instances

ToJSONKey Bool Source # |
Methods toJSONKey :: ToJSONKeyFunction Bool Source # toJSONKeyList :: ToJSONKeyFunction [Bool] Source #
ToJSONKey Char Source # |
Methods toJSONKey :: ToJSONKeyFunction Char Source # toJSONKeyList :: ToJSONKeyFunction [Char] Source #
ToJSONKey Double Source # |
Methods toJSONKey :: ToJSONKeyFunction Double Source # toJSONKeyList :: ToJSONKeyFunction [Double] Source #
ToJSONKey Float Source # |
Methods toJSONKey :: ToJSONKeyFunction Float Source # toJSONKeyList :: ToJSONKeyFunction [Float] Source #
ToJSONKey Int Source # |
Methods toJSONKey :: ToJSONKeyFunction Int Source # toJSONKeyList :: ToJSONKeyFunction [Int] Source #
ToJSONKey Int8 Source # |
Methods toJSONKey :: ToJSONKeyFunction Int8 Source # toJSONKeyList :: ToJSONKeyFunction [Int8] Source #
ToJSONKey Int16 Source # |
Methods toJSONKey :: ToJSONKeyFunction Int16 Source # toJSONKeyList :: ToJSONKeyFunction [Int16] Source #
ToJSONKey Int32 Source # |
Methods toJSONKey :: ToJSONKeyFunction Int32 Source # toJSONKeyList :: ToJSONKeyFunction [Int32] Source #
ToJSONKey Int64 Source # |
Methods toJSONKey :: ToJSONKeyFunction Int64 Source # toJSONKeyList :: ToJSONKeyFunction [Int64] Source #
ToJSONKey Integer Source # |
Methods toJSONKey :: ToJSONKeyFunction Integer Source # toJSONKeyList :: ToJSONKeyFunction [Integer] Source #
ToJSONKey Word Source # |
Methods toJSONKey :: ToJSONKeyFunction Word Source # toJSONKeyList :: ToJSONKeyFunction [Word] Source #
ToJSONKey Word8 Source # |
Methods toJSONKey :: ToJSONKeyFunction Word8 Source # toJSONKeyList :: ToJSONKeyFunction [Word8] Source #
ToJSONKey Word16 Source # |
Methods toJSONKey :: ToJSONKeyFunction Word16 Source # toJSONKeyList :: ToJSONKeyFunction [Word16] Source #
ToJSONKey Word32 Source # |
Methods toJSONKey :: ToJSONKeyFunction Word32 Source # toJSONKeyList :: ToJSONKeyFunction [Word32] Source #
ToJSONKey Word64 Source # |
Methods toJSONKey :: ToJSONKeyFunction Word64 Source # toJSONKeyList :: ToJSONKeyFunction [Word64] Source #
ToJSONKey Text Source # |
Methods toJSONKey :: ToJSONKeyFunction Text Source # toJSONKeyList :: ToJSONKeyFunction [Text] Source #
ToJSONKey Text Source # |
Methods toJSONKey :: ToJSONKeyFunction Text Source # toJSONKeyList :: ToJSONKeyFunction [Text] Source #
ToJSONKey Natural Source # |
Methods toJSONKey :: ToJSONKeyFunction Natural Source # toJSONKeyList :: ToJSONKeyFunction [Natural] Source #
ToJSONKey Version Source # |
Methods toJSONKey :: ToJSONKeyFunction Version Source # toJSONKeyList :: ToJSONKeyFunction [Version] Source #
ToJSONKey Scientific Source # |
Methods toJSONKey :: ToJSONKeyFunction Scientific Source # toJSONKeyList :: ToJSONKeyFunction [Scientific] Source #
ToJSONKey LocalTime Source # |
Methods toJSONKey :: ToJSONKeyFunction LocalTime Source # toJSONKeyList :: ToJSONKeyFunction [LocalTime] Source #
ToJSONKey ZonedTime Source # |
Methods toJSONKey :: ToJSONKeyFunction ZonedTime Source # toJSONKeyList :: ToJSONKeyFunction [ZonedTime] Source #
ToJSONKey TimeOfDay Source # |
Methods toJSONKey :: ToJSONKeyFunction TimeOfDay Source # toJSONKeyList :: ToJSONKeyFunction [TimeOfDay] Source #
ToJSONKey UTCTime Source # |
Methods toJSONKey :: ToJSONKeyFunction UTCTime Source # toJSONKeyList :: ToJSONKeyFunction [UTCTime] Source #
ToJSONKey Day Source # |
Methods toJSONKey :: ToJSONKeyFunction Day Source # toJSONKeyList :: ToJSONKeyFunction [Day] Source #
ToJSONKey UUID Source # |
Methods toJSONKey :: ToJSONKeyFunction UUID Source # toJSONKeyList :: ToJSONKeyFunction [UUID] Source #
(ToJSONKey a, ToJSON a) => ToJSONKey [a] Source # |
Methods toJSONKey :: ToJSONKeyFunction [a] Source # toJSONKeyList :: ToJSONKeyFunction [[a]] Source #
ToJSONKey a => ToJSONKey (Identity a) Source # |
Methods toJSONKey :: ToJSONKeyFunction (Identity a) Source # toJSONKeyList :: ToJSONKeyFunction [Identity a] Source #
HasResolution a => ToJSONKey (Fixed a) Source # |
Methods toJSONKey :: ToJSONKeyFunction (Fixed a) Source # toJSONKeyList :: ToJSONKeyFunction [Fixed a] Source #
(ToJSON a, ToJSON b) => ToJSONKey (a, b) Source # |
Methods toJSONKey :: ToJSONKeyFunction (a, b) Source # toJSONKeyList :: ToJSONKeyFunction [(a, b)] Source #
(ToJSON a, ToJSON b, ToJSON c) => ToJSONKey (a, b, c) Source # |
Methods toJSONKey :: ToJSONKeyFunction (a, b, c) Source # toJSONKeyList :: ToJSONKeyFunction [(a, b, c)] Source #
ToJSONKey b => ToJSONKey (Tagged k a b) Source # |
Methods toJSONKey :: ToJSONKeyFunction (Tagged k a b) Source # toJSONKeyList :: ToJSONKeyFunction [Tagged k a b] Source #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d) => ToJSONKey (a, b, c, d) Source # |
Methods toJSONKey :: ToJSONKeyFunction (a, b, c, d) Source # toJSONKeyList :: ToJSONKeyFunction [(a, b, c, d)] Source #

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 #

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.

Instances

FromJSONKey Bool Source # |
Methods fromJSONKey :: FromJSONKeyFunction Bool Source # fromJSONKeyList :: FromJSONKeyFunction [Bool] Source #
FromJSONKey Char Source # |
Methods fromJSONKey :: FromJSONKeyFunction Char Source # fromJSONKeyList :: FromJSONKeyFunction [Char] Source #
FromJSONKey Double Source # |
Methods fromJSONKey :: FromJSONKeyFunction Double Source # fromJSONKeyList :: FromJSONKeyFunction [Double] Source #
FromJSONKey Float Source # |
Methods fromJSONKey :: FromJSONKeyFunction Float Source # fromJSONKeyList :: FromJSONKeyFunction [Float] Source #
FromJSONKey Int Source # |
Methods fromJSONKey :: FromJSONKeyFunction Int Source # fromJSONKeyList :: FromJSONKeyFunction [Int] Source #
FromJSONKey Int8 Source # |
Methods fromJSONKey :: FromJSONKeyFunction Int8 Source # fromJSONKeyList :: FromJSONKeyFunction [Int8] Source #
FromJSONKey Int16 Source # |
Methods fromJSONKey :: FromJSONKeyFunction Int16 Source # fromJSONKeyList :: FromJSONKeyFunction [Int16] Source #
FromJSONKey Int32 Source # |
Methods fromJSONKey :: FromJSONKeyFunction Int32 Source # fromJSONKeyList :: FromJSONKeyFunction [Int32] Source #
FromJSONKey Int64 Source # |
Methods fromJSONKey :: FromJSONKeyFunction Int64 Source # fromJSONKeyList :: FromJSONKeyFunction [Int64] Source #
FromJSONKey Integer Source # |
Methods fromJSONKey :: FromJSONKeyFunction Integer Source # fromJSONKeyList :: FromJSONKeyFunction [Integer] Source #
FromJSONKey Word Source # |
Methods fromJSONKey :: FromJSONKeyFunction Word Source # fromJSONKeyList :: FromJSONKeyFunction [Word] Source #
FromJSONKey Word8 Source # |
Methods fromJSONKey :: FromJSONKeyFunction Word8 Source # fromJSONKeyList :: FromJSONKeyFunction [Word8] Source #
FromJSONKey Word16 Source # |
Methods fromJSONKey :: FromJSONKeyFunction Word16 Source # fromJSONKeyList :: FromJSONKeyFunction [Word16] Source #
FromJSONKey Word32 Source # |
Methods fromJSONKey :: FromJSONKeyFunction Word32 Source # fromJSONKeyList :: FromJSONKeyFunction [Word32] Source #
FromJSONKey Word64 Source # |
Methods fromJSONKey :: FromJSONKeyFunction Word64 Source # fromJSONKeyList :: FromJSONKeyFunction [Word64] Source #
FromJSONKey Text Source # |
Methods fromJSONKey :: FromJSONKeyFunction Text Source # fromJSONKeyList :: FromJSONKeyFunction [Text] Source #
FromJSONKey Text Source # |
Methods fromJSONKey :: FromJSONKeyFunction Text Source # fromJSONKeyList :: FromJSONKeyFunction [Text] Source #
FromJSONKey Natural Source # |
Methods fromJSONKey :: FromJSONKeyFunction Natural Source # fromJSONKeyList :: FromJSONKeyFunction [Natural] Source #
FromJSONKey Version Source # |
Methods fromJSONKey :: FromJSONKeyFunction Version Source # fromJSONKeyList :: FromJSONKeyFunction [Version] Source #
FromJSONKey LocalTime Source # |
Methods fromJSONKey :: FromJSONKeyFunction LocalTime Source # fromJSONKeyList :: FromJSONKeyFunction [LocalTime] Source #
FromJSONKey ZonedTime Source # |
Methods fromJSONKey :: FromJSONKeyFunction ZonedTime Source # fromJSONKeyList :: FromJSONKeyFunction [ZonedTime] Source #
FromJSONKey TimeOfDay Source # |
Methods fromJSONKey :: FromJSONKeyFunction TimeOfDay Source # fromJSONKeyList :: FromJSONKeyFunction [TimeOfDay] Source #
FromJSONKey UTCTime Source # |
Methods fromJSONKey :: FromJSONKeyFunction UTCTime Source # fromJSONKeyList :: FromJSONKeyFunction [UTCTime] Source #
FromJSONKey Day Source # |
Methods fromJSONKey :: FromJSONKeyFunction Day Source # fromJSONKeyList :: FromJSONKeyFunction [Day] Source #
FromJSONKey UUID Source # |
Methods fromJSONKey :: FromJSONKeyFunction UUID Source # fromJSONKeyList :: FromJSONKeyFunction [UUID] Source #
(FromJSONKey a, FromJSON a) => FromJSONKey [a] Source # |
Methods fromJSONKey :: FromJSONKeyFunction [a] Source # fromJSONKeyList :: FromJSONKeyFunction [[a]] Source #
FromJSONKey a => FromJSONKey (Identity a) Source # |
Methods fromJSONKey :: FromJSONKeyFunction (Identity a) Source # fromJSONKeyList :: FromJSONKeyFunction [Identity a] Source #
(FromJSON a, FromJSON b) => FromJSONKey (a, b) Source # |
Methods fromJSONKey :: FromJSONKeyFunction (a, b) Source # fromJSONKeyList :: FromJSONKeyFunction [(a, b)] Source #
(FromJSON a, FromJSON b, FromJSON c) => FromJSONKey (a, b, c) Source # |
Methods fromJSONKey :: FromJSONKeyFunction (a, b, c) Source # fromJSONKeyList :: FromJSONKeyFunction [(a, b, c)] Source #
FromJSONKey b => FromJSONKey (Tagged k a b) Source # |
Methods fromJSONKey :: FromJSONKeyFunction (Tagged k a b) Source # fromJSONKeyList :: FromJSONKeyFunction [Tagged k a b] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSONKey (a, b, c, d) Source # |
Methods fromJSONKey :: FromJSONKeyFunction (a, b, c, d) Source # fromJSONKeyList :: FromJSONKeyFunction [(a, b, c, d)] Source #

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 `coerce` (`unsafeCoerce` in older GHCs)
FromJSONKeyText !(Text -> a) | conversion from `Text` that always succeeds
FromJSONKeyTextParser !(Text -> Parser a) | conversion from `Text` that may fail
FromJSONKeyValue !(Value -> Parser a) | conversion for non-textual keys

Instances

Functor FromJSONKeyFunction Source # | Only law abiding up to interpretation
Methods fmap :: (a -> b) -> FromJSONKeyFunction a -> FromJSONKeyFunction b # (<$) :: a -> FromJSONKeyFunction b -> FromJSONKeyFunction a #

## 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 `Generic1`` clause to your datatype and declare a `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 } deriving Generic1

    instance FromJSON 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
                    }

    instance FromJSON a => FromJSON1 (Pair a) where
        liftParseJSON = genericLiftParseJSON customOptions

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

FromJSON1 [] Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [a] Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [[a]] Source #
FromJSON1 Maybe Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Maybe a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Maybe a] Source #
FromJSON1 Identity Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Identity a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Identity a] Source #
FromJSON1 Min Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Min a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Min a] Source #
FromJSON1 Max Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Max a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Max a] Source #
FromJSON1 First Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (First a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [First a] Source #
FromJSON1 Last Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Last a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Last a] Source #
FromJSON1 WrappedMonoid Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (WrappedMonoid a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [WrappedMonoid a] Source #
FromJSON1 Option Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Option a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Option a] Source #
FromJSON1 NonEmpty Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (NonEmpty a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [NonEmpty a] Source #
FromJSON1 Dual Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Dual a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Dual a] Source #
FromJSON1 First Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (First a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [First a] Source #
FromJSON1 Last Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Last a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Last a] Source #
FromJSON1 IntMap Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (IntMap a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [IntMap a] Source #
FromJSON1 Tree Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Tree a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Tree a] Source #
FromJSON1 Seq Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Seq a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Seq a] Source #
FromJSON1 DList Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (DList a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [DList a] Source #
FromJSON1 Vector Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Vector a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Vector a] Source #
FromJSON a => FromJSON1 (Either a) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Either a a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Either a a] Source #
FromJSON a => FromJSON1 ((,) a) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (a, a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [(a, a)] Source #
FromJSON1 (Proxy *) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Proxy * a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Proxy * a] Source #
(FromJSONKey k, Ord k) => FromJSON1 (Map k) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Map k a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Map k a] Source #
(FromJSONKey k, Eq k, Hashable k) => FromJSON1 (HashMap k) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (HashMap k a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [HashMap k a] Source #
(FromJSON a, FromJSON b) => FromJSON1 ((,,) a b) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (a, b, a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [(a, b, a)] Source #
FromJSON a => FromJSON1 (Const * a) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Const * a a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Const * a a] Source #
FromJSON1 (Tagged k a) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Tagged k a a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Tagged k a a] Source #
(FromJSON a, FromJSON b, FromJSON c) => FromJSON1 ((,,,) a b c) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (a, b, c, a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [(a, b, c, a)] Source #
(FromJSON1 f, FromJSON1 g) => FromJSON1 (Sum * f g) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Sum * f g a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Sum * f g a] Source #
(FromJSON1 f, FromJSON1 g) => FromJSON1 (Product * f g) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Product * f g a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Product * f g a] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSON1 ((,,,,) a b c d) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (a, b, c, d, a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [(a, b, c, d, a)] Source #
(FromJSON1 f, FromJSON1 g) => FromJSON1 (Compose * * f g) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Compose * * f g a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Compose * * f g a] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e) => FromJSON1 ((,,,,,) a b c d e) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (a, b, c, d, e, a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [(a, b, c, d, e, a)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f) => FromJSON1 ((,,,,,,) a b c d e f) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (a, b, c, d, e, f, a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [(a, b, c, d, e, f, a)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g) => FromJSON1 ((,,,,,,,) a b c d e f g) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (a, b, c, d, e, f, g, a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [(a, b, c, d, e, f, g, a)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h) => FromJSON1 ((,,,,,,,,) a b c d e f g h) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (a, b, c, d, e, f, g, h, a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [(a, b, c, d, e, f, g, h, a)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i) => FromJSON1 ((,,,,,,,,,) a b c d e f g h i) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, a)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j) => FromJSON1 ((,,,,,,,,,,) a b c d e f g h i j) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, a)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k) => FromJSON1 ((,,,,,,,,,,,) a b c d e f g h i j k) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, a)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l) => FromJSON1 ((,,,,,,,,,,,,) a b c d e f g h i j k l) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, a)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m) => FromJSON1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, a)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m, FromJSON n) => FromJSON1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n) Source # |
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, a)] Source #

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

liftParseJSON2

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

FromJSON2 Either Source # |
Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (Either a b) Source # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [Either a b] Source #
FromJSON2 (,) Source # |
Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (a, b) Source # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [(a, b)] Source #
FromJSON a => FromJSON2 ((,,) a) Source # |
Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (a, a, b) Source # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [(a, a, b)] Source #
FromJSON2 (Const *) Source # |
Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (Const * a b) Source # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [Const * a b] Source #
FromJSON2 (Tagged *) Source # |
Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (Tagged * a b) Source # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [Tagged * a b] Source #
(FromJSON a, FromJSON b) => FromJSON2 ((,,,) a b) Source # |
Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (a, b, a, b) Source # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [(a, b, a, b)] Source #
(FromJSON a, FromJSON b, FromJSON c) => FromJSON2 ((,,,,) a b c) Source # |
Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (a, b, c, a, b) Source # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [(a, b, c, a, b)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSON2 ((,,,,,) a b c d) Source # |
Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (a, b, c, d, a, b) Source # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [(a, b, c, d, a, b)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e) => FromJSON2 ((,,,,,,) a b c d e) Source # |
Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (a, b, c, d, e, a, b) Source # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [(a, b, c, d, e, a, b)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f) => FromJSON2 ((,,,,,,,) a b c d e f) Source # |
Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (a, b, c, d, e, f, a, b) Source # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [(a, b, c, d, e, f, a, b)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g) => FromJSON2 ((,,,,,,,,) a b c d e f g) Source # |
Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (a, b, c, d, e, f, g, a, b) Source # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [(a, b, c, d, e, f, g, a, b)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h) => FromJSON2 ((,,,,,,,,,) a b c d e f g h) Source # |
Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (a, b, c, d, e, f, g, h, a, b) Source # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [(a, b, c, d, e, f, g, h, a, b)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i) => FromJSON2 ((,,,,,,,,,,) a b c d e f g h i) Source # |
Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, a, b) Source # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, a, b)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j) => FromJSON2 ((,,,,,,,,,,,) a b c d e f g h i j) Source # |
Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, a, b) Source # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, a, b)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k) => FromJSON2 ((,,,,,,,,,,,,) a b c d e f g h i j k) Source # |
Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, a, b) Source # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, a, b)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l) => FromJSON2 ((,,,,,,,,,,,,,) a b c d e f g h i j k l) Source # |
Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, a, b) Source # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, a, b)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m) => FromJSON2 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m) Source # |
Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, a, b) Source # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, a, b)] Source #

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 `Generic1`` clause to your datatype and declare a `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 } deriving Generic1

    instance ToJSON 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
                    }

    instance ToJSON a => ToJSON1 (Pair a) where
        liftToJSON     = genericLiftToJSON customOptions
        liftToEncoding = genericLiftToEncoding customOptions

See also `ToJSON`.

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 [] Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> [a] -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [[a]] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> [a] -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [[a]] -> Encoding Source #
ToJSON1 Maybe Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Maybe a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Maybe a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Maybe a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Maybe a] -> Encoding Source #
ToJSON1 Identity Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Identity a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Identity a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Identity a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Identity a] -> Encoding Source #
ToJSON1 Min Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Min a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Min a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Min a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Min a] -> Encoding Source #
ToJSON1 Max Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Max a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Max a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Max a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Max a] -> Encoding Source #
ToJSON1 First Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> First a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [First a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> First a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [First a] -> Encoding Source #
ToJSON1 Last Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Last a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Last a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Last a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Last a] -> Encoding Source #
ToJSON1 WrappedMonoid Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> WrappedMonoid a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [WrappedMonoid a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> WrappedMonoid a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [WrappedMonoid a] -> Encoding Source #
ToJSON1 Option Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Option a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Option a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Option a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Option a] -> Encoding Source #
ToJSON1 NonEmpty Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> NonEmpty a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [NonEmpty a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> NonEmpty a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [NonEmpty a] -> Encoding Source #
ToJSON1 Dual Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Dual a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Dual a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Dual a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Dual a] -> Encoding Source #
ToJSON1 First Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> First a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [First a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> First a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [First a] -> Encoding Source #
ToJSON1 Last Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Last a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Last a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Last a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Last a] -> Encoding Source #
ToJSON1 IntMap Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> IntMap a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [IntMap a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> IntMap a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [IntMap a] -> Encoding Source #
ToJSON1 Tree Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Tree a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Tree a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Tree a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Tree a] -> Encoding Source #
ToJSON1 Seq Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Seq a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Seq a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Seq a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Seq a] -> Encoding Source #
ToJSON1 Set Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Set a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Set a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Set a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Set a] -> Encoding Source #
ToJSON1 DList Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> DList a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [DList a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> DList a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [DList a] -> Encoding Source #
ToJSON1 HashSet Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> HashSet a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [HashSet a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> HashSet a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [HashSet a] -> Encoding Source #
ToJSON1 Vector Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Vector a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Vector a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Vector a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Vector a] -> Encoding Source #
ToJSON a => ToJSON1 (Either a) Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Either a a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Either a a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Either a a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Either a a] -> Encoding Source #
ToJSON a => ToJSON1 ((,) a) Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> (a, a) -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [(a, a)] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> (a, a) -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [(a, a)] -> Encoding Source #
ToJSON1 (Proxy *) Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Proxy * a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Proxy * a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Proxy * a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Proxy * a] -> Encoding Source #
ToJSONKey k => ToJSON1 (Map k) Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Map k a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Map k a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Map k a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Map k a] -> Encoding Source #
ToJSONKey k => ToJSON1 (HashMap k) Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> HashMap k a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [HashMap k a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> HashMap k a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [HashMap k a] -> Encoding Source #
(ToJSON a, ToJSON b) => ToJSON1 ((,,) a b) Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> (a, b, a) -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [(a, b, a)] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> (a, b, a) -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [(a, b, a)] -> Encoding Source #
ToJSON a => ToJSON1 (Const * a) Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Const * a a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Const * a a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Const * a a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Const * a a] -> Encoding Source #
ToJSON1 (Tagged k a) Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Tagged k a a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Tagged k a a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Tagged k a a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Tagged k a a] -> Encoding Source #
(ToJSON a, ToJSON b, ToJSON c) => ToJSON1 ((,,,) a b c) Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> (a, b, c, a) -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [(a, b, c, a)] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> (a, b, c, a) -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [(a, b, c, a)] -> Encoding Source #
(ToJSON1 f, ToJSON1 g) => ToJSON1 (Sum * f g) Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Sum * f g a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Sum * f g a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Sum * f g a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Sum * f g a] -> Encoding Source #
(ToJSON1 f, ToJSON1 g) => ToJSON1 (Product * f g) Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Product * f g a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Product * f g a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Product * f g a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Product * f g a] -> Encoding Source #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d) => ToJSON1 ((,,,,) a b c d) Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> (a, b, c, d, a) -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [(a, b, c, d, a)] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> (a, b, c, d, a) -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [(a, b, c, d, a)] -> Encoding Source #
(ToJSON1 f, ToJSON1 g) => ToJSON1 (Compose * * f g) Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Compose * * f g a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Compose * * f g a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Compose * * f g a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Compose * * f g a] -> Encoding Source #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e) => ToJSON1 ((,,,,,) a b c d e) Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> (a, b, c, d, e, a) -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [(a, b, c, d, e, a)] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> (a, b, c, d, e, a) -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [(a, b, c, d, e, a)] -> Encoding Source #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f) => ToJSON1 ((,,,,,,) a b c d e f) Source # |
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> (a, b, c, d, e, f, a) -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [(a, b, c, d, e, f, a)] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> (a, b, c, d, e, f, a) -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [(a, b, c, d, e, f, a)] -> Encoding Source #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g) => ToJSON1 ((,,,,,,,) a b c d e f g) Source # |

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> (a, b, c, d, e, f, g, a) -> Value Source #

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [(a, b, c, d, e, f, g, a)] -> Value Source #

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> (a, b, c, d, e, f, g, a) -> Encoding Source #

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [(a, b, c, d, e, f, g, a)] -> Encoding 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 # |

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> (a, b, c, d, e, f, g, h, a) -> Value Source #

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [(a, b, c, d, e, f, g, h, a)] -> Value Source #

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> (a, b, c, d, e, f, g, h, a) -> Encoding Source #

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [(a, b, c, d, e, f, g, h, a)] -> Encoding 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 # |

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> (a, b, c, d, e, f, g, h, i, a) -> Value Source #

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [(a, b, c, d, e, f, g, h, i, a)] -> Value Source #

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> (a, b, c, d, e, f, g, h, i, a) -> Encoding Source #

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, a)] -> Encoding 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 # |

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> (a, b, c, d, e, f, g, h, i, j, a) -> Value Source #

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, a)] -> Value Source #

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, a) -> Encoding Source #

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, a)] -> Encoding 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 # |

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, a) -> Value Source #

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, a)] -> Value Source #

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, a) -> Encoding Source #

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, a)] -> Encoding 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 # |

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, l, a) -> Value Source #

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, l, a)] -> Value Source #

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, l, a) -> Encoding Source #

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, l, a)] -> Encoding 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 # |

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a) -> Value Source #

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, a)] -> Value Source #

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a) -> Encoding Source #

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, a)] -> Encoding 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 # |

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a) -> Value Source #

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, a)] -> Value Source #

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a) -> Encoding Source #

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, a)] -> Encoding 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`.

Minimal complete definition

liftToJSON2, liftToEncoding2

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 Either Source # |

Methods

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

Methods

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

Methods

liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> (a, a, b) -> Value Source #

liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [(a, a, b)] -> Value Source #

liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, a, b) -> Encoding Source #

liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, a, b)] -> Encoding Source #

ToJSON2 (Const *) Source # |

Methods

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 *) Source # |

Methods

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

Methods

liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> (a, b, a, b) -> Value Source #

liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [(a, b, a, b)] -> Value Source #

liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, b, a, b) -> Encoding Source #

liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, b, a, b)] -> Encoding Source #

(ToJSON a, ToJSON b, ToJSON c) => ToJSON2 ((,,,,) a b c) Source # |

Methods

liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> (a, b, c, a, b) -> Value Source #

liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [(a, b, c, a, b)] -> Value Source #

liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, b, c, a, b) -> Encoding Source #

liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, b, c, a, b)] -> Encoding Source #

(ToJSON a, ToJSON b, ToJSON c, ToJSON d) => ToJSON2 ((,,,,,) a b c d) Source # |

Methods

liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> (a, b, c, d, a, b) -> Value Source #

liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [(a, b, c, d, a, b)] -> Value Source #

liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, b, c, d, a, b) -> Encoding Source #

liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, b, c, d, a, b)] -> Encoding Source #

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e) => ToJSON2 ((,,,,,,) a b c d e) Source # |

Methods

liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> (a, b, c, d, e, a, b) -> Value Source #

liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [(a, b, c, d, e, a, b)] -> Value Source #

liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, b, c, d, e, a, b) -> Encoding Source #

liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, b, c, d, e, a, b)] -> Encoding Source #

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f) => ToJSON2 ((,,,,,,,) a b c d e f) Source # |

Methods

liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> (a, b, c, d, e, f, a, b) -> Value Source #

liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [(a, b, c, d, e, f, a, b)] -> Value Source #

liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, b, c, d, e, f, a, b) -> Encoding Source #

liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, b, c, d, e, f, a, b)] -> Encoding Source #

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g) => ToJSON2 ((,,,,,,,,) a b c d e f g) Source # |

Methods

liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> (a, b, c, d, e, f, g, a, b) -> Value Source #

liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [(a, b, c, d, e, f, g, a, b)] -> Value Source #

liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, b, c, d, e, f, g, a, b) -> Encoding Source #

liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, b, c, d, e, f, g, a, b)] -> Encoding 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 # |

Methods

liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> (a, b, c, d, e, f, g, h, a, b) -> Value Source #

liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [(a, b, c, d, e, f, g, h, a, b)] -> Value Source #

liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, b, c, d, e, f, g, h, a, b) -> Encoding Source #

liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, b, c, d, e, f, g, h, a, b)] -> Encoding 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 # |

Methods

liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> (a, b, c, d, e, f, g, h, i, a, b) -> Value Source #

liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [(a, b, c, d, e, f, g, h, i, a, b)] -> Value Source #

liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, b, c, d, e, f, g, h, i, a, b) -> Encoding Source #

liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, a, b)] -> Encoding 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 # |

Methods

liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> (a, b, c, d, e, f, g, h, i, j, a, b) -> Value Source #

liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, a, b)] -> Value Source #

liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, a, b) -> Encoding Source #

liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, a, b)] -> Encoding 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 # |

Methods

liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, a, b) -> Value Source #

liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, a, b)] -> Value Source #

liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, a, b) -> Encoding Source #

liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, a, b)] -> Encoding 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 # |

Methods

liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, l, a, b) -> Value Source #

liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, l, a, b)] -> Value Source #

liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, l, a, b) -> Encoding Source #

liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, l, a, b)] -> Encoding 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 # |

Methods

liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a, b) -> Value Source #

liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, a, b)] -> Value Source #

liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a, b) -> Encoding Source #

liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, a, b)] -> Encoding 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 where Source #

Class of generic representation types that can be converted from JSON.

Minimal complete definition

gParseJSON

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 # |
Methods gParseJSON :: Options -> FromArgs arity a -> Value -> Parser (U1 a) Source #
GFromJSON One Par1 Source # |
Methods gParseJSON :: Options -> FromArgs One a -> Value -> Parser (Par1 a) Source #
FromJSON1 f => GFromJSON One (Rec1 f) Source # |
Methods gParseJSON :: Options -> FromArgs One a -> Value -> Parser (Rec1 f a) Source #
(AllNullary ((:+:) a b) allNullary, ParseSum * arity ((:+:) a b) allNullary) => GFromJSON arity ((:+:) a b) Source # |
Methods gParseJSON :: Options -> FromArgs arity a -> Value -> Parser ((a :+: b) a) Source #
(FromProduct arity a, FromProduct arity b, ProductSize a, ProductSize b) => GFromJSON arity ((:*:) a b) Source # |
Methods gParseJSON :: Options -> FromArgs arity a -> Value -> Parser ((a :*: b) a) Source #
ConsFromJSON arity a => GFromJSON arity (C1 c a) Source # |
Methods gParseJSON :: Options -> FromArgs arity a -> Value -> Parser (C1 c a a) Source #
FromJSON a => GFromJSON arity (K1 i a) Source # |
Methods gParseJSON :: Options -> FromArgs arity a -> Value -> Parser (K1 i a a) Source #
(FromJSON1 f, GFromJSON One g) => GFromJSON One ((:.:) f g) Source # |
Methods gParseJSON :: Options -> FromArgs One a -> Value -> Parser ((f :.: g) a) Source #
GFromJSON arity a => GFromJSON arity (M1 i c a) Source # |
Methods gParseJSON :: Options -> FromArgs arity a -> Value -> Parser (M1 i c a a) Source #

data FromArgs arity a where Source #

A `FromArgs` value either stores nothing (for `FromJSON`) or it stores the two function arguments that decode occurrences of the type parameter (for `FromJSON1`).

Constructors

NoFromArgs :: FromArgs Zero a |
From1Args :: (Value -> Parser a) -> (Value -> Parser [a]) -> FromArgs One a |

class GToJSON arity f where Source #

Class of generic representation types that can be converted to JSON.

Minimal complete definition

gToJSON

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 # |
Methods gToJSON :: Options -> ToArgs Value arity a -> U1 a -> Value Source #
GToJSON One Par1 Source # |
Methods gToJSON :: Options -> ToArgs Value One a -> Par1 a -> Value Source #
ToJSON1 f => GToJSON One (Rec1 f) Source # |
Methods gToJSON :: Options -> ToArgs Value One a -> Rec1 f a -> Value Source #
(AllNullary ((:+:) a b) allNullary, SumToJSON * arity ((:+:) a b) allNullary) => GToJSON arity ((:+:) a b) Source # |
Methods gToJSON :: Options -> ToArgs Value arity a -> (a :+: b) a -> Value Source #
(WriteProduct arity a, WriteProduct arity b, ProductSize a, ProductSize b) => GToJSON arity ((:*:) a b) Source # |
Methods gToJSON :: Options -> ToArgs Value arity a -> (a :*: b) a -> Value Source #
ConsToJSON arity a => GToJSON arity (C1 c a) Source # |
Methods gToJSON :: Options -> ToArgs Value arity a -> C1 c a a -> Value Source #
ToJSON a => GToJSON arity (K1 i a) Source # |
Methods gToJSON :: Options -> ToArgs Value arity a -> K1 i a a -> Value Source #
(ToJSON1 f, GToJSON One g) => GToJSON One ((:.:) f g) Source # |
Methods gToJSON :: Options -> ToArgs Value One a -> (f :.: g) a -> Value Source #
GToJSON arity a => GToJSON arity (M1 i c a) Source # |
Methods gToJSON :: Options -> ToArgs Value arity a -> M1 i c a a -> Value Source #

class GToEncoding arity f where Source #

Class of generic representation types that can be converted to a JSON `Encoding`.

Minimal complete definition

gToEncoding

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 # |
Methods gToEncoding :: Options -> ToArgs Encoding arity a -> U1 a -> Encoding Source #
GToEncoding One Par1 Source # |
Methods gToEncoding :: Options -> ToArgs Encoding One a -> Par1 a -> Encoding Source #
ToJSON1 f => GToEncoding One (Rec1 f) Source # |
Methods gToEncoding :: Options -> ToArgs Encoding One a -> Rec1 f a -> Encoding Source #
(AllNullary ((:+:) a b) allNullary, SumToEncoding * arity ((:+:) a b) allNullary) => GToEncoding arity ((:+:) a b) Source # |
Methods gToEncoding :: Options -> ToArgs Encoding arity a -> (a :+: b) a -> Encoding Source #
(EncodeProduct arity a, EncodeProduct arity b) => GToEncoding arity ((:*:) a b) Source # |
Methods gToEncoding :: Options -> ToArgs Encoding arity a -> (a :*: b) a -> Encoding Source #
ConsToEncoding arity a => GToEncoding arity (C1 c a) Source # |
Methods gToEncoding :: Options -> ToArgs Encoding arity a -> C1 c a a -> Encoding Source #
ToJSON a => GToEncoding arity (K1 i a) Source # |
Methods gToEncoding :: Options -> ToArgs Encoding arity a -> K1 i a a -> Encoding Source #
(ToJSON1 f, GToEncoding One g) => GToEncoding One ((:.:) f g) Source # |
Methods gToEncoding :: Options -> ToArgs Encoding One a -> (f :.: g) a -> Encoding Source #
GToEncoding arity a => GToEncoding arity (M1 i c a) Source # |
Methods gToEncoding :: Options -> ToArgs Encoding arity a -> M1 i c a a -> Encoding Source #

data ToArgs res arity a where Source #

A `ToArgs` value either stores nothing (for `ToJSON`) or it stores the two function arguments that encode occurrences of the type parameter (for `ToJSON1`).

Constructors

NoToArgs :: ToArgs res Zero a |
To1Args :: (a -> res) -> ([a] -> res) -> ToArgs res One a |

data Zero Source #

A type-level indicator that `ToJSON` or `FromJSON` is being derived generically.

data One Source #

A type-level indicator that `ToJSON1` or `FromJSON1` is being derived generically.

Instances

GFromJSON One Par1 Source # |
Methods gParseJSON :: Options -> FromArgs One a -> Value -> Parser (Par1 a) Source #
GToEncoding One Par1 Source # |
Methods gToEncoding :: Options -> ToArgs Encoding One a -> Par1 a -> Encoding Source #
GToJSON One Par1 Source # |
Methods gToJSON :: Options -> ToArgs Value One a -> Par1 a -> Value Source #
FromJSON1 f => GFromJSON One (Rec1 f) Source # |
Methods gParseJSON :: Options -> FromArgs One a -> Value -> Parser (Rec1 f a) Source #
ToJSON1 f => GToEncoding One (Rec1 f) Source # |
Methods gToEncoding :: Options -> ToArgs Encoding One a -> Rec1 f a -> Encoding Source #
ToJSON1 f => GToJSON One (Rec1 f) Source # |
Methods gToJSON :: Options -> ToArgs Value One a -> Rec1 f a -> Value Source #
(FromJSON1 f, GFromJSON One g) => GFromJSON One ((:.:) f g) Source # |
Methods gParseJSON :: Options -> FromArgs One a -> Value -> Parser ((f :.: g) a) Source #
(ToJSON1 f, GToEncoding One g) => GToEncoding One ((:.:) f g) Source # |
Methods gToEncoding :: Options -> ToArgs Encoding One a -> (f :.: g) a -> Encoding Source #
(ToJSON1 f, GToJSON One g) => GToJSON One ((:.:) f g) Source # |
Methods gToJSON :: Options -> ToArgs Value One a -> (f :.: g) a -> Value 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 ``Value`s`

withObject :: 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` otherwise.

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` otherwise.

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` otherwise.

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` otherwise.

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` otherwise.

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` otherwise.

# Constructors and accessors

data Series Source #

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)

Instances

Semigroup Series Source # |
Methods (<>) :: Series -> Series -> Series # sconcat :: NonEmpty Series -> Series # stimes :: Integral b => b -> Series -> Series #
Monoid Series Source # |
Methods mempty :: Series # mappend :: Series -> Series -> Series # mconcat :: [Series] -> Series #
KeyValue Series Source # |
Methods (.=) :: ToJSON v => Text -> v -> Series Source #

pairs :: Series -> Encoding Source #

Encode a series of key/value pairs, separated by commas.

foldable :: (Foldable t, ToJSON a) => t a -> Encoding Source #

Encode a `Foldable` as a JSON array.

(.:) :: 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.

(.:!) :: 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 `empty` if the value cannot be converted to the desired type.

This differs from `.:?` by attempting to parse `Null` the same as any other JSON value, instead of interpreting it as `Nothing`.

(.!=) :: 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"

object :: [Pair] -> Value Source #

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

# Parsing

json :: Parser Value Source #

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.