Allows field access and modification.

Like HasField, but allows constrainting field type.

Shortcut for multiple HasFieldOfType constraints.

A pair of field name and type.

Extract a field of a datatype replacing the value of this datatype with the extracted field.

For this and the following functions you have to specify field name which is either record name or name attached with (:!) operator.

Like toField, but leaves field named.

Extract a field of a datatype, leaving the original datatype on stack.

Like getField, but leaves field named.

Set a field of a datatype.

Apply given modifier to a datatype field.

Make up a datatype. You provide a pack of individual fields constructors.

Each element of the accepted record should be an instruction wrapped with fieldCtor function. This instruction will have access to the stack at the moment of calling construct. Instructions have to output fields of the built datatype, one per instruction; instructions order is expected to correspond to the order of fields in the datatype.

Version of construct which accepts tuple of field constructors.

Construct an object from fields on the stack.

Decompose a complex object into its fields

Lift an instruction to field constructor.

Wrap entry in constructor. Useful for sum types.

Wrap entry in single-field constructor. Useful for sum types.

Pattern match on the given sum type.

You have to provide a Rec containing case branches. To construct a case branch use /-> operator.

Like case_, accepts a tuple of clauses, which may be more convenient.

If user is experiencing problems with wierd errors about tuples while using this function, he should take look at Instances and ensure that his tuple isn't bigger than generated instances, if so, he should probably extend number of generated instances.

Unwrap a constructor with the given name. Useful for sum types.

Provides "case" arrow which works on different wrappers for clauses.

Lorentz analogy of CaseClause, it works on plain Type types.

A record is parameterized by a universe u, an interpretation f and a list of rows rs. The labels or indices of the record are given by inhabitants of the kind u; the type of values at any label r :: u is given by its interpretation f r :: *.

Infix notation for the type of a named parameter.

Infix notation for the type of an optional named parameter.

arg unwraps a named parameter with the specified name. One way to use it is to match on arguments with -XViewPatterns:

fn (arg #t -> t) (arg #f -> f) = ...

This way, the names of parameters can be inferred from the patterns: no type signature for fn is required. In case a type signature for fn is provided, the parameters must come in the same order:

fn :: "t" :! Integer -> "f" :! Integer -> ...
fn (arg #t -> t) (arg #f -> f) = ... -- ok
fn (arg #f -> f) (arg #t -> t) = ... -- does not typecheck

A variation of arg for optional arguments. Requires a default value to handle the case when the optional argument was omitted:

fn (argDef #answer 42 -> ans) = ...

In case you want to get a value wrapped in Maybe instead, use argF or ArgF.

argF is similar to arg: it unwraps a named parameter with the specified name. The difference is that the result of argF is inside an arity wrapper, which is Identity for normal parameters and Maybe for optional parameters.