Declare the dictionary type associated with a given class. The generated type is a record of class members with the following format by default (it can be customized using setDictOptions):

• The type of the record is Dict prepended to the name of the class.
• The name of the constructor is the name of the class.

• Superclass constraints are transformed into fields containing their dictionaries. The names of those fields are generated this way:

  • Alphabetic names (e.g., Show, Applicative) are prefixed with _
  • Operators (e.g., (~)) are prefixed with /
  • Tuples are converted into _Tuple2, _Tuple3, etc.
  • Multiple occurrences of the same superclass are suffixed with an index starting from 1, or with an increasing number of |s if its name is an operator.
• Methods get their own fields; their names are the names of methods prefixed with _ for alphabetic method names, or | for operators.

This behavior can be configured using setDictOptions from FCI.TH.

Set options for subsequent invocations of mkDict. This setting only affects the current module.

Returns the empty list so it can be used as a top-level slice.

Options to configure mkDict. The constructor is hidden so you have to use record update with dictOptions.

Example

setDictOptions dictOptions { autoDoc = False }

Default DictOptions. To be modified with record updates.

dictOptions
  { methodName = _
  , superclassName = _
  , typeName = _
  , constructorName = _
  , autoDoc = _
  }

Implement an instance using a dictionary. The argument must be an expression quote with an explicit signature.

Example

This declaration

instanceDict [| viaFunctor @((->) e) :: Dict (Functor (Reader e)) |]

generates the following Functor instance for a user-defined type Reader e:

instance Functor (Reader e) where
  -- Methods obtained from the fields of the dictionary (viaFunctor @((->) e)).
  fmap = _fmap (viaFunctor @(((->) e)))
  (<$) = (|<$) (viaFunctor @(((->) e)))

The following syntaxes are supported to specify the instance head:

instanceDict [| e ::                  Dict (C (T a)) |]  -- instance                  C (T a)
instanceDict [| e ::           D a => Dict (C (T a)) |]  -- instance           D a => C (T a)
instanceDict [| e :: forall a. D a => Dict (C (T a)) |]  -- instance forall a. D a => C (T a)

Variant of instanceDict with an Overlap annotation: {-# OVERLAPPABLE #-}, etc.

instanceDict_ Overlappable
instanceDict_ Overlapping
instanceDict_ Overlaps
instanceDict_ Incoherent

instanceDict and instanceDict_ as one function.

instanceDictM Nothing        = instanceDict
instanceDictM (Just overlap) = instanceDict_ overlap

Varieties of allowed instance overlap.