Documentation

A class for defining Options for Aeson's Generic deriving support. It is generally instantiated either by specifying all Options fields, using GenericOptions, or simply be overriding a few specific fields, by giving a (type-level) list. In both cases, for the sake of explicitness and to reduce the possibility of mistakes, fields are specified in a record-like form using the '(:=)' data type.

Users may also provide their own instances for their own data types if desired, but this should not generally be necessary.

A class that knows about fields of aeson's Options.

Type-level representation of the Aeson Generic deriving Options. This representation is useful explicitly setting all options.

Specify your encoding scheme in terms of aeson's out-of-the box Generic functionality. This type is never used directly, only "coerced through". Use some of the pre-defined types supplied here for the opts phantom parameter, or define your with an instance of ToAesonOptions.

Used in FromJSON/ToJSON superclass constraints for newtypes that recursively modify the instances. A guard against the common mistake of deriving encoders in terms of such a newtype over the naked base type instead of the GenericEncoded version. This can lead to nasty runtime bugs.

This error can be disabled by wrapping your type in DisableLoopWarning. This should never be necessary to use the functionality of this package. It may be required if you, for example, combine our newtypes with another library's types for generating aeson instances.

Assert that you know what you're doing and to nullify the LoopWarning constraint family. This should not be necessary.

An encoding scheme for sums of records that are defined as distinct data types. If we have a number of record types we want to combine under a sum, a straightforward solution is to ensure that each each inner type uses a constructor tag, and then derive the sum with SumEncoding := UntaggedValue. This works fine for the happy path, but makes for very bad error messages, since it means that decoding proceeds by trying each case in sequence. Thus error messages always pertain to the last type in the sum, even when it wasn't the intended payload. This newtype improves on that solution by providing the relevant error messages, by remembering the correspondence between the constructor tag and the intended inner type/parser.

In order to work correctly, the inner types must use the TaggedObject encoding. The same tag field name and ConstructorTagModifier must be supplied to this type.

Applies snakeCase

Applies dropLowercasePrefix, dropping until the first uppercase character.

Type-level encoding for SumEncoding

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.

Field name modifier function that separates camel-case words by underscores (i.e. on capital letters). Also knows to handle a consecutive sequence of capitals as a single word.

Drop the first lowercase sequence (i.e. until isUpper returns True) from the start of a string. Used for the common idiom where fields are prefixed by the type name in all lowercase. The definition is taken from the aeson-casing package.