aeson-1.4.7.1: 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.Types

Contents

- Core JSON types
- Convenience types and functions
- Type conversion
  - Keys for maps
    - Generic keys
  - Liftings to unary and binary type constructors
  - Generic JSON classes
- Inspecting ``Value`s`
- Generic and TH encoding configuration
  - Options fields
  - Options utilities
  - Options for object keys
- Parsing context

Description

Types for working with JSON data.

Synopsis

- data Value
  - = Object !Object
  - | Array !Array
  - | String !Text
  - | Number !Scientific
  - | Bool !Bool
  - | Null
- type Encoding = Encoding' Value
- unsafeToEncoding :: Builder -> Encoding' a
- fromEncoding :: Encoding' tag -> Builder
- data Series
- type Array = Vector Value
- emptyArray :: Value
- type Pair = (Text, Value)
- type Object = HashMap Text Value
- emptyObject :: Value
- newtype DotNetTime = DotNetTime {
  - fromDotNetTime :: UTCTime
  }
- typeMismatch :: String -> Value -> Parser a
- unexpected :: Value -> Parser a
- data Parser a
- data Result a
  - = Error String
  - | Success a
- class FromJSON a where
  - parseJSON :: Value -> Parser a
  - parseJSONList :: Value -> Parser [a]
- fromJSON :: FromJSON a => Value -> Result a
- parse :: (a -> Parser b) -> a -> Result b
- parseEither :: (a -> Parser b) -> a -> Either String b
- parseMaybe :: (a -> Parser b) -> a -> Maybe b
- parseFail :: String -> Parser a
- class ToJSON a where
  - toJSON :: a -> Value
  - toEncoding :: a -> Encoding
  - toJSONList :: [a] -> Value
  - toEncodingList :: [a] -> Encoding
- class KeyValue kv where
  - (.=) :: ToJSON v => Text -> v -> kv
- modifyFailure :: (String -> String) -> Parser a -> Parser a
- prependFailure :: String -> Parser a -> Parser a
- parserThrowError :: JSONPath -> String -> Parser a
- parserCatchError :: Parser a -> (JSONPath -> String -> Parser a) -> Parser a
- class ToJSONKey a where
  - toJSONKey :: ToJSONKeyFunction a
  - toJSONKeyList :: ToJSONKeyFunction [a]
- data ToJSONKeyFunction a
  - = ToJSONKeyText !(a -> Text) !(a -> Encoding' Text)
  - | ToJSONKeyValue !(a -> Value) !(a -> Encoding)
- toJSONKeyText :: (a -> Text) -> ToJSONKeyFunction a
- contramapToJSONKeyFunction :: (b -> a) -> ToJSONKeyFunction a -> ToJSONKeyFunction b
- class FromJSONKey a where
  - fromJSONKey :: FromJSONKeyFunction a
  - fromJSONKeyList :: FromJSONKeyFunction [a]
- data FromJSONKeyFunction a
  - = FromJSONKeyCoerce !(CoerceText a)
  - | FromJSONKeyText !(Text -> a)
  - | FromJSONKeyTextParser !(Text -> Parser a)
  - | FromJSONKeyValue !(Value -> Parser a)
- fromJSONKeyCoerce :: Coercible Text a => FromJSONKeyFunction a
- coerceFromJSONKeyFunction :: Coercible a b => FromJSONKeyFunction a -> FromJSONKeyFunction b
- mapFromJSONKeyFunction :: (a -> b) -> FromJSONKeyFunction a -> FromJSONKeyFunction b
- class GetConName f => GToJSONKey f
- genericToJSONKey :: (Generic a, GToJSONKey (Rep a)) => JSONKeyOptions -> ToJSONKeyFunction a
- class (ConstructorNames f, SumFromString f) => GFromJSONKey f
- genericFromJSONKey :: forall a. (Generic a, GFromJSONKey (Rep a)) => JSONKeyOptions -> FromJSONKeyFunction a
- class FromJSON1 f where
  - liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a)
  - liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [f a]
- parseJSON1 :: (FromJSON1 f, FromJSON a) => Value -> Parser (f a)
- class FromJSON2 f where
  - liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (f a b)
  - liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [f a b]
- parseJSON2 :: (FromJSON2 f, FromJSON a, FromJSON b) => Value -> Parser (f a b)
- class ToJSON1 f where
  - liftToJSON :: (a -> Value) -> ([a] -> Value) -> f a -> Value
  - liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [f a] -> Value
  - liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding
  - liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [f a] -> Encoding
- toJSON1 :: (ToJSON1 f, ToJSON a) => f a -> Value
- toEncoding1 :: (ToJSON1 f, ToJSON a) => f a -> Encoding
- class ToJSON2 f where
  - liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> f a b -> Value
  - liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [f a b] -> Value
  - liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> f a b -> Encoding
  - liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [f a b] -> Encoding
- toJSON2 :: (ToJSON2 f, ToJSON a, ToJSON b) => f a b -> Value
- toEncoding2 :: (ToJSON2 f, ToJSON a, ToJSON b) => f a b -> Encoding
- class GFromJSON arity f where
  - gParseJSON :: Options -> FromArgs arity a -> Value -> Parser (f a)
- data FromArgs arity a where
  - NoFromArgs :: FromArgs Zero a
  - From1Args :: (Value -> Parser a) -> (Value -> Parser [a]) -> FromArgs One a
- type GToJSON = GToJSON Value
- type GToEncoding = GToJSON Encoding
- 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 Value Zero (Rep a)) => Options -> a -> Value
- genericLiftToJSON :: (Generic1 f, GToJSON Value One (Rep1 f)) => Options -> (a -> Value) -> ([a] -> Value) -> f a -> Value
- genericToEncoding :: (Generic a, GToJSON Encoding Zero (Rep a)) => Options -> a -> Encoding
- genericLiftToEncoding :: (Generic1 f, GToJSON Encoding One (Rep1 f)) => Options -> (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding
- genericParseJSON :: (Generic a, GFromJSON Zero (Rep a)) => Options -> Value -> Parser a
- genericLiftParseJSON :: (Generic1 f, GFromJSON One (Rep1 f)) => Options -> (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a)
- withObject :: String -> (Object -> Parser a) -> Value -> Parser a
- withText :: String -> (Text -> Parser a) -> Value -> Parser a
- withArray :: String -> (Array -> Parser a) -> Value -> Parser a
- withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
- withBool :: String -> (Bool -> Parser a) -> Value -> Parser a
- withEmbeddedJSON :: String -> (Value -> Parser a) -> Value -> Parser a
- pairs :: Series -> Encoding
- foldable :: (Foldable t, ToJSON a) => t a -> Encoding
- (.:) :: FromJSON a => Object -> Text -> Parser a
- (.:?) :: FromJSON a => Object -> Text -> Parser (Maybe a)
- (.:!) :: FromJSON a => Object -> Text -> Parser (Maybe a)
- (.!=) :: Parser (Maybe a) -> a -> Parser a
- object :: [Pair] -> Value
- parseField :: FromJSON a => Object -> Text -> Parser a
- parseFieldMaybe :: FromJSON a => Object -> Text -> Parser (Maybe a)
- parseFieldMaybe' :: FromJSON a => Object -> Text -> Parser (Maybe a)
- explicitParseField :: (Value -> Parser a) -> Object -> Text -> Parser a
- explicitParseFieldMaybe :: (Value -> Parser a) -> Object -> Text -> Parser (Maybe a)
- explicitParseFieldMaybe' :: (Value -> Parser a) -> Object -> Text -> Parser (Maybe a)
- listEncoding :: (a -> Encoding) -> [a] -> Encoding
- listValue :: (a -> Value) -> [a] -> Value
- listParser :: (Value -> Parser a) -> Value -> Parser [a]
- data Options
- fieldLabelModifier :: Options -> String -> String
- constructorTagModifier :: Options -> String -> String
- allNullaryToStringTag :: Options -> Bool
- omitNothingFields :: Options -> Bool
- sumEncoding :: Options -> SumEncoding
- unwrapUnaryRecords :: Options -> Bool
- tagSingleConstructors :: Options -> Bool
- rejectUnknownFields :: Options -> Bool
- data SumEncoding
  - = TaggedObject {
    - tagFieldName :: String
    - contentsFieldName :: String
    }
  - | UntaggedValue
  - | ObjectWithSingleField
  - | TwoElemArray
- camelTo :: Char -> String -> String
- camelTo2 :: Char -> String -> String
- defaultOptions :: Options
- defaultTaggedObject :: SumEncoding
- data JSONKeyOptions
- keyModifier :: JSONKeyOptions -> String -> String
- defaultJSONKeyOptions :: JSONKeyOptions
- (<?>) :: Parser a -> JSONPathElement -> Parser a
- type JSONPath = [JSONPathElement]
- data JSONPathElement
  - = Key Text
  - | Index !Int
- formatPath :: JSONPath -> String
- formatRelativePath :: JSONPath -> String

# 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

Instances details

Eq Value Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: Value -> Value -> Bool (/=) :: Value -> Value -> Bool
Data Value Source # |

Instance details

Defined in Data.Aeson.Types.Internal

Methods

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

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

toConstr :: Value -> Constr

dataTypeOf :: Value -> DataType

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

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

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

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

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

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

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

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

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

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

Read Value Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods readsPrec :: Int -> ReadS Value readList :: ReadS [Value] readPrec :: ReadPrec Value readListPrec :: ReadPrec [Value]
Show Value Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> Value -> ShowS show :: Value -> String showList :: [Value] -> ShowS
IsString Value Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods fromString :: String -> Value
Generic Value Source # |
Instance details Defined in Data.Aeson.Types.Internal Associated Types type Rep Value :: Type -> Type Methods from :: Value -> Rep Value x to :: Rep Value x -> Value
Lift Value Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods lift :: Value -> Q Exp
Hashable Value Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods hashWithSalt :: Int -> Value -> Int Source # hash :: Value -> Int Source #
NFData Value Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods rnf :: Value -> ()
FromJSON Value Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Value Source # parseJSONList :: Value -> Parser [Value] Source #
KeyValue Pair Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.=) :: ToJSON v => Text -> v -> Pair Source #
KeyValue Object Source # | Constructs a singleton `HashMap`. For calling functions that demand an `Object` for constructing objects. To be used in conjunction with `mconcat`. Prefer to use `object` where possible.
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.=) :: ToJSON v => Text -> v -> Object Source #
ToJSON Value Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Value -> Value Source # toEncoding :: Value -> Encoding Source # toJSONList :: [Value] -> Value Source # toEncodingList :: [Value] -> Encoding Source #
type Rep Value Source # |

Instance details

Defined in Data.Aeson.Types.Internal

type Rep Value = D1 ('MetaData "Value" "Data.Aeson.Types.Internal" "aeson-1.4.7.1-LcFT4XRNxNk1GX4d6qN7FX" 'False) ((C1 ('MetaCons "Object" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Object)) :+: (C1 ('MetaCons "Array" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Array)) :+: C1 ('MetaCons "String" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Text)))) :+: (C1 ('MetaCons "Number" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Scientific)) :+: (C1 ('MetaCons "Bool" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Bool)) :+: C1 ('MetaCons "Null" 'PrefixI 'False) (U1 :: Type -> Type))))

type Encoding = Encoding' Value Source #

Often used synonym for `Encoding'`.

unsafeToEncoding :: Builder -> Encoding' a Source #

Make Encoding from Builder.

Use with care! You have to make sure that the passed Builder is a valid JSON Encoding!

fromEncoding :: Encoding' tag -> Builder Source #

Acquire the underlying bytestring builder.

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

Instances details

Semigroup Series Source # |
Instance details Defined in Data.Aeson.Encoding.Internal Methods (<>) :: Series -> Series -> Series # sconcat :: NonEmpty Series -> Series # stimes :: Integral b => b -> Series -> Series #
Monoid Series Source # |
Instance details Defined in Data.Aeson.Encoding.Internal Methods mempty :: Series # mappend :: Series -> Series -> Series # mconcat :: [Series] -> Series #
KeyValue Series Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.=) :: ToJSON v => Text -> v -> Series Source #

type Array = Vector Value Source #

A JSON "array" (sequence).

emptyArray :: Value Source #

The empty array.

type Pair = (Text, Value) Source #

A key/value pair for an `Object`.

type Object = HashMap Text Value Source #

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

emptyObject :: Value Source #

The empty object.

# Convenience types and functions

newtype DotNetTime Source #

A newtype wrapper for `UTCTime` that uses the same non-standard serialization format as Microsoft .NET, whose System.DateTime type is by default serialized to JSON as in the following example:

    /Date(1302547608878)/

The number represents milliseconds since the Unix epoch.

Constructors

DotNetTime |

Fields

- fromDotNetTime :: UTCTime

  Acquire the underlying value.

#### Instances

Instances details

Eq DotNetTime Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: DotNetTime -> DotNetTime -> Bool (/=) :: DotNetTime -> DotNetTime -> Bool
Ord DotNetTime Source # |
Instance details Defined in Data.Aeson.Types.Internal 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 # |
Instance details Defined in Data.Aeson.Types.Internal Methods readsPrec :: Int -> ReadS DotNetTime readList :: ReadS [DotNetTime] readPrec :: ReadPrec DotNetTime readListPrec :: ReadPrec [DotNetTime]
Show DotNetTime Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> DotNetTime -> ShowS show :: DotNetTime -> String showList :: [DotNetTime] -> ShowS
FormatTime DotNetTime Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods formatCharacter :: Bool -> Char -> Maybe (FormatOptions -> DotNetTime -> String)
FromJSON DotNetTime Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser DotNetTime Source # parseJSONList :: Value -> Parser [DotNetTime] Source #
ToJSON DotNetTime Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: DotNetTime -> Value Source # toEncoding :: DotNetTime -> Encoding Source # toJSONList :: [DotNetTime] -> Value Source # toEncodingList :: [DotNetTime] -> Encoding Source #

typeMismatch Source #

Arguments

:: String | The name of the JSON type being parsed (`"Object"`, `"Array"`, `"String"`, `"Number"`, `"Boolean"`, or `"Null"`).
-> Value | The actual value encountered.
-> Parser a |

Fail parsing due to a type mismatch, with a descriptive message.

The following wrappers should generally be prefered: `withObject`, `withArray`, `withText`, `withBool`.

#### Error message example

    typeMismatch "Object" (String "oops")
    -- Error: "expected Object, but encountered String"

unexpected :: Value -> Parser a Source #

Fail parsing due to a type mismatch, when the expected types are implicit.

#### Error message example

    unexpected (String "oops")
    -- Error: "unexpected String"

# Type conversion

data Parser a Source #

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

#### Instances

Instances details

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

data Result a Source #

The result of running a `Parser`.

Constructors

Error String |
Success a |

#### Instances

Instances details

Monad Result Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods (>>=) :: Result a -> (a -> Result b) -> Result b # (>>) :: Result a -> Result b -> Result b # return :: a -> Result a #
Functor Result Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods fmap :: (a -> b) -> Result a -> Result b # (<$) :: a -> Result b -> Result a #
MonadFail Result Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods fail :: String -> Result a #
Applicative Result Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods pure :: a -> Result a (<*>) :: Result (a -> b) -> Result a -> Result b liftA2 :: (a -> b -> c) -> Result a -> Result b -> Result c (*>) :: Result a -> Result b -> Result b (<*) :: Result a -> Result b -> Result a
Foldable Result Source # |

Instance details

Defined in Data.Aeson.Types.Internal

Methods

fold :: Monoid m => Result m -> m

foldMap :: Monoid m => (a -> m) -> Result a -> m

foldMap' :: Monoid m => (a -> m) -> Result a -> m

foldr :: (a -> b -> b) -> b -> Result a -> b

foldr' :: (a -> b -> b) -> b -> Result a -> b

foldl :: (b -> a -> b) -> b -> Result a -> b

foldl' :: (b -> a -> b) -> b -> Result a -> b

foldr1 :: (a -> a -> a) -> Result a -> a

foldl1 :: (a -> a -> a) -> Result a -> a

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 # |
Instance details Defined in Data.Aeson.Types.Internal 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 # |
Instance details Defined in Data.Aeson.Types.Internal Methods empty :: Result a (<|>) :: Result a -> Result a -> Result a some :: Result a -> Result [a] many :: Result a -> Result [a]
MonadPlus Result Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods mzero :: Result a # mplus :: Result a -> Result a -> Result a #
Eq a => Eq (Result a) Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: Result a -> Result a -> Bool (/=) :: Result a -> Result a -> Bool
Show a => Show (Result a) Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> Result a -> ShowS show :: Result a -> String showList :: [Result a] -> ShowS
Semigroup (Result a) Source # |
Instance details Defined in Data.Aeson.Types.Internal 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 # |
Instance details Defined in Data.Aeson.Types.Internal Methods mempty :: Result a # mappend :: Result a -> Result a -> Result a # mconcat :: [Result a] -> Result a #
NFData a => NFData (Result a) Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods rnf :: Result a -> ()

class FromJSON a where Source #

A type that can be converted from JSON, with the possibility of failure.

In many cases, you can get the compiler to generate parsing code for you (see below). To begin, let's cover writing an instance by hand.

There are various reasons a conversion could fail. For example, an `Object` could be missing a required key, an `Array` could be of the wrong size, or a value could be of an incompatible type.

The basic ways to signal a failed conversion are as follows:

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

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

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

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

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

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

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

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

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

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

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

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

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

    {-# LANGUAGE DeriveGeneric #-}

    import GHC.Generics

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

    instance FromJSON Coord

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

    customOptions = defaultOptions
                    { fieldLabelModifier = map toUpper
                    }

    instance FromJSON Coord where
        parseJSON = genericParseJSON customOptions

Minimal complete definition

Nothing

Methods

parseJSON :: Value -> Parser a Source #

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

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

#### Instances

Instances details

FromJSON Bool Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Bool Source # parseJSONList :: Value -> Parser [Bool] Source #
FromJSON Char Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Char Source # parseJSONList :: Value -> Parser [Char] Source #
FromJSON Double Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Double Source # parseJSONList :: Value -> Parser [Double] Source #
FromJSON Float Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Float Source # parseJSONList :: Value -> Parser [Float] Source #
FromJSON Int Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Int Source # parseJSONList :: Value -> Parser [Int] Source #
FromJSON Int8 Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Int8 Source # parseJSONList :: Value -> Parser [Int8] Source #
FromJSON Int16 Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Int16 Source # parseJSONList :: Value -> Parser [Int16] Source #
FromJSON Int32 Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Int32 Source # parseJSONList :: Value -> Parser [Int32] Source #
FromJSON Int64 Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Int64 Source # parseJSONList :: Value -> Parser [Int64] Source #
FromJSON Integer Source # | This instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype `Scientific` and provide your own instance using `withScientific` if you want to allow larger inputs.
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Integer Source # parseJSONList :: Value -> Parser [Integer] Source #
FromJSON Natural Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Natural Source # parseJSONList :: Value -> Parser [Natural] Source #
FromJSON Ordering Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Ordering Source # parseJSONList :: Value -> Parser [Ordering] Source #
FromJSON Word Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Word Source # parseJSONList :: Value -> Parser [Word] Source #
FromJSON Word8 Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Word8 Source # parseJSONList :: Value -> Parser [Word8] Source #
FromJSON Word16 Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Word16 Source # parseJSONList :: Value -> Parser [Word16] Source #
FromJSON Word32 Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Word32 Source # parseJSONList :: Value -> Parser [Word32] Source #
FromJSON Word64 Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Word64 Source # parseJSONList :: Value -> Parser [Word64] Source #
FromJSON () Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser () Source # parseJSONList :: Value -> Parser [()] Source #
FromJSON Text Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Text Source # parseJSONList :: Value -> Parser [Text] Source #
FromJSON Text Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Text Source # parseJSONList :: Value -> Parser [Text] Source #
FromJSON Version Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Version Source # parseJSONList :: Value -> Parser [Version] Source #
FromJSON Void Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Void Source # parseJSONList :: Value -> Parser [Void] Source #
FromJSON Scientific Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Scientific Source # parseJSONList :: Value -> Parser [Scientific] Source #
FromJSON SystemTime Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser SystemTime Source # parseJSONList :: Value -> Parser [SystemTime] Source #

FromJSON ZonedTime Source #

Supported string formats:

`YYYY-MM-DD HH:MM Z` `YYYY-MM-DD HH:MM:SS Z` `YYYY-MM-DD HH:MM:SS.SSS Z`

The first space may instead be a `T`, and the second space is optional. The `Z` represents UTC. The `Z` may be replaced with a time zone offset of the form `+0000` or `-08:00`, where the first two digits are hours, the `:` is optional and the second two digits (also optional) are minutes.

Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser ZonedTime Source # parseJSONList :: Value -> Parser [ZonedTime] Source #
FromJSON TimeOfDay Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser TimeOfDay Source # parseJSONList :: Value -> Parser [TimeOfDay] Source #
FromJSON LocalTime Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser LocalTime Source # parseJSONList :: Value -> Parser [LocalTime] Source #
FromJSON CalendarDiffTime Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser CalendarDiffTime Source # parseJSONList :: Value -> Parser [CalendarDiffTime] Source #
FromJSON UTCTime Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser UTCTime Source # parseJSONList :: Value -> Parser [UTCTime] Source #
FromJSON NominalDiffTime Source # | This instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype `Scientific` and provide your own instance using `withScientific` if you want to allow larger inputs.
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser NominalDiffTime Source # parseJSONList :: Value -> Parser [NominalDiffTime] Source #
FromJSON DiffTime Source # | This instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype `Scientific` and provide your own instance using `withScientific` if you want to allow larger inputs.
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser DiffTime Source # parseJSONList :: Value -> Parser [DiffTime] Source #
FromJSON DayOfWeek Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser DayOfWeek Source # parseJSONList :: Value -> Parser [DayOfWeek] Source #
FromJSON Day Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Day Source # parseJSONList :: Value -> Parser [Day] Source #
FromJSON CalendarDiffDays Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser CalendarDiffDays Source # parseJSONList :: Value -> Parser [CalendarDiffDays] Source #
FromJSON UUID Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser UUID Source # parseJSONList :: Value -> Parser [UUID] Source #
FromJSON CTime Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser CTime Source # parseJSONList :: Value -> Parser [CTime] Source #
FromJSON IntSet Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser IntSet Source # parseJSONList :: Value -> Parser [IntSet] Source #
FromJSON DotNetTime Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser DotNetTime Source # parseJSONList :: Value -> Parser [DotNetTime] Source #
FromJSON Value Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Value Source # parseJSONList :: Value -> Parser [Value] Source #
FromJSON a => FromJSON [a] Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser [a] Source # parseJSONList :: Value -> Parser [[a]] Source #
FromJSON a => FromJSON (Maybe a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Maybe a) Source # parseJSONList :: Value -> Parser [Maybe a] Source #
(FromJSON a, Integral a) => FromJSON (Ratio a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Ratio a) Source # parseJSONList :: Value -> Parser [Ratio a] Source #
FromJSON a => FromJSON (Identity a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Identity a) Source # parseJSONList :: Value -> Parser [Identity a] Source #
FromJSON a => FromJSON (NonEmpty a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (NonEmpty a) Source # parseJSONList :: Value -> Parser [NonEmpty a] Source #
FromJSON a => FromJSON (Dual a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Dual a) Source # parseJSONList :: Value -> Parser [Dual a] Source #
FromJSON a => FromJSON (First a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (First a) Source # parseJSONList :: Value -> Parser [First a] Source #
FromJSON a => FromJSON (Last a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Last a) Source # parseJSONList :: Value -> Parser [Last a] Source #
FromJSON a => FromJSON (First a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (First a) Source # parseJSONList :: Value -> Parser [First a] Source #
FromJSON a => FromJSON (Last a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Last a) Source # parseJSONList :: Value -> Parser [Last a] Source #
FromJSON a => FromJSON (Max a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Max a) Source # parseJSONList :: Value -> Parser [Max a] Source #
FromJSON a => FromJSON (Min a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Min a) Source # parseJSONList :: Value -> Parser [Min a] Source #
FromJSON a => FromJSON (Option a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Option a) Source # parseJSONList :: Value -> Parser [Option a] Source #
FromJSON a => FromJSON (WrappedMonoid a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (WrappedMonoid a) Source # parseJSONList :: Value -> Parser [WrappedMonoid a] Source #
FromJSON a => FromJSON (DList a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (DList a) Source # parseJSONList :: Value -> Parser [DList a] Source #
(Prim a, FromJSON a) => FromJSON (PrimArray a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (PrimArray a) Source # parseJSONList :: Value -> Parser [PrimArray a] Source #
FromJSON a => FromJSON (SmallArray a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (SmallArray a) Source # parseJSONList :: Value -> Parser [SmallArray a] Source #
FromJSON a => FromJSON (Array a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Array a) Source # parseJSONList :: Value -> Parser [Array a] Source #
(Eq a, Hashable a, FromJSON a) => FromJSON (HashSet a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (HashSet a) Source # parseJSONList :: Value -> Parser [HashSet a] Source #
(Vector Vector a, FromJSON a) => FromJSON (Vector a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Vector a) Source # parseJSONList :: Value -> Parser [Vector a] Source #
(Storable a, FromJSON a) => FromJSON (Vector a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Vector a) Source # parseJSONList :: Value -> Parser [Vector a] Source #
(Prim a, FromJSON a) => FromJSON (Vector a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Vector a) Source # parseJSONList :: Value -> Parser [Vector a] Source #
FromJSON a => FromJSON (Vector a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Vector a) Source # parseJSONList :: Value -> Parser [Vector a] Source #
HasResolution a => FromJSON (Fixed a) Source # | This instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype `Scientific` and provide your own instance using `withScientific` if you want to allow larger inputs.
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Fixed a) Source # parseJSONList :: Value -> Parser [Fixed a] Source #
(Ord a, FromJSON a) => FromJSON (Set a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Set a) Source # parseJSONList :: Value -> Parser [Set a] Source #
FromJSON a => FromJSON (IntMap a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (IntMap a) Source # parseJSONList :: Value -> Parser [IntMap a] Source #
FromJSON a => FromJSON (Seq a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Seq a) Source # parseJSONList :: Value -> Parser [Seq a] Source #
FromJSON v => FromJSON (Tree v) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Tree v) Source # parseJSONList :: Value -> Parser [Tree v] Source #
(FromJSON a, FromJSON b) => FromJSON (Either a b) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Either a b) Source # parseJSONList :: Value -> Parser [Either a b] Source #
(FromJSON a, FromJSON b) => FromJSON (a, b) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b) Source # parseJSONList :: Value -> Parser [(a, b)] Source #
FromJSON (Proxy a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Proxy a) Source # parseJSONList :: Value -> Parser [Proxy a] Source #
(FromJSON v, FromJSONKey k, Eq k, Hashable k) => FromJSON (HashMap k v) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (HashMap k v) Source # parseJSONList :: Value -> Parser [HashMap k v] Source #
(FromJSONKey k, Ord k, FromJSON v) => FromJSON (Map k v) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Map k v) Source # parseJSONList :: Value -> Parser [Map k v] Source #
(FromJSON a, FromJSON b, FromJSON c) => FromJSON (a, b, c) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c) Source # parseJSONList :: Value -> Parser [(a, b, c)] Source #
FromJSON a => FromJSON (Const a b) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Const a b) Source # parseJSONList :: Value -> Parser [Const a b] Source #
FromJSON b => FromJSON (Tagged a b) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Tagged a b) Source # parseJSONList :: Value -> Parser [Tagged a b] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSON (a, b, c, d) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m) 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n) 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] Source #

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

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

parse :: (a -> Parser b) -> a -> Result b Source #

Run a `Parser`.

parseEither :: (a -> Parser b) -> a -> Either String b Source #

Run a `Parser` with an `Either` result type. If the parse fails, the `Left` payload will contain an error message.

parseMaybe :: (a -> Parser b) -> a -> Maybe b Source #

Run a `Parser` with a `Maybe` result type.

parseFail :: String -> Parser a Source #

Raise a parsing failure with some custom message.

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 two 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.)

Minimal complete definition

Nothing

Methods

toJSON :: a -> Value Source #

Convert a Haskell value to a JSON-friendly intermediate type.

default toJSON :: (Generic a, GToJSON Value Zero (Rep a)) => a -> Value Source #

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

Instances details

ToJSON Bool Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Bool -> Value Source # toEncoding :: Bool -> Encoding Source # toJSONList :: [Bool] -> Value Source # toEncodingList :: [Bool] -> Encoding Source #
ToJSON Char Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Char -> Value Source # toEncoding :: Char -> Encoding Source # toJSONList :: [Char] -> Value Source # toEncodingList :: [Char] -> Encoding Source #
ToJSON Double Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Double -> Value Source # toEncoding :: Double -> Encoding Source # toJSONList :: [Double] -> Value Source # toEncodingList :: [Double] -> Encoding Source #
ToJSON Float Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Float -> Value Source # toEncoding :: Float -> Encoding Source # toJSONList :: [Float] -> Value Source # toEncodingList :: [Float] -> Encoding Source #
ToJSON Int Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Int -> Value Source # toEncoding :: Int -> Encoding Source # toJSONList :: [Int] -> Value Source # toEncodingList :: [Int] -> Encoding Source #
ToJSON Int8 Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Int8 -> Value Source # toEncoding :: Int8 -> Encoding Source # toJSONList :: [Int8] -> Value Source # toEncodingList :: [Int8] -> Encoding Source #
ToJSON Int16 Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Int16 -> Value Source # toEncoding :: Int16 -> Encoding Source # toJSONList :: [Int16] -> Value Source # toEncodingList :: [Int16] -> Encoding Source #
ToJSON Int32 Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Int32 -> Value Source # toEncoding :: Int32 -> Encoding Source # toJSONList :: [Int32] -> Value Source # toEncodingList :: [Int32] -> Encoding Source #
ToJSON Int64 Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Int64 -> Value Source # toEncoding :: Int64 -> Encoding Source # toJSONList :: [Int64] -> Value Source # toEncodingList :: [Int64] -> Encoding Source #
ToJSON Integer Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Integer -> Value Source # toEncoding :: Integer -> Encoding Source # toJSONList :: [Integer] -> Value Source # toEncodingList :: [Integer] -> Encoding Source #
ToJSON Natural Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Natural -> Value Source # toEncoding :: Natural -> Encoding Source # toJSONList :: [Natural] -> Value Source # toEncodingList :: [Natural] -> Encoding Source #
ToJSON Ordering Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Ordering -> Value Source # toEncoding :: Ordering -> Encoding Source # toJSONList :: [Ordering] -> Value Source # toEncodingList :: [Ordering] -> Encoding Source #
ToJSON Word Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Word -> Value Source # toEncoding :: Word -> Encoding Source # toJSONList :: [Word] -> Value Source # toEncodingList :: [Word] -> Encoding Source #
ToJSON Word8 Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Word8 -> Value Source # toEncoding :: Word8 -> Encoding Source # toJSONList :: [Word8] -> Value Source # toEncodingList :: [Word8] -> Encoding Source #
ToJSON Word16 Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Word16 -> Value Source # toEncoding :: Word16 -> Encoding Source # toJSONList :: [Word16] -> Value Source # toEncodingList :: [Word16] -> Encoding Source #
ToJSON Word32 Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Word32 -> Value Source # toEncoding :: Word32 -> Encoding Source # toJSONList :: [Word32] -> Value Source # toEncodingList :: [Word32] -> Encoding Source #
ToJSON Word64 Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Word64 -> Value Source # toEncoding :: Word64 -> Encoding Source # toJSONList :: [Word64] -> Value Source # toEncodingList :: [Word64] -> Encoding Source #
ToJSON () Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: () -> Value Source # toEncoding :: () -> Encoding Source # toJSONList :: [()] -> Value Source # toEncodingList :: [()] -> Encoding Source #
ToJSON Text Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Text -> Value Source # toEncoding :: Text -> Encoding Source # toJSONList :: [Text] -> Value Source # toEncodingList :: [Text] -> Encoding Source #
ToJSON Text Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Text -> Value Source # toEncoding :: Text -> Encoding Source # toJSONList :: [Text] -> Value Source # toEncodingList :: [Text] -> Encoding Source #
ToJSON Number Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Number -> Value Source # toEncoding :: Number -> Encoding Source # toJSONList :: [Number] -> Value Source # toEncodingList :: [Number] -> Encoding Source #
ToJSON Version Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Version -> Value Source # toEncoding :: Version -> Encoding Source # toJSONList :: [Version] -> Value Source # toEncodingList :: [Version] -> Encoding Source #
ToJSON Void Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Void -> Value Source # toEncoding :: Void -> Encoding Source # toJSONList :: [Void] -> Value Source # toEncodingList :: [Void] -> Encoding Source #
ToJSON Scientific Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Scientific -> Value Source # toEncoding :: Scientific -> Encoding Source # toJSONList :: [Scientific] -> Value Source # toEncodingList :: [Scientific] -> Encoding Source #
ToJSON SystemTime Source # | Encoded as number
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: SystemTime -> Value Source # toEncoding :: SystemTime -> Encoding Source # toJSONList :: [SystemTime] -> Value Source # toEncodingList :: [SystemTime] -> Encoding Source #
ToJSON ZonedTime Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: ZonedTime -> Value Source # toEncoding :: ZonedTime -> Encoding Source # toJSONList :: [ZonedTime] -> Value Source # toEncodingList :: [ZonedTime] -> Encoding Source #
ToJSON TimeOfDay Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: TimeOfDay -> Value Source # toEncoding :: TimeOfDay -> Encoding Source # toJSONList :: [TimeOfDay] -> Value Source # toEncodingList :: [TimeOfDay] -> Encoding Source #
ToJSON LocalTime Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: LocalTime -> Value Source # toEncoding :: LocalTime -> Encoding Source # toJSONList :: [LocalTime] -> Value Source # toEncodingList :: [LocalTime] -> Encoding Source #
ToJSON CalendarDiffTime Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: CalendarDiffTime -> Value Source # toEncoding :: CalendarDiffTime -> Encoding Source # toJSONList :: [CalendarDiffTime] -> Value Source # toEncodingList :: [CalendarDiffTime] -> Encoding Source #
ToJSON UTCTime Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: UTCTime -> Value Source # toEncoding :: UTCTime -> Encoding Source # toJSONList :: [UTCTime] -> Value Source # toEncodingList :: [UTCTime] -> Encoding Source #
ToJSON NominalDiffTime Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: NominalDiffTime -> Value Source # toEncoding :: NominalDiffTime -> Encoding Source # toJSONList :: [NominalDiffTime] -> Value Source # toEncodingList :: [NominalDiffTime] -> Encoding Source #
ToJSON DiffTime Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: DiffTime -> Value Source # toEncoding :: DiffTime -> Encoding Source # toJSONList :: [DiffTime] -> Value Source # toEncodingList :: [DiffTime] -> Encoding Source #
ToJSON DayOfWeek Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: DayOfWeek -> Value Source # toEncoding :: DayOfWeek -> Encoding Source # toJSONList :: [DayOfWeek] -> Value Source # toEncodingList :: [DayOfWeek] -> Encoding Source #
ToJSON Day Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Day -> Value Source # toEncoding :: Day -> Encoding Source # toJSONList :: [Day] -> Value Source # toEncodingList :: [Day] -> Encoding Source #
ToJSON CalendarDiffDays Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: CalendarDiffDays -> Value Source # toEncoding :: CalendarDiffDays -> Encoding Source # toJSONList :: [CalendarDiffDays] -> Value Source # toEncodingList :: [CalendarDiffDays] -> Encoding Source #
ToJSON UUID Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: UUID -> Value Source # toEncoding :: UUID -> Encoding Source # toJSONList :: [UUID] -> Value Source # toEncodingList :: [UUID] -> Encoding Source #
ToJSON CTime Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: CTime -> Value Source # toEncoding :: CTime -> Encoding Source # toJSONList :: [CTime] -> Value Source # toEncodingList :: [CTime] -> Encoding Source #
ToJSON IntSet Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: IntSet -> Value Source # toEncoding :: IntSet -> Encoding Source # toJSONList :: [IntSet] -> Value Source # toEncodingList :: [IntSet] -> Encoding Source #
ToJSON DotNetTime Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: DotNetTime -> Value Source # toEncoding :: DotNetTime -> Encoding Source # toJSONList :: [DotNetTime] -> Value Source # toEncodingList :: [DotNetTime] -> Encoding Source #
ToJSON Value Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Value -> Value Source # toEncoding :: Value -> Encoding Source # toJSONList :: [Value] -> Value Source # toEncodingList :: [Value] -> Encoding Source #
ToJSON a => ToJSON [a] Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: [a] -> Value Source # toEncoding :: [a] -> Encoding Source # toJSONList :: [[a]] -> Value Source # toEncodingList :: [[a]] -> Encoding Source #
ToJSON a => ToJSON (Maybe a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Identity a -> Value Source # toEncoding :: Identity a -> Encoding Source # toJSONList :: [Identity a] -> Value Source # toEncodingList :: [Identity a] -> Encoding Source #
ToJSON a => ToJSON (NonEmpty a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: NonEmpty a -> Value Source # toEncoding :: NonEmpty a -> Encoding Source # toJSONList :: [NonEmpty a] -> Value Source # toEncodingList :: [NonEmpty a] -> Encoding Source #
ToJSON a => ToJSON (Dual a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Last a -> Value Source # toEncoding :: Last a -> Encoding Source # toJSONList :: [Last a] -> Value Source # toEncodingList :: [Last a] -> Encoding Source #
ToJSON a => ToJSON (First a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Last a -> Value Source # toEncoding :: Last a -> Encoding Source # toJSONList :: [Last a] -> Value Source # toEncodingList :: [Last a] -> Encoding Source #
ToJSON a => ToJSON (Max a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Max a -> Value Source # toEncoding :: Max a -> Encoding Source # toJSONList :: [Max a] -> Value Source # toEncodingList :: [Max a] -> Encoding Source #
ToJSON a => ToJSON (Min a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Min a -> Value Source # toEncoding :: Min a -> Encoding Source # toJSONList :: [Min a] -> Value Source # toEncodingList :: [Min a] -> Encoding Source #
ToJSON a => ToJSON (Option a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Option a -> Value Source # toEncoding :: Option a -> Encoding Source # toJSONList :: [Option a] -> Value Source # toEncodingList :: [Option a] -> Encoding Source #
ToJSON a => ToJSON (WrappedMonoid a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: WrappedMonoid a -> Value Source # toEncoding :: WrappedMonoid a -> Encoding Source # toJSONList :: [WrappedMonoid a] -> Value Source # toEncodingList :: [WrappedMonoid a] -> Encoding Source #
ToJSON a => ToJSON (DList a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: DList a -> Value Source # toEncoding :: DList a -> Encoding Source # toJSONList :: [DList a] -> Value Source # toEncodingList :: [DList a] -> Encoding Source #
(Prim a, ToJSON a) => ToJSON (PrimArray a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: PrimArray a -> Value Source # toEncoding :: PrimArray a -> Encoding Source # toJSONList :: [PrimArray a] -> Value Source # toEncodingList :: [PrimArray a] -> Encoding Source #
ToJSON a => ToJSON (SmallArray a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: SmallArray a -> Value Source # toEncoding :: SmallArray a -> Encoding Source # toJSONList :: [SmallArray a] -> Value Source # toEncodingList :: [SmallArray a] -> Encoding Source #
ToJSON a => ToJSON (Array a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Array a -> Value Source # toEncoding :: Array a -> Encoding Source # toJSONList :: [Array a] -> Value Source # toEncodingList :: [Array a] -> Encoding Source #
ToJSON a => ToJSON (HashSet a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: HashSet a -> Value Source # toEncoding :: HashSet a -> Encoding Source # toJSONList :: [HashSet a] -> Value Source # toEncodingList :: [HashSet a] -> Encoding Source #
(Vector Vector a, ToJSON a) => ToJSON (Vector a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Vector a -> Value Source # toEncoding :: Vector a -> Encoding Source # toJSONList :: [Vector a] -> Value Source # toEncodingList :: [Vector a] -> Encoding Source #
ToJSON a => ToJSON (Vector a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Vector a -> Value Source # toEncoding :: Vector a -> Encoding Source # toJSONList :: [Vector a] -> Value Source # toEncodingList :: [Vector a] -> Encoding Source #
HasResolution a => ToJSON (Fixed a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Fixed a -> Value Source # toEncoding :: Fixed a -> Encoding Source # toJSONList :: [Fixed a] -> Value Source # toEncodingList :: [Fixed a] -> Encoding Source #
ToJSON a => ToJSON (Set a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Set a -> Value Source # toEncoding :: Set a -> Encoding Source # toJSONList :: [Set a] -> Value Source # toEncodingList :: [Set a] -> Encoding Source #
ToJSON a => ToJSON (IntMap a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: IntMap a -> Value Source # toEncoding :: IntMap a -> Encoding Source # toJSONList :: [IntMap a] -> Value Source # toEncodingList :: [IntMap a] -> Encoding Source #
ToJSON a => ToJSON (Seq a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Seq a -> Value Source # toEncoding :: Seq a -> Encoding Source # toJSONList :: [Seq a] -> Value Source # toEncodingList :: [Seq a] -> Encoding Source #
ToJSON v => ToJSON (Tree v) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Tree v -> Value Source # toEncoding :: Tree v -> Encoding Source # toJSONList :: [Tree v] -> Value Source # toEncodingList :: [Tree v] -> Encoding Source #
(ToJSON a, ToJSON b) => ToJSON (Either a b) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: (a, b) -> Value Source # toEncoding :: (a, b) -> Encoding Source # toJSONList :: [(a, b)] -> Value Source # toEncodingList :: [(a, b)] -> Encoding Source #
ToJSON (Proxy a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Proxy a -> Value Source # toEncoding :: Proxy a -> Encoding Source # toJSONList :: [Proxy a] -> Value Source # toEncodingList :: [Proxy a] -> Encoding Source #
(ToJSON v, ToJSONKey k) => ToJSON (HashMap k v) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 v, ToJSONKey k) => ToJSON (Map k v) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 a, ToJSON b, ToJSON c) => ToJSON (a, b, c) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 a b) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Const a b -> Value Source # toEncoding :: Const a b -> Encoding Source # toJSONList :: [Const a b] -> Value Source # toEncodingList :: [Const a b] -> Encoding Source #
ToJSON b => ToJSON (Tagged a b) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Tagged a b -> Value Source # toEncoding :: Tagged a b -> Encoding Source # toJSONList :: [Tagged a b] -> Value Source # toEncodingList :: [Tagged a b] -> Encoding Source #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d) => ToJSON (a, b, c, d) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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.

Methods

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

#### Instances

Instances details

KeyValue Pair Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.=) :: ToJSON v => Text -> v -> Pair Source #
KeyValue Object Source # | Constructs a singleton `HashMap`. For calling functions that demand an `Object` for constructing objects. To be used in conjunction with `mconcat`. Prefer to use `object` where possible.
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.=) :: ToJSON v => Text -> v -> Object Source #
KeyValue Series Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.=) :: ToJSON v => Text -> v -> Series Source #

modifyFailure :: (String -> String) -> Parser a -> Parser a Source #

If the inner `Parser` failed, modify the failure message using the provided function. This allows you to create more descriptive error messages. For example:

    parseJSON (Object o) = modifyFailure
        ("Parsing of the Foo value failed: " ++)
        (Foo <$> o .: "someField")

Since 0.6.2.0

prependFailure :: String -> Parser a -> Parser a Source #

If the inner `Parser` failed, prepend the given string to the failure message.

    prependFailure s = modifyFailure (s ++)

parserThrowError :: JSONPath -> String -> Parser a Source #

Throw a parser error with an additional path.

Since: 1.2.1.0

parserCatchError :: Parser a -> (JSONPath -> String -> Parser a) -> Parser a Source #

A handler function to handle previous errors and return to normal execution.

Since: 1.2.1.0

## Keys for maps

class ToJSONKey a where Source #

Typeclass for types that can be used as the key of a map-like container (like `Map` or `HashMap`). For example, since `Text` has a `ToJSONKey` instance and `Char` has a `ToJSON` instance, we can encode a value of type `Map` `Text` `Char`:

    >>> LBC8.putStrLn $ encode $ Map.fromList [("foo" :: Text, 'a')]
    {"foo":"a"}

Since `Int` also has a `ToJSONKey` instance, we can similarly write:

    >>> LBC8.putStrLn $ encode $ Map.fromList [(5 :: Int, 'a')]
    {"5":"a"}

JSON documents only accept strings as object keys. For any type from `base` that has a natural textual representation, it can be expected that its `ToJSONKey` instance will choose that representation.

For data types that lack a natural textual representation, an alternative is provided. The map-like container is represented as a JSON array instead of a JSON object. Each value in the array is an array with exactly two values. The first is the key and the second is the value.

For example, values of type '[Text]' cannot be encoded to a string, so a `Map` with keys of type '[Text]' is encoded as follows:

    >>> LBC8.putStrLn $ encode $ Map.fromList [(["foo","bar","baz" :: Text], 'a')]
    [[["foo","bar","baz"],"a"]]

The default implementation of `ToJSONKey` chooses this method of encoding a key, using the `ToJSON` instance of the type.

To use your own data type as the key in a map, all that is needed is to write a `ToJSONKey` (and possibly a `FromJSONKey`) instance for it. If the type cannot be trivially converted to and from `Text`, it is recommended that `ToJSONKeyValue` is used. Since the default implementations of the typeclass methods can build this from a `ToJSON` instance, there is nothing that needs to be written:

    data Foo = Foo { fooAge :: Int, fooName :: Text }
      deriving (Eq,Ord,Generic)
    instance ToJSON Foo
    instance ToJSONKey Foo

That's it. We can now write:

    >>> let m = Map.fromList [(Foo 4 "bar",'a'),(Foo 6 "arg",'b')]
    >>> LBC8.putStrLn $ encode m
    [[{"fooName":"bar","fooAge":4},"a"],[{"fooName":"arg","fooAge":6},"b"]]

The next case to consider is if we have a type that is a newtype wrapper around `Text`. The recommended approach is to use generalized newtype deriving:

    newtype RecordId = RecordId { getRecordId :: Text }
      deriving (Eq,Ord,ToJSONKey)

Then we may write:

    >>> LBC8.putStrLn $ encode $ Map.fromList [(RecordId "abc",'a')]
    {"abc":"a"}

Simple sum types are a final case worth considering. Suppose we have:

    data Color = Red | Green | Blue
      deriving (Show,Read,Eq,Ord)

It is possible to get the `ToJSONKey` instance for free as we did with `Foo`. However, in this case, we have a natural way to go to and from `Text` that does not require any escape sequences. So `ToJSONKeyText` can be used instead of `ToJSONKeyValue` to encode maps as objects instead of arrays of pairs. This instance may be implemented using generics as follows:

    instance ToJSONKey Color where
      toJSONKey = genericToJSONKey defaultJSONKeyOptions

### Low-level implementations

Expand

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.

Minimal complete definition

Nothing

Methods

toJSONKey :: ToJSONKeyFunction a Source #

Strategy for rendering the key for a map-like container.

default toJSONKey :: ToJSON a => ToJSONKeyFunction a Source #

toJSONKeyList :: ToJSONKeyFunction [a] Source #

This is similar in spirit to the `showsList` method of `Show`. It makes it possible to give `String` keys special treatment without using `OverlappingInstances`. End users should always be able to use the default implementation of this method.

default toJSONKeyList :: ToJSON a => ToJSONKeyFunction [a] Source #

#### Instances

Instances details

ToJSONKey Bool Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Bool Source # toJSONKeyList :: ToJSONKeyFunction [Bool] Source #
ToJSONKey Char Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Char Source # toJSONKeyList :: ToJSONKeyFunction [Char] Source #
ToJSONKey Double Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Double Source # toJSONKeyList :: ToJSONKeyFunction [Double] Source #
ToJSONKey Float Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Float Source # toJSONKeyList :: ToJSONKeyFunction [Float] Source #
ToJSONKey Int Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Int Source # toJSONKeyList :: ToJSONKeyFunction [Int] Source #
ToJSONKey Int8 Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Int8 Source # toJSONKeyList :: ToJSONKeyFunction [Int8] Source #
ToJSONKey Int16 Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Int16 Source # toJSONKeyList :: ToJSONKeyFunction [Int16] Source #
ToJSONKey Int32 Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Int32 Source # toJSONKeyList :: ToJSONKeyFunction [Int32] Source #
ToJSONKey Int64 Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Int64 Source # toJSONKeyList :: ToJSONKeyFunction [Int64] Source #
ToJSONKey Integer Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Integer Source # toJSONKeyList :: ToJSONKeyFunction [Integer] Source #
ToJSONKey Natural Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Natural Source # toJSONKeyList :: ToJSONKeyFunction [Natural] Source #
ToJSONKey Word Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Word Source # toJSONKeyList :: ToJSONKeyFunction [Word] Source #
ToJSONKey Word8 Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Word8 Source # toJSONKeyList :: ToJSONKeyFunction [Word8] Source #
ToJSONKey Word16 Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Word16 Source # toJSONKeyList :: ToJSONKeyFunction [Word16] Source #
ToJSONKey Word32 Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Word32 Source # toJSONKeyList :: ToJSONKeyFunction [Word32] Source #
ToJSONKey Word64 Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Word64 Source # toJSONKeyList :: ToJSONKeyFunction [Word64] Source #
ToJSONKey Text Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Text Source # toJSONKeyList :: ToJSONKeyFunction [Text] Source #
ToJSONKey Text Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Text Source # toJSONKeyList :: ToJSONKeyFunction [Text] Source #
ToJSONKey Version Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Version Source # toJSONKeyList :: ToJSONKeyFunction [Version] Source #
ToJSONKey Scientific Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Scientific Source # toJSONKeyList :: ToJSONKeyFunction [Scientific] Source #
ToJSONKey ZonedTime Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction ZonedTime Source # toJSONKeyList :: ToJSONKeyFunction [ZonedTime] Source #
ToJSONKey TimeOfDay Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction TimeOfDay Source # toJSONKeyList :: ToJSONKeyFunction [TimeOfDay] Source #
ToJSONKey LocalTime Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction LocalTime Source # toJSONKeyList :: ToJSONKeyFunction [LocalTime] Source #
ToJSONKey UTCTime Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction UTCTime Source # toJSONKeyList :: ToJSONKeyFunction [UTCTime] Source #
ToJSONKey DayOfWeek Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction DayOfWeek Source # toJSONKeyList :: ToJSONKeyFunction [DayOfWeek] Source #
ToJSONKey Day Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Day Source # toJSONKeyList :: ToJSONKeyFunction [Day] Source #
ToJSONKey UUID Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction UUID Source # toJSONKeyList :: ToJSONKeyFunction [UUID] Source #
(ToJSONKey a, ToJSON a) => ToJSONKey [a] Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction [a] Source # toJSONKeyList :: ToJSONKeyFunction [[a]] Source #
ToJSONKey a => ToJSONKey (Identity a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction (Identity a) Source # toJSONKeyList :: ToJSONKeyFunction [Identity a] Source #
HasResolution a => ToJSONKey (Fixed a) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction (Fixed a) Source # toJSONKeyList :: ToJSONKeyFunction [Fixed a] Source #
(ToJSON a, ToJSON b) => ToJSONKey (a, b) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction (a, b) Source # toJSONKeyList :: ToJSONKeyFunction [(a, b)] Source #
(ToJSON a, ToJSON b, ToJSON c) => ToJSONKey (a, b, c) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction (a, b, c) Source # toJSONKeyList :: ToJSONKeyFunction [(a, b, c)] Source #
ToJSONKey b => ToJSONKey (Tagged a b) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction (Tagged a b) Source # toJSONKeyList :: ToJSONKeyFunction [Tagged a b] Source #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d) => ToJSONKey (a, b, c, d) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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

#### Instances

Instances details

Contravariant ToJSONKeyFunction Source # |
Instance details Defined in Data.Aeson.Types.ToJSON Methods contramap :: (a -> b) -> ToJSONKeyFunction b -> ToJSONKeyFunction a (>$) :: b -> ToJSONKeyFunction b -> ToJSONKeyFunction a

toJSONKeyText :: (a -> Text) -> ToJSONKeyFunction a Source #

Helper for creating textual keys.

    instance ToJSONKey MyKey where
        toJSONKey = toJSONKeyText myKeyToText
          where
            myKeyToText = Text.pack . show -- or showt from text-show

contramapToJSONKeyFunction :: (b -> a) -> ToJSONKeyFunction a -> ToJSONKeyFunction b Source #

Contravariant map, as `ToJSONKeyFunction` is a contravariant functor.

class FromJSONKey a where Source #

Read the docs for `ToJSONKey` first. This class is a conversion in the opposite direction. If you have a newtype wrapper around `Text`, the recommended way to define instances is with generalized newtype deriving:

    newtype SomeId = SomeId { getSomeId :: Text }
      deriving (Eq,Ord,Hashable,FromJSONKey)

If you have a sum of nullary constructors, you may use the generic implementation:

    data Color = Red | Green | Blue
      deriving Generic

    instance FromJSONKey Color where
      fromJSONKey = genericFromJSONKey defaultJSONKeyOptions

Minimal complete definition

Nothing

Methods

fromJSONKey :: FromJSONKeyFunction a Source #

Strategy for parsing the key of a map-like container.

default fromJSONKey :: FromJSON a => FromJSONKeyFunction a Source #

fromJSONKeyList :: FromJSONKeyFunction [a] Source #

This is similar in spirit to the `readList` method of `Read`. It makes it possible to give `String` keys special treatment without using `OverlappingInstances`. End users should always be able to use the default implementation of this method.

default fromJSONKeyList :: FromJSON a => FromJSONKeyFunction [a] Source #

#### Instances

Instances details

FromJSONKey Bool Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Bool Source # fromJSONKeyList :: FromJSONKeyFunction [Bool] Source #
FromJSONKey Char Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Char Source # fromJSONKeyList :: FromJSONKeyFunction [Char] Source #
FromJSONKey Double Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Double Source # fromJSONKeyList :: FromJSONKeyFunction [Double] Source #
FromJSONKey Float Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Float Source # fromJSONKeyList :: FromJSONKeyFunction [Float] Source #
FromJSONKey Int Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Int Source # fromJSONKeyList :: FromJSONKeyFunction [Int] Source #
FromJSONKey Int8 Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Int8 Source # fromJSONKeyList :: FromJSONKeyFunction [Int8] Source #
FromJSONKey Int16 Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Int16 Source # fromJSONKeyList :: FromJSONKeyFunction [Int16] Source #
FromJSONKey Int32 Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Int32 Source # fromJSONKeyList :: FromJSONKeyFunction [Int32] Source #
FromJSONKey Int64 Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Int64 Source # fromJSONKeyList :: FromJSONKeyFunction [Int64] Source #
FromJSONKey Integer Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Integer Source # fromJSONKeyList :: FromJSONKeyFunction [Integer] Source #
FromJSONKey Natural Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Natural Source # fromJSONKeyList :: FromJSONKeyFunction [Natural] Source #
FromJSONKey Word Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Word Source # fromJSONKeyList :: FromJSONKeyFunction [Word] Source #
FromJSONKey Word8 Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Word8 Source # fromJSONKeyList :: FromJSONKeyFunction [Word8] Source #
FromJSONKey Word16 Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Word16 Source # fromJSONKeyList :: FromJSONKeyFunction [Word16] Source #
FromJSONKey Word32 Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Word32 Source # fromJSONKeyList :: FromJSONKeyFunction [Word32] Source #
FromJSONKey Word64 Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Word64 Source # fromJSONKeyList :: FromJSONKeyFunction [Word64] Source #
FromJSONKey Text Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Text Source # fromJSONKeyList :: FromJSONKeyFunction [Text] Source #
FromJSONKey Text Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Text Source # fromJSONKeyList :: FromJSONKeyFunction [Text] Source #
FromJSONKey Version Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Version Source # fromJSONKeyList :: FromJSONKeyFunction [Version] Source #
FromJSONKey ZonedTime Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction ZonedTime Source # fromJSONKeyList :: FromJSONKeyFunction [ZonedTime] Source #
FromJSONKey TimeOfDay Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction TimeOfDay Source # fromJSONKeyList :: FromJSONKeyFunction [TimeOfDay] Source #
FromJSONKey LocalTime Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction LocalTime Source # fromJSONKeyList :: FromJSONKeyFunction [LocalTime] Source #
FromJSONKey UTCTime Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction UTCTime Source # fromJSONKeyList :: FromJSONKeyFunction [UTCTime] Source #
FromJSONKey DayOfWeek Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction DayOfWeek Source # fromJSONKeyList :: FromJSONKeyFunction [DayOfWeek] Source #
FromJSONKey Day Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Day Source # fromJSONKeyList :: FromJSONKeyFunction [Day] Source #
FromJSONKey UUID Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction UUID Source # fromJSONKeyList :: FromJSONKeyFunction [UUID] Source #
(FromJSONKey a, FromJSON a) => FromJSONKey [a] Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction [a] Source # fromJSONKeyList :: FromJSONKeyFunction [[a]] Source #
FromJSONKey a => FromJSONKey (Identity a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction (Identity a) Source # fromJSONKeyList :: FromJSONKeyFunction [Identity a] Source #
(FromJSON a, FromJSON b) => FromJSONKey (a, b) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction (a, b) Source # fromJSONKeyList :: FromJSONKeyFunction [(a, b)] Source #
(FromJSON a, FromJSON b, FromJSON c) => FromJSONKey (a, b, c) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction (a, b, c) Source # fromJSONKeyList :: FromJSONKeyFunction [(a, b, c)] Source #
FromJSONKey b => FromJSONKey (Tagged a b) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction (Tagged a b) Source # fromJSONKeyList :: FromJSONKeyFunction [Tagged a b] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSONKey (a, b, c, d) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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

Instances details

Functor FromJSONKeyFunction Source # | Only law abiding up to interpretation
Instance details Defined in Data.Aeson.Types.FromJSON Methods fmap :: (a -> b) -> FromJSONKeyFunction a -> FromJSONKeyFunction b # (<$) :: a -> FromJSONKeyFunction b -> FromJSONKeyFunction a #

fromJSONKeyCoerce :: Coercible Text a => FromJSONKeyFunction a Source #

Construct `FromJSONKeyFunction` for types coercible from `Text`. This conversion is still unsafe, as `Hashable` and `Eq` instances of `a` should be compatible with `Text` i.e. hash values should be equal for wrapped values as well. This property will always be maintained if the `Hashable` and `Eq` instances are derived with generalized newtype deriving. compatible with `Text` i.e. hash values be equal for wrapped values as well.

On pre GHC 7.8 this is unconstrainted function.

coerceFromJSONKeyFunction :: Coercible a b => FromJSONKeyFunction a -> FromJSONKeyFunction b Source #

Semantically the same as `coerceFromJSONKeyFunction = fmap coerce = coerce`.

See note on `fromJSONKeyCoerce`.

mapFromJSONKeyFunction :: (a -> b) -> FromJSONKeyFunction a -> FromJSONKeyFunction b Source #

Same as `fmap`. Provided for the consistency with `ToJSONKeyFunction`.

### Generic keys

class GetConName f => GToJSONKey f Source #

#### Instances

Instances details

GetConName f => GToJSONKey (f :: k -> Type) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON

genericToJSONKey :: (Generic a, GToJSONKey (Rep a)) => JSONKeyOptions -> ToJSONKeyFunction a Source #

class (ConstructorNames f, SumFromString f) => GFromJSONKey f Source #

#### Instances

Instances details

(ConstructorNames f, SumFromString f) => GFromJSONKey f Source # |
Instance details Defined in Data.Aeson.Types.FromJSON

genericFromJSONKey :: forall a. (Generic a, GFromJSONKey (Rep a)) => JSONKeyOptions -> FromJSONKeyFunction a Source #

`fromJSONKey` for `Generic` types. These types must be sums of nullary constructors, whose names will be used as keys for JSON objects.

See also `genericToJSONKey`.

### Example

Expand

    data Color = Red | Green | Blue
      deriving Generic

    instance FromJSONKey Color where
      fromJSONKey = genericFromJSONKey defaultJSONKeyOptions

## Liftings to unary and binary type constructors

class FromJSON1 f where Source #

Lifting of the `FromJSON` class to unary type constructors.

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

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

To use the second, simply add a `deriving `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

Minimal complete definition

Nothing

Methods

liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a) Source #

default 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

Instances details

FromJSON1 [] Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 NonEmpty Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 First Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 Max Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 Min Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 Option Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 WrappedMonoid Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 DList Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 #
FromJSON1 IntMap Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 Seq Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 Tree Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 #
FromJSON a => FromJSON1 (Either a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (Either a a0) Source # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [Either a a0] Source #
FromJSON a => FromJSON1 ((,) a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, a0) Source # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, a0)] Source #
FromJSON1 (Proxy :: Type -> Type) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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, Eq k, Hashable k) => FromJSON1 (HashMap k) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 #
(FromJSONKey k, Ord k) => FromJSON1 (Map k) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 #
(FromJSON a, FromJSON b) => FromJSON1 ((,,) a b) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, a0) Source # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, a0)] Source #
FromJSON a => FromJSON1 (Const a :: Type -> Type) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (Const a a0) Source # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [Const a a0] Source #
FromJSON1 (Tagged a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (Tagged a a0) Source # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [Tagged a a0] Source #
(FromJSON a, FromJSON b, FromJSON c) => FromJSON1 ((,,,) a b c) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, a0) Source # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, a0)] Source #
(FromJSON1 f, FromJSON1 g) => FromJSON1 (Sum f g) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, a0) Source # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, a0)] Source #
(FromJSON1 f, FromJSON1 g) => FromJSON1 (Compose f g) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, a0) Source # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, a0)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f) => FromJSON1 ((,,,,,,) a b c d e f) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, f, a0) Source # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, f, a0)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g) => FromJSON1 ((,,,,,,,) a b c d e f g) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, f, g, a0) Source # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, f, g, a0)] 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, f, g, h, a0) Source # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, a0)] 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, a0) Source # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, a0)] 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, a0) Source # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, a0)] 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, a0) Source # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, a0)] 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, a0) Source # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, a0)] 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, a0) Source # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, a0)] 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0) Source # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0)] 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

Instances details

FromJSON2 Either Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (a, a0, b) Source # liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [(a, a0, b)] Source #
FromJSON2 (Const :: Type -> Type -> Type) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 :: Type -> Type -> Type) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON 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 # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, a0, b0) Source # liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, a0, b0)] Source #
(FromJSON a, FromJSON b, FromJSON c) => FromJSON2 ((,,,,) a b c) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, c, a0, b0) Source # liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, a0, b0)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSON2 ((,,,,,) a b c d) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, c, d, a0, b0) Source # liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, a0, b0)] Source #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e) => FromJSON2 ((,,,,,,) a b c d e) Source # |

Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, c, d, e, a0, b0) Source #

liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, e, a0, b0)] Source #

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f) => FromJSON2 ((,,,,,,,) a b c d e f) Source # |

Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, c, d, e, f, a0, b0) Source #

liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, e, f, a0, b0)] Source #

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g) => FromJSON2 ((,,,,,,,,) a b c d e f g) Source # |

Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, c, d, e, f, g, a0, b0) Source #

liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, e, f, g, a0, b0)] 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 # |

Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, c, d, e, f, g, h, a0, b0) Source #

liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, a0, b0)] 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 # |

Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

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

liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, a0, b0)] 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 # |

Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

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

liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, a0, b0)] 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 # |

Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

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

liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, a0, b0)] 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 # |

Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

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

liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, a0, b0)] 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 # |

Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

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

liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, a0, b0)] 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`.

Minimal complete definition

Nothing

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> f a -> Value Source #

default liftToJSON :: (Generic1 f, GToJSON Value One (Rep1 f)) => (a -> Value) -> ([a] -> Value) -> f a -> Value Source #

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [f a] -> Value Source #

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding Source #

default liftToEncoding :: (Generic1 f, GToJSON Encoding One (Rep1 f)) => (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding Source #

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [f a] -> Encoding Source #

#### Instances

Instances details

ToJSON1 [] Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |

Instance details

Defined in Data.Aeson.Types.ToJSON

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

Instance details

Defined in Data.Aeson.Types.ToJSON

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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 First Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 Max Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 Min Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 Option Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 WrappedMonoid Source # |

Instance details

Defined in Data.Aeson.Types.ToJSON

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 DList Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 # |

Instance details

Defined in Data.Aeson.Types.ToJSON

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 # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 #
ToJSON1 Set Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 IntMap Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 Seq Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 Tree Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 #
ToJSON a => ToJSON1 (Either a) Source # |

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> Either a a0 -> Value Source #

liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [Either a a0] -> Value Source #

liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> Either a a0 -> Encoding Source #

liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [Either a a0] -> Encoding Source #

ToJSON a => ToJSON1 ((,) a) Source # |

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> (a, a0) -> Value Source #

liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [(a, a0)] -> Value Source #

liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, a0) -> Encoding Source #

liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, a0)] -> Encoding Source #

ToJSON1 (Proxy :: Type -> Type) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 (HashMap k) Source # |

Instance details

Defined in Data.Aeson.Types.ToJSON

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 #

ToJSONKey k => ToJSON1 (Map k) Source # |
Instance details Defined in Data.Aeson.Types.ToJSON 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 #
(ToJSON a, ToJSON b) => ToJSON1 ((,,) a b) Source # |

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

ToJSON a => ToJSON1 (Const a :: Type -> Type) Source # |

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> Const a a0 -> Value Source #

liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [Const a a0] -> Value Source #

liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> Const a a0 -> Encoding Source #

liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [Const a a0] -> Encoding Source #

ToJSON1 (Tagged a) Source # |

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> Tagged a a0 -> Value Source #

liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [Tagged a a0] -> Value Source #

liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> Tagged a a0 -> Encoding Source #

liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [Tagged a a0] -> Encoding Source #

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

(ToJSON1 f, ToJSON1 g) => ToJSON1 (Sum f g) Source # |

Instance details

Defined in Data.Aeson.Types.ToJSON

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

Instance details

Defined in Data.Aeson.Types.ToJSON

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

(ToJSON1 f, ToJSON1 g) => ToJSON1 (Compose f g) Source # |

Instance details

Defined in Data.Aeson.Types.ToJSON

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

Instances details

ToJSON2 Either Source # |

Instance details

Defined in Data.Aeson.Types.ToJSON

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

Instance details

Defined in Data.Aeson.Types.ToJSON

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

ToJSON2 (Const :: Type -> Type -> Type) Source # |

Instance details

Defined in Data.Aeson.Types.ToJSON

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 :: Type -> Type -> Type) Source # |

Instance details

Defined in Data.Aeson.Types.ToJSON

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

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

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

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

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

class GFromJSON arity f where Source #

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

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

Instances details

GFromJSON One Par1 Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs One a -> Value -> Parser (Par1 a) Source #
GFromJSON arity (V1 :: Type -> Type) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs arity a -> Value -> Parser (V1 a) Source #
FromJSON1 f => GFromJSON One (Rec1 f) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs One a -> Value -> Parser (Rec1 f a) Source #
(GFromJSON' arity a, Datatype d) => GFromJSON arity (D1 d a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs arity a0 -> Value -> Parser (D1 d a a0) Source #
FromJSON a => GFromJSON arity (K1 i a :: Type -> Type) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs arity a0 -> Value -> Parser (K1 i a a0) Source #
GFromJSON arity a => GFromJSON arity (M1 i c a) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs arity a0 -> Value -> Parser (M1 i c a a0) Source #
(FromJSON1 f, GFromJSON One g) => GFromJSON One (f :.: g) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs One a -> Value -> Parser ((f :.: g) 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 |

type GToJSON = GToJSON Value Source #

type GToEncoding = GToJSON 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

Instances details

GFromJSON One Par1 Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs One a -> Value -> Parser (Par1 a) Source #
FromJSON1 f => GFromJSON One (Rec1 f) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs One a -> Value -> Parser (Rec1 f a) Source #
(FromJSON1 f, GFromJSON One g) => GFromJSON One (f :.: g) Source # |
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs One a -> Value -> Parser ((f :.: g) a) Source #

genericToJSON :: (Generic a, GToJSON Value Zero (Rep a)) => Options -> a -> Value Source #

A configurable generic JSON creator. This function applied to `defaultOptions` is used as the default for `toJSON` when the type is an instance of `Generic`.

genericLiftToJSON :: (Generic1 f, GToJSON Value One (Rep1 f)) => Options -> (a -> Value) -> ([a] -> Value) -> f a -> Value Source #

A configurable generic JSON creator. This function applied to `defaultOptions` is used as the default for `liftToJSON` when the type is an instance of `Generic1`.

genericToEncoding :: (Generic a, GToJSON Encoding Zero (Rep a)) => Options -> a -> Encoding Source #

A configurable generic JSON encoder. This function applied to `defaultOptions` is used as the default for `toEncoding` when the type is an instance of `Generic`.

genericLiftToEncoding :: (Generic1 f, GToJSON Encoding One (Rep1 f)) => Options -> (a -> 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`.

# Inspecting ``Value`s`

withObject :: String -> (Object -> Parser a) -> Value -> Parser a Source #

``withObject` name f value` applies `f` to the `Object` when `value` is an `Object` and fails otherwise.

#### Error message example

    withObject "MyType" f (String "oops")
    -- Error: "parsing MyType failed, expected Object, but encountered String"

withText :: String -> (Text -> Parser a) -> Value -> Parser a Source #

``withText` name f value` applies `f` to the `Text` when `value` is a `String` and fails otherwise.

#### Error message example

    withText "MyType" f Null
    -- Error: "parsing MyType failed, expected String, but encountered Null"

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

#### Error message example

    withArray "MyType" f (String "oops")
    -- Error: "parsing MyType failed, expected Array, but encountered String"

withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a Source #

``withScientific` name f value` applies `f` to the `Scientific` number when `value` is a `Number` and fails using `typeMismatch` otherwise.

Warning: If you are converting from a scientific to an unbounded type such as `Integer` you may want to add a restriction on the size of the exponent (see `withBoundedScientific`) to prevent malicious input from filling up the memory of the target system.

#### Error message example

    withScientific "MyType" f (String "oops")
    -- Error: "parsing MyType failed, expected Number, but encountered String"

withBool :: String -> (Bool -> Parser a) -> Value -> Parser a Source #

``withBool` expected f value` applies `f` to the `Bool` when `value` is a `Boolean` and fails otherwise.

#### Error message example

    withBool "MyType" f (String "oops")
    -- Error: "parsing MyType failed, expected Boolean, but encountered String"

withEmbeddedJSON :: String -> (Value -> Parser a) -> Value -> Parser a Source #

Decode a nested JSON-encoded string.

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.

parseField :: FromJSON a => Object -> Text -> Parser a Source #

Function variant of `.:`.

parseFieldMaybe :: FromJSON a => Object -> Text -> Parser (Maybe a) Source #

Function variant of `.:?`.

parseFieldMaybe' :: FromJSON a => Object -> Text -> Parser (Maybe a) Source #

Function variant of `.:!`.

explicitParseField :: (Value -> Parser a) -> Object -> Text -> Parser a Source #

Variant of `.:` with explicit parser function.

E.g. ``explicitParseField` `parseJSON1` :: (`FromJSON1` f, `FromJSON` a) -> `Object` -> `Text` -> `Parser` (f a)`

explicitParseFieldMaybe :: (Value -> Parser a) -> Object -> Text -> Parser (Maybe a) Source #

Variant of `.:?` with explicit parser function.

explicitParseFieldMaybe' :: (Value -> Parser a) -> Object -> Text -> Parser (Maybe a) Source #

Variant of `.:!` with explicit parser function.

listEncoding :: (a -> Encoding) -> [a] -> Encoding Source #

Helper function to use with `liftToEncoding`. Useful when writing own `ToJSON1` instances.

    newtype F a = F [a]

    -- This instance encodes String as an array of chars
    instance ToJSON1 F where
        liftToJSON     tj _ (F xs) = liftToJSON     tj (listValue    tj) xs
        liftToEncoding te _ (F xs) = liftToEncoding te (listEncoding te) xs

    instance FromJSON1 F where
        liftParseJSON p _ v = F <$> liftParseJSON p (listParser p) v

listValue :: (a -> Value) -> [a] -> Value Source #

Helper function to use with `liftToJSON`, see `listEncoding`.

listParser :: (Value -> Parser a) -> Value -> Parser [a] Source #

Helper function to use with `liftParseJSON`. See `listEncoding`.

# Generic and TH encoding configuration

data Options Source #

Options that specify how to encode/decode your datatype to/from JSON.

Options can be set using record syntax on `defaultOptions` with the fields below.

#### Instances

Instances details

Show Options Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> Options -> ShowS show :: Options -> String showList :: [Options] -> ShowS

## Options fields

The functions here are in fact record fields of the `Options` type.

fieldLabelModifier :: Options -> String -> String Source #

Function applied to field labels. Handy for removing common record prefixes for example.

constructorTagModifier :: Options -> String -> String Source #

Function applied to constructor tags which could be handy for lower-casing them for example.

allNullaryToStringTag :: Options -> Bool Source #

If `True` the constructors of a datatype, with all nullary constructors, will be encoded to just a string with the constructor tag. If `False` the encoding will always follow the `sumEncoding`.

omitNothingFields :: Options -> Bool Source #

If `True`, record fields with a `Nothing` value will be omitted from the resulting object. If `False`, the resulting object will include those fields mapping to `null`.

Note that this does not affect parsing: `Maybe` fields are optional regardless of the value of `omitNothingFields`, subject to the note below.

### Note

Setting `omitNothingFields` to `True` only affects fields which are of type `Maybe` uniformly in the `ToJSON` instance. In particular, if the type of a field is declared as a type variable, it will not be omitted from the JSON object, unless the field is specialized upfront in the instance.

The same holds for `Maybe` fields being optional in the `FromJSON` instance.

#### Example

Expand

The generic instance for the following type `Fruit` depends on whether the instance head is `Fruit a` or `Fruit (Maybe a)`.

    data Fruit a = Fruit
      { apples :: a  -- A field whose type is a type variable.
      , oranges :: Maybe Int
      } deriving Generic

    -- apples required, oranges optional
    -- Even if fromJSON is then specialized to (Fruit (Maybe a)).
    instance FromJSON a => FromJSON (Fruit a)

    -- apples optional, oranges optional
    -- In this instance, the field apples is uniformly of type (Maybe a).
    instance FromJSON a => FromJSON (Fruit (Maybe a))

    options :: Options
    options = defaultOptions { omitNothingFields = True }

    -- apples always present in the output, oranges is omitted if Nothing
    instance ToJSON a => ToJSON (Fruit a) where
      toJSON = genericToJSON options

    -- both apples and oranges are omitted if Nothing
    instance ToJSON a => ToJSON (Fruit (Maybe a)) where
      toJSON = genericToJSON options

sumEncoding :: Options -> SumEncoding Source #

Specifies how to encode constructors of a sum datatype.

unwrapUnaryRecords :: Options -> Bool Source #

Hide the field name when a record constructor has only one field, like a newtype.

tagSingleConstructors :: Options -> Bool Source #

Encode types with a single constructor as sums, so that `allNullaryToStringTag` and `sumEncoding` apply.

rejectUnknownFields :: Options -> Bool Source #

Applies only to `FromJSON` instances. If a field appears in the parsed object map, but does not appear in the target object, parsing will fail, with an error message indicating which fields were unknown.

## Options utilities

data SumEncoding Source #

Specifies how to encode constructors of a sum datatype.

Constructors

TaggedObject

A constructor will be encoded to an object with a field `tagFieldName` which specifies the constructor tag (modified by the `constructorTagModifier`). If the constructor is a record the encoded record fields will be unpacked into this object. So make sure that your record doesn't have a field with the same label as the `tagFieldName`. Otherwise the tag gets overwritten by the encoded value of that field! If the constructor is not a record the encoded constructor contents will be stored under the `contentsFieldName` field.

Fields

- tagFieldName :: String
- contentsFieldName :: String

UntaggedValue

Constructor names won't be encoded. Instead only the contents of the constructor will be encoded as if the type had a single constructor. JSON encodings have to be disjoint for decoding to work properly.

When decoding, constructors are tried in the order of definition. If some encodings overlap, the first one defined will succeed.

Note: Nullary constructors are encoded as strings (using `constructorTagModifier`). Having a nullary constructor alongside a single field constructor that encodes to a string leads to ambiguity.

Note: Only the last error is kept when decoding, so in the case of malformed JSON, only an error for the last constructor will be reported.

ObjectWithSingleField | A constructor will be encoded to an object with a single field named after the constructor tag (modified by the `constructorTagModifier`) which maps to the encoded contents of the constructor.
TwoElemArray | A constructor will be encoded to a 2-element array where the first element is the tag of the constructor (modified by the `constructorTagModifier`) and the second element the encoded contents of the constructor.

#### Instances

Instances details

Eq SumEncoding Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: SumEncoding -> SumEncoding -> Bool (/=) :: SumEncoding -> SumEncoding -> Bool
Show SumEncoding Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> SumEncoding -> ShowS show :: SumEncoding -> String showList :: [SumEncoding] -> ShowS

camelTo :: Char -> String -> String Source #

Deprecated: Use camelTo2 for better results

Converts from CamelCase to another lower case, interspersing the character between all capital letters and their previous entries, except those capital letters that appear together, like `API`.

For use by Aeson template haskell calls.

    camelTo '_' 'CamelCaseAPI' == "camel_case_api"

camelTo2 :: Char -> String -> String Source #

Better version of `camelTo`. Example where it works better:

    camelTo '_' 'CamelAPICase' == "camel_apicase"
    camelTo2 '_' 'CamelAPICase' == "camel_api_case"

defaultOptions :: Options Source #

Default encoding `Options`:

    Options
    { fieldLabelModifier      = id
    , constructorTagModifier  = id
    , allNullaryToStringTag   = True
    , omitNothingFields       = False
    , sumEncoding             = defaultTaggedObject
    , unwrapUnaryRecords      = False
    , tagSingleConstructors   = False
    , rejectUnknownFields     = False
    }

defaultTaggedObject :: SumEncoding Source #

Default `TaggedObject` `SumEncoding` options:

    defaultTaggedObject = TaggedObject
                          { tagFieldName      = "tag"
                          , contentsFieldName = "contents"
                          }

## Options for object keys

data JSONKeyOptions Source #

Options for encoding keys with `genericFromJSONKey` and `genericToJSONKey`.

keyModifier :: JSONKeyOptions -> String -> String Source #

Function applied to keys. Its result is what goes into the encoded `Value`.

### Example

Expand

The following instances encode the constructor `Bar` to lower-case keys `"bar"`.

    data Foo = Bar
      deriving Generic

    opts :: JSONKeyOptions
    opts = defaultJSONKeyOptions { keyModifier = toLower }

    instance ToJSONKey Foo where
      toJSONKey = genericToJSONKey opts

    instance FromJSONKey Foo where
      fromJSONKey = genericFromJSONKey opts

defaultJSONKeyOptions :: JSONKeyOptions Source #

Default `JSONKeyOptions`:

    defaultJSONKeyOptions = JSONKeyOptions
                            { keyModifier = id
                            }

# Parsing context

(<?>) :: Parser a -> JSONPathElement -> Parser a Source #

Add JSON Path context to a parser

When parsing a complex structure, it helps to annotate (sub)parsers with context, so that if an error occurs, you can find its location.

    withObject "Person" $ \o ->
      Person
        <$> o .: "name" <?> Key "name"
        <*> o .: "age"  <?> Key "age"

(Standard methods like `(.:)` already do this.)

With such annotations, if an error occurs, you will get a JSON Path location of that error.

Since 0.10

type JSONPath = [JSONPathElement] Source #

data JSONPathElement Source #

Elements of a JSON path used to describe the location of an error.

Constructors

Key Text | JSON path element of a key into an object, "object.key".
Index !Int | JSON path element of an index into an array, "array[index]".

#### Instances

Instances details

Eq JSONPathElement Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: JSONPathElement -> JSONPathElement -> Bool (/=) :: JSONPathElement -> JSONPathElement -> Bool
Ord JSONPathElement Source # |

Instance details

Defined in Data.Aeson.Types.Internal

Methods

compare :: JSONPathElement -> JSONPathElement -> Ordering

(<) :: JSONPathElement -> JSONPathElement -> Bool

(<=) :: JSONPathElement -> JSONPathElement -> Bool

(>) :: JSONPathElement -> JSONPathElement -> Bool

(>=) :: JSONPathElement -> JSONPathElement -> Bool

max :: JSONPathElement -> JSONPathElement -> JSONPathElement

min :: JSONPathElement -> JSONPathElement -> JSONPathElement

Show JSONPathElement Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> JSONPathElement -> ShowS show :: JSONPathElement -> String showList :: [JSONPathElement] -> ShowS
NFData JSONPathElement Source # |
Instance details Defined in Data.Aeson.Types.Internal Methods rnf :: JSONPathElement -> ()

formatPath :: JSONPath -> String Source #

Format a JSONPath as a `String`, representing the root object as `$`.

formatRelativePath :: JSONPath -> String Source #

Format a JSONPath as a `String` which represents the path relative to some root object.