Safe Haskell	None
Language	Haskell2010

Data.HighJson

Contents

A json specification for any type
Construct specifications for records
Construct specifications for sum types
Construct specifications for enum types
Shared between specifications for simplicity
Generate json serializers/encoders and parsers from specs
Specification structures
Aeson reexports
Implementation detail structures

Synopsis

A json specification for any type

data HighSpec a ty as #

Constructors

HighSpec
Fields hs_name :: !Text hs_description :: !(Maybe Text) hs_bodySpec :: !(BodySpec ty a as)

data SpecType #

Constructors

SpecRecord
SpecSum
SpecEnum

Construct specifications for records

recSpec :: (IsDataSpec q, DContainer q ~ RecordFields) => Text -> Maybe Text -> HVectElim (DFields q) (DType q) -> q -> RecordTypeSpec (DType q) (DFields q) #

The specification for a record. Contains a name, an optional description, the constructor and a description how to parse and serialize fields respecting a given json key.

type RecordTypeSpec t flds = HighSpec t SpecRecord flds #

A specification for a record

reqField :: FromJSON f => Text -> (t -> f) -> RecordField t f #

A required json field. The key must be present in the json.

(.=) :: FromJSON f => Text -> (t -> f) -> RecordField t f #

Alias for reqField

optField :: FromJSON f => Text -> (t -> Maybe f) -> RecordField t (Maybe f) #

An optional json field.

(.=?) :: FromJSON f => Text -> (t -> Maybe f) -> RecordField t (Maybe f) #

Alias for optField

Construct specifications for sum types

sumSpec :: (IsDataSpec q, DContainer q ~ SumOptions) => Text -> Maybe Text -> q -> SumTypeSpec (DType q) (DFields q) #

The specification for a sum type. Contains a name, an optional description and a mapping from all constructor (prims) to their respective json fields

type SumTypeSpec t flds = HighSpec t SpecSum flds #

A specification for an arbitrary sum type

sumOpt :: Text -> Prism' t o -> SumOption t o #

An option of a sum type

(.->) :: Text -> Prism' t o -> SumOption t o #

Alias for sumOpt

Construct specifications for enum types

enumSpec :: (IsDataSpec q, DContainer q ~ PhantomEnumContainer) => Text -> Maybe Text -> q -> EnumTypeSpec (DType q) (DFields q) #

The specification for a classic enum type. Contains a name, an optional description and a mapping from all constructors to ther counterpart json string names.

type EnumTypeSpec t flds = HighSpec t SpecEnum flds #

A specification for a classic enum

enumOpt :: Text -> Prism' t () -> EnumOption t #

An option of a classic enum

(@->) :: Text -> Prism' t () -> EnumOption t #

Alias for enumOpt

Shared between specifications for simplicity

class IsDataSpec t where #

A type class that allows a unified notation for records and sum types. Build specifications using '(:&)' and '(.=)', '(.=?)', '(.->)' or '(@->)'

Minimal complete definition

compileRec

Associated Types

type DFields t :: [*] #

type DType t #

type DContainer t :: * -> [*] -> * #

Methods

compileRec :: t -> DContainer t (DType t) (DFields t) #

Instances

IsDataSpec (EnumOption t) #
Associated Types type DFields (EnumOption t) :: [] # type DType (EnumOption t) :: # type DContainer (EnumOption t) :: * -> [] -> # Methods compileRec :: EnumOption t -> DContainer (EnumOption t) (DType (EnumOption t)) (DFields (EnumOption t)) #
IsDataSpec (SumOption t f) #
Associated Types type DFields (SumOption t f) :: [] # type DType (SumOption t f) :: # type DContainer (SumOption t f) :: * -> [] -> # Methods compileRec :: SumOption t f -> DContainer (SumOption t f) (DType (SumOption t f)) (DFields (SumOption t f)) #
IsDataSpec (RecordField t f) #
Associated Types type DFields (RecordField t f) :: [] # type DType (RecordField t f) :: # type DContainer (RecordField t f) :: * -> [] -> # Methods compileRec :: RecordField t f -> DContainer (RecordField t f) (DType (RecordField t f)) (DFields (RecordField t f)) #
(IsDataSpec x, IsDataSpec y, (~) * (DType x) (DType y), (~) (* -> [] -> ) (DContainer x) (DContainer y), CombinableContainer (DContainer x)) => IsDataSpec ((:&) x y) #
Associated Types type DFields ((:&) x y) :: [] # type DType ((:&) x y) :: # type DContainer ((:&) x y) :: * -> [] -> # Methods compileRec :: (x :& y) -> DContainer (x :& y) (DType (x :& y)) (DFields (x :& y)) #

data a :& b infixr 8 #

Combination of two local specifications. For records, these are fields, for sum types and enums these are the options.

Constructors

a :& b infixr 8

Instances

Functor ((:&) a) #
Methods fmap :: (a -> b) -> (a :& a) -> a :& b # (<$) :: a -> (a :& b) -> a :& a #
Foldable ((:&) a) #
Methods fold :: Monoid m => (a :& m) -> m # foldMap :: Monoid m => (a -> m) -> (a :& a) -> m # foldr :: (a -> b -> b) -> b -> (a :& a) -> b # foldr' :: (a -> b -> b) -> b -> (a :& a) -> b # foldl :: (b -> a -> b) -> b -> (a :& a) -> b # foldl' :: (b -> a -> b) -> b -> (a :& a) -> b # foldr1 :: (a -> a -> a) -> (a :& a) -> a # foldl1 :: (a -> a -> a) -> (a :& a) -> a # toList :: (a :& a) -> [a] # null :: (a :& a) -> Bool # length :: (a :& a) -> Int # elem :: Eq a => a -> (a :& a) -> Bool # maximum :: Ord a => (a :& a) -> a # minimum :: Ord a => (a :& a) -> a # sum :: Num a => (a :& a) -> a # product :: Num a => (a :& a) -> a #
Traversable ((:&) a) #
Methods traverse :: Applicative f => (a -> f b) -> (a :& a) -> f (a :& b) # sequenceA :: Applicative f => (a :& f a) -> f (a :& a) # mapM :: Monad m => (a -> m b) -> (a :& a) -> m (a :& b) # sequence :: Monad m => (a :& m a) -> m (a :& a) #
(Bounded b, Bounded a) => Bounded ((:&) a b) #
Methods minBound :: a :& b # maxBound :: a :& b #
(Eq b, Eq a) => Eq ((:&) a b) #
Methods (==) :: (a :& b) -> (a :& b) -> Bool # (/=) :: (a :& b) -> (a :& b) -> Bool #
(Show b, Show a) => Show ((:&) a b) #
Methods showsPrec :: Int -> (a :& b) -> ShowS # show :: (a :& b) -> String # showList :: [a :& b] -> ShowS #
(Monoid a, Monoid b) => Monoid ((:&) a b) #
Methods mempty :: a :& b # mappend :: (a :& b) -> (a :& b) -> a :& b # mconcat :: [a :& b] -> a :& b #
(IsDataSpec x, IsDataSpec y, (~) * (DType x) (DType y), (~) (* -> [] -> ) (DContainer x) (DContainer y), CombinableContainer (DContainer x)) => IsDataSpec ((:&) x y) #
Associated Types type DFields ((:&) x y) :: [] # type DType ((:&) x y) :: # type DContainer ((:&) x y) :: * -> [] -> # Methods compileRec :: (x :& y) -> DContainer (x :& y) (DType (x :& y)) (DFields (x :& y)) #
type DFields ((:&) x y) #
type DFields ((:&) x y) = Append (DFields x) (DFields y)
type DType ((:&) x y) #
type DType ((:&) x y) = DType x
type DContainer ((:&) x y) #
type DContainer ((:&) x y) = DContainer x

Generate json serializers/encoders and parsers from specs

jsonSerializer :: AllHave ToJSON as => HighSpec a ty as -> a -> Value #

jsonEncoder :: AllHave ToJSON as => HighSpec a ty as -> a -> Encoding #

jsonParser :: AllHave FromJSON as => HighSpec a ty as -> Value -> Parser a #

Specification structures

data BodySpec ty a as where #

Constructors

BodySpecRecord :: !(RecordSpec a as) -> BodySpec SpecRecord a as
BodySpecSum :: !(SumSpec a as) -> BodySpec SpecSum a as
BodySpecEnum :: !(EnumSpec a) -> BodySpec SpecEnum a as

data RecordField t f #

Constructors

RecordField
Fields rf_jsonKey :: !Text rf_optional :: !Bool rf_jsonLoader :: Object -> Text -> Parser f rf_get :: !(t -> f)

Instances

IsDataSpec (RecordField t f) #
Associated Types type DFields (RecordField t f) :: [] # type DType (RecordField t f) :: # type DContainer (RecordField t f) :: * -> [] -> # Methods compileRec :: RecordField t f -> DContainer (RecordField t f) (DType (RecordField t f)) (DFields (RecordField t f)) #
type DFields (RecordField t f) #
type DFields (RecordField t f) = (:) * f ([] *)
type DType (RecordField t f) #
type DType (RecordField t f) = t
type DContainer (RecordField t f) #
type DContainer (RecordField t f) = RecordFields

data RecordSpec a fs #

Constructors

RecordSpec
Fields rs_make :: HVect fs -> a rs_fields :: RecordFields a fs

data RecordFields t fs where #

Constructors

RFEmpty :: RecordFields t '[]
(:+:) :: RecordField t f -> RecordFields t fs -> RecordFields t (f ': fs) infixr 5

Instances

CombinableContainer RecordFields #
Methods combineContainer :: RecordFields a as -> RecordFields a bs -> RecordFields a (Append as bs) #

data SumOption t o #

Constructors

SumOption
Fields so_jsonKey :: !Text so_prism :: !(Prism' t o)

Instances

IsDataSpec (SumOption t f) #
Associated Types type DFields (SumOption t f) :: [] # type DType (SumOption t f) :: # type DContainer (SumOption t f) :: * -> [] -> # Methods compileRec :: SumOption t f -> DContainer (SumOption t f) (DType (SumOption t f)) (DFields (SumOption t f)) #
type DFields (SumOption t f) #
type DFields (SumOption t f) = (:) * f ([] *)
type DType (SumOption t f) #
type DType (SumOption t f) = t
type DContainer (SumOption t f) #
type DContainer (SumOption t f) = SumOptions

data SumSpec a os #

Constructors

SumSpec
Fields ss_options :: SumOptions a os

data SumOptions t os where #

Constructors

SOEmpty :: SumOptions t '[]
(:\|:) :: SumOption t o -> SumOptions t os -> SumOptions t (o ': os) infixr 5

Instances

CombinableContainer SumOptions #
Methods combineContainer :: SumOptions a as -> SumOptions a bs -> SumOptions a (Append as bs) #

data EnumOption t #

Constructors

EnumOption
Fields eo_jsonKey :: !Text eo_prism :: !(Prism' t ())

Instances

IsDataSpec (EnumOption t) #
Associated Types type DFields (EnumOption t) :: [] # type DType (EnumOption t) :: # type DContainer (EnumOption t) :: * -> [] -> # Methods compileRec :: EnumOption t -> DContainer (EnumOption t) (DType (EnumOption t)) (DFields (EnumOption t)) #
type DFields (EnumOption t) #
type DFields (EnumOption t) = (:) * () ([] *)
type DType (EnumOption t) #
type DType (EnumOption t) = t
type DContainer (EnumOption t) #
type DContainer (EnumOption t) = PhantomEnumContainer

data EnumSpec a #

Constructors

EnumSpec
Fields es_options :: [EnumOption a]

Aeson reexports

class ToJSON a where #

A type that can be converted to JSON.

Instances in general must specify toJSON and should (but don't need to) specify toEncoding.

An example type and instance:

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

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

instance ToJSON Coord where
  toJSON (Coord x y) = object ["x" .= x, "y" .= y]

  toEncoding (Coord x y) = pairs ("x" .= x <> "y" .= y)

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

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

To use the second, simply add a deriving Generic clause to your datatype and declare a ToJSON instance. If you require nothing other than defaultOptions, it is sufficient to write (and this is the only alternative where the default toJSON implementation is sufficient):

{-# LANGUAGE DeriveGeneric #-}

import GHC.Generics

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

instance ToJSON Coord where
    toEncoding = genericToEncoding defaultOptions

If on the other hand you wish to customize the generic decoding, you have to implement both methods:

customOptions = defaultOptions
                { fieldLabelModifier = map toUpper
                }

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

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

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.
The choice of defaults allows a smooth transition for existing users: Existing instances that do not define toEncoding still compile and have the correct semantics. This is ensured by making the default implementation of toEncoding use toJSON. This produces correct results, but since it performs an intermediate conversion to a Value, it will be less efficient than directly emitting an Encoding. (this also means that specifying nothing more than instance ToJSON Coord would be sufficient as a generically decoding instance, but there probably exists no good reason to not specify toEncoding in new instances.)

Methods

toJSON :: a -> Value #

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

toEncoding :: a -> Encoding #

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 #

toEncodingList :: [a] -> Encoding #

Instances

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

class FromJSON a where #

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

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

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

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

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

An example type and instance using typeMismatch:

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

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

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

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

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

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

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

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

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

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

{-# LANGUAGE DeriveGeneric #-}

import GHC.Generics

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

instance FromJSON Coord

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

customOptions = defaultOptions
                { fieldLabelModifier = map toUpper
                }

instance FromJSON Coord where
    parseJSON = genericParseJSON customOptions

Methods

parseJSON :: Value -> Parser a #

parseJSONList :: Value -> Parser [a] #

Instances

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

Implementation detail structures

newtype PhantomEnumContainer t ts #

Constructors

PhantomEnumContainer
Fields unPhantomEnumContainer :: [EnumOption t]

Instances

CombinableContainer PhantomEnumContainer #
Methods combineContainer :: PhantomEnumContainer a as -> PhantomEnumContainer a bs -> PhantomEnumContainer a (Append as bs) #

class CombinableContainer t where #

A monoidal type class that respects type level lists associated to the bodies

Minimal complete definition

combineContainer

Methods

combineContainer :: t a (as :: [*]) -> t a (bs :: [*]) -> t a (Append as bs) #

Instances

CombinableContainer SumOptions #
Methods combineContainer :: SumOptions a as -> SumOptions a bs -> SumOptions a (Append as bs) #
CombinableContainer RecordFields #
Methods combineContainer :: RecordFields a as -> RecordFields a bs -> RecordFields a (Append as bs) #
CombinableContainer PhantomEnumContainer #
Methods combineContainer :: PhantomEnumContainer a as -> PhantomEnumContainer a bs -> PhantomEnumContainer a (Append as bs) #

IsDataSpec (EnumOption t) #
Associated Types type DFields (EnumOption t) :: [] # type DType (EnumOption t) :: # type DContainer (EnumOption t) :: * -> [] -> # Methods compileRec :: EnumOption t -> DContainer (EnumOption t) (DType (EnumOption t)) (DFields (EnumOption t)) #
IsDataSpec (SumOption t f) #
Associated Types type DFields (SumOption t f) :: [] # type DType (SumOption t f) :: # type DContainer (SumOption t f) :: * -> [] -> # Methods compileRec :: SumOption t f -> DContainer (SumOption t f) (DType (SumOption t f)) (DFields (SumOption t f)) #
IsDataSpec (RecordField t f) #
Associated Types type DFields (RecordField t f) :: [] # type DType (RecordField t f) :: # type DContainer (RecordField t f) :: * -> [] -> # Methods compileRec :: RecordField t f -> DContainer (RecordField t f) (DType (RecordField t f)) (DFields (RecordField t f)) #
(IsDataSpec x, IsDataSpec y, (~) * (DType x) (DType y), (~) (* -> [] -> ) (DContainer x) (DContainer y), CombinableContainer (DContainer x)) => IsDataSpec ((:&) x y) #
Associated Types type DFields ((:&) x y) :: [] # type DType ((:&) x y) :: # type DContainer ((:&) x y) :: * -> [] -> # Methods compileRec :: (x :& y) -> DContainer (x :& y) (DType (x :& y)) (DFields (x :& y)) #