Documentation

A class for defining Options for Aeson's Generic deriving support. It is generally instantiated by overriding specific fields using the instance for (type-level) list values. It can also be instantiated in a more exhaustive way using the GenericOptions type. In both cases fields are specified in a record-like form using the '(:=)' data type for explicitness.

See the ReadMe or tests for examples.

Users may also provide instances for their own phantom data types if desired.

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

Represents an aeson Options field to be set with `(:=)`. See ToAesonOptions

Represents an aeson Options field to be set with `(:=)`. See ToAesonOptions

Represents an aeson Options field to be set with `(:=)`. See ToAesonOptions

Represents an aeson Options field to be set with `(:=)`. See ToAesonOptions

Represents an aeson Options field to be set with `(:=)`. See ToAesonOptions

Represents an aeson Options field to be set with `(:=)`. See ToAesonOptions

Type-level representation of the Aeson Generic deriving Options. This representation is useful for 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.