TemplateHaskell helper for HTools.

As TemplateHaskell require that splices be defined in a separate module, we combine all the TemplateHaskell functionality that HTools needs in this module (except the one for unittests).

Ensure first letter is lowercase.

Used to convert type name to function prefix, e.g. in data Aa -> aaToRaw.

Ensure first letter is uppercase.

Used to convert constructor name to component

Smarter function application.

This does simply f x, except that if is id, it will skip it, in order to generate more readable code when using -ddump-splices.

Generates a data type declaration.

The type will have a fixed list of instances.

Generates a toRaw function.

This generates a simple function of the form:

 nameToRaw :: Name -> traw
 nameToRaw Cons1 = var1
 nameToRaw Cons2 = "value2"

Generates a fromRaw function.

The function generated is monadic and can fail parsing the raw value. It is of the form:

 nameFromRaw :: (Monad m) => traw -> m Name
 nameFromRaw s | s == var1       = Cons1
               | s == "value2" = Cons2
               | otherwise = fail ...

Generates a data type from a given raw format.

The format is expected to multiline. The first line contains the type name, and the rest of the lines must contain two words: the constructor name and then the string representation of the respective constructor.

The function will generate the data type declaration, and then two functions:

• nameToRaw, which converts the type to a raw type
• nameFromRaw, which (monadically) converts from a raw type to the type

Note that this is basically just a custom show/read instance, nothing else.

Creates the showJSON member of a JSON instance declaration.

This will create what is the equivalent of:

 showJSON = showJSON . nameToRaw

in an instance JSON name declaration

Creates the readJSON member of a JSON instance declaration.

This will create what is the equivalent of:

 readJSON s = case readJSON s of
                Ok s' -> nameFromRaw s'
                Error e -> Error description

in an instance JSON name declaration

Generates a JSON instance for a given type.

This assumes that the nameToRaw and nameFromRaw functions have been defined as by the declareSADT function.

Builds the generic constructor-to-string function.

This generates a simple function of the following form:

 fname (ConStructorOne {}) = trans_fun(ConStructorOne)
 fname (ConStructorTwo {}) = trans_fun(ConStructorTwo)

This builds a custom list of name/string pairs and then uses genToRaw to actually generate the function

Checks whether a given parameter is options.

This requires that it's a Maybe.

Generates the main save opcode function.

This builds a per-constructor match clause that contains the respective constructor-serialisation code.

Generates the LuxiOp data type.

This takes a Luxi operation definition and builds both the datatype and the function trnasforming the arguments to JSON. We can't use anything less generic, because the way different operations are serialized differs on both parameter- and top-level.

There are three things to be defined for each parameter:

• name
• type
• operation; this is the operation performed on the parameter before serialization

Build a parameter declaration.

This function builds two different data structures: a filled one, in which all fields are required, and a partial one, in which all fields are optional. Due to the current record syntax issues, the fields need to be named differrently for the two structures, so the partial ones get a P suffix.