JSON encoder/decoder configuration

Constructor tag

For a datatype with a single constructor we do not need to tag values with their constructor; but for a datatype with multiple constructors we do.

For some values we can support "updating" the value with a "partial" JSON value; record types are the prime example (and the only one supported by the generic function). For non-record types we typically can only replace the value with a "complete" JSON value; in this case, we simply ignore the old value (see replaceWithJSON). Typical class instances will look like

instance UpdateFromJSON SomeRecordType where
   updateFromJSON = gupdateFromJSON <jsonOptions>

or

instance UpdateFromJSON SomeNonRecordType where
   updateFromJSON = replaceWithJSON

NOTE: The generic function uses one-level lenses for the object fields. We could generalize this to arbitrary paths, but then the type would change to

updateFromJSON :: Value -> Parser (a -> UpdateM a)

I.e., updating a value from JSON would, in general, involve a database write.

Construct a function that updates a value of some record type, given a JSON object with new values for some (or none, or all) of the fields

For types that we can only replace "whole", rather than update field by field

Conversely, for types that we can only parse if we have a starting point

A type that can be converted to JSON.

An example type and instance:

@{-# LANGUAGE OverloadedStrings #-}

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

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

Note the use of the OverloadedStrings language extension which enables Text values to be written as string literals.

Instead of manually writing your ToJSON instance, there are three 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:
• Data.Aeson.Generic provides a generic toJSON function that accepts any type which is an instance of Data.
• If your compiler has support for the DeriveGeneric and DefaultSignatures language extensions (GHC 7.2 and newer), toJSON will have a default generic implementation.

To use the latter option, simply add a deriving Generic clause to your datatype and declare a ToJSON instance for your datatype without giving a definition for toJSON.

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 ToJSON Coord @

Note that, instead of using DefaultSignatures, it's also possible to parameterize the generic encoding using genericToJSON applied to your encoding/decoding Options:

instance ToJSON Coord where
    toJSON = genericToJSON defaultOptions

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

When writing an instance, use empty, mzero, or fail to make a conversion fail, e.g. if an Object is missing a required key, or the value is of the wrong type.

An example type and instance:

@{-# LANGUAGE OverloadedStrings #-}

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

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

-- A non-Object value is of the wrong type, so use mzero to fail. parseJSON _ = mzero @

Note the use of the OverloadedStrings language extension which enables Text values to be written as string literals.

Instead of manually writing your FromJSON instance, there are three 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:
• Data.Aeson.Generic provides a generic fromJSON function that parses to any type which is an instance of Data.
• If your compiler has support for the DeriveGeneric and DefaultSignatures language extensions, parseJSON will have a default generic implementation.

To use this, 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 @

Note that, instead of using DefaultSignatures, it's also possible to parameterize the generic decoding using genericParseJSON applied to your encoding/decoding Options:

instance FromJSON Coord where
    parseJSON = genericParseJSON defaultOptions

A concrete, poly-kinded proxy type