Translation Constraint -> Type.

The underlying type family is hidden so that mkDict is the only way to extend it, maintaining invariants required by dict.

For example:

class Bar a => Foo a where
  baz :: a
  qux :: a -> b -> [(a, b)]

mkDict 'Foo

creates the following declarations:

type instance Dict (Foo a) = DictFoo a
data DictFoo a = Foo {
    _Bar :: Dict (Bar a)
  , baz  :: a
  , qux  :: forall b. a -> b -> [(a, b)]
  }

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.

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.

Reflect a constraint as a dictionary value.

You can use TypeApplications to make the constraint c explicit. Dict is injective, so c may be inferred sometimes.