A Type representing the types of expressions or values handled by Copilot Core.

Note that both arrays and structs use dependently typed features. In the former, the length of the array is part of the type. In the latter, the names of the fields are part of the type.

A typed expression, from which we can obtain the two type representations used by Copilot: Type and SimpleType.

A default implementation of typeOf that leverages Generic. In order to use this, make sure you derive a Generic instance for your data type and then define typeOf = typeOfDefault in its Typed instance.

A untyped type (no phantom type).

A simple, monomorphic representation of types that facilitates putting variables in heterogeneous lists and environments in spite of their types being different.

Return the total (nested) size of an array from its type

Return the length of an array from its type

The field of a struct, together with a representation of its type.

Transforms all the struct's fields into a list of values.

A default implementation of toValues that leverages Generic. In order to use this, make sure you derive a Generic instance for your data type and then define toValues = toValuesDefault in its Struct instance.

A field in a struct. The name of the field is a literal at the type level.

Returns the name of struct in the target language.

A default implementation of typeName that leverages Generic. In order to use this, make sure you derive a Generic instance for your data type and then define typeName = typeNameDefault in its Struct instance.

This generates a struct name that consists of the name of the original Haskell data type, but converted to snake_case.

The value of that is a product or struct, defined as a constructor with several fields.

Extract the name of a field.

Extract the name of an accessor (a function that returns a field of a struct).

Update the value of a struct field. This is only used by the Copilot interpreter.

If you do not plan to use the interpreter, you can omit an implementation of this method. If you do so, it is recommended that you derive a Generic instance for the struct data type. This is because in a future release, the default implementation of updateField (which will be picked if there is not a manually written implementation) will be changed to require a Generic instance.

In order to implement updateField, pick one of the following approaches:

• Derive a Generic instance for the struct data type and then define updateField = updateFieldDefault in the Struct instance.
• Manually implement updateField by doing the following for each Field in a struct:

1. Check that the name of the Field matches the name of the supplied Value (using sameSymbol).
2. Check that the type of the Field matches the Type of the supplied Value (using testEquality).
3. If both (1) and (2) succeed, update the corresponding struct field using a record update.

For a complete end-to-end example that demonstrates how to manually implement updateField and use it in the Copilot interpreter, see the examples/StructsUpdateField.hs example in the copilot library.

A default implementation of updateField that leverages Generic. In order to use this, make sure you derive a Generic instance for your data type and then define updateField = updateFieldDefault in its Struct instance.