Data.HighJson

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.

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 will probably be more efficient than the following two options:
• The compiler can provide a default generic implementation for toJSON.

To use the second, simply add a deriving Generic clause to your datatype and declare a ToJSON instance for your datatype without giving definitions for toJSON or toEncoding.

For example, the previous example can be simplified to a more minimal instance:

{-# LANGUAGE DeriveGeneric #-}

import GHC.Generics

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

instance ToJSON Coord where
    toEncoding = genericToEncoding defaultOptions

Why do we provide an implementation for toEncoding here? The toEncoding function is a relatively new addition to this class. To allow users of older versions of this library to upgrade without having to edit all of their instances or encounter surprising incompatibilities, the default implementation of toEncoding uses toJSON. This produces correct results, but since it performs an intermediate conversion to a Value, it will be less efficient than directly emitting an Encoding. Our one-liner definition of toEncoding above bypasses the intermediate Value.

If DefaultSignatures doesn't give exactly the results you want, you can customize the generic encoding with only a tiny amount of effort, using genericToJSON and genericToEncoding with your preferred Options:

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

Methods

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:

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

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

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

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

If DefaultSignatures doesn't give exactly the results you want, you can customize the generic decoding with only a tiny amount of effort, using genericParseJSON with your preferred Options:

instance FromJSON Coord where
    parseJSON = genericParseJSON defaultOptions

Methods

parseJSON :: Value -> Parser a

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)