Database.RethinkDB.TH

Functions to mechanically derive ToDatum and FromDatum instances. Note that you need to enable the TemplateHaskell language extension in order to use this module.

An example shows how instances are generated for arbitrary data types. First we define a data type:

data D a = Nullary
         | Unary Int
         | Product String Char a
         | Record { testOne   :: Double
                  , testTwo   :: Bool
                  , testThree :: D a
                  } deriving Eq

Next we derive the necessary instances. Note that we make use of the feature to change record field names. In this case we drop the first 4 characters of every field name. We also modify constructor names by lower-casing them:

$(deriveDatum defaultOptions{fieldLabelModifier = drop 4, constructorTagModifier = map toLower} ''D)

Now we can use the newly created instances.

d :: D Int
d = Record { testOne = 3.14159
           , testTwo = True
           , testThree = Product "test" 'A' 123
           }

>>> fromDatum (toDatum d) == Success d
> True

Please note that you can derive instances for tuples using the following syntax:

-- FromDatum and ToDatum instances for 4-tuples.
$(deriveDatum defaultOptions ''(,,,))

Encoding configuration

data Options :: *

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

Instances

Show Options

Methods

showsPrec :: Int -> Options -> ShowS

show :: Options -> String

showList :: [Options] -> ShowS

data SumEncoding :: *

Specifies how to encode constructors of a sum datatype.

Constructors

TaggedObject

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

Fields

• tagFieldName :: String
• contentsFieldName :: String

UntaggedValue

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

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

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

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

ObjectWithSingleField

A constructor will be encoded to an object with a single field named after the constructor tag (modified by the constructorTagModifier) which maps to the encoded contents of the constructor.

TwoElemArray

A constructor will be encoded to a 2-element array where the first element is the tag of the constructor (modified by the constructorTagModifier) and the second element the encoded contents of the constructor.

Instances

Eq SumEncoding

Methods

(==) :: SumEncoding -> SumEncoding -> Bool

(/=) :: SumEncoding -> SumEncoding -> Bool

Show SumEncoding

Methods

showsPrec :: Int -> SumEncoding -> ShowS

show :: SumEncoding -> String

showList :: [SumEncoding] -> ShowS

defaultOptions :: Options

Default encoding Options:

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

defaultTaggedObject :: SumEncoding

Default TaggedObject SumEncoding options:

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

FromDatum and ToDatum derivation

deriveDatum

Arguments

:: Options

Encoding options.

-> Name

Name of the type for which to generate ToDatum and FromDatum instances.

-> Q [Dec]

Generates both ToDatum and FromDatum instance declarations for the given data type.

This is a convienience function which is equivalent to calling both deriveToDatum and deriveFromDatum.

deriveToDatum

Arguments

:: Options

Encoding options.

-> Name

Name of the type for which to generate a ToDatum instance declaration.

-> Q [Dec]

Generates a ToDatum instance declaration for the given data type.

deriveFromDatum

Arguments

:: Options

Encoding options.

-> Name

Name of the type for which to generate a FromDatum instance declaration.

-> Q [Dec]

Generates a FromDatum instance declaration for the given data type.

mkToDatum

Arguments

:: Options

Encoding options.

-> Name

Name of the type to encode.

-> Q Exp

Generates a lambda expression which encodes the given data type as Datum.

mkParseDatum

Arguments

:: Options

Encoding options.

-> Name

Name of the encoded type.

-> Q Exp

Generates a lambda expression which parses the Datum encoding of the given data type.