Documentation

Helper function for generating a list of instances for a list of named signatures. For example, in order to derive instances Functor and ShowF for a signature Exp, use derive as follows (requires Template Haskell):

 $(derive [makeFunctor, makeShowF] [''Exp])

Signature printing. An instance ShowF f gives rise to an instance Show (Term f).

Derive an instance of ShowF for a type constructor of any first-order kind taking at least one argument.

Signature equality. An instance EqF f gives rise to an instance Eq (Term f).

Derive an instance of EqF for a type constructor of any first-order kind taking at least one argument.

Signature ordering. An instance OrdF f gives rise to an instance Ord (Term f).

Derive an instance of OrdF for a type constructor of any first-order kind taking at least one argument.

The Functor class is used for types that can be mapped over. Instances of Functor should satisfy the following laws:

 fmap id  ==  id
 fmap (f . g)  ==  fmap f . fmap g

The instances of Functor for lists, Data.Maybe.Maybe and System.IO.IO satisfy these laws.

Derive an instance of Functor for a type constructor of any first-order kind taking at least one argument.

Data structures that can be folded.

Minimal complete definition: foldMap or foldr.

For example, given a data type

 data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

 instance Foldable Tree where
    foldMap f Empty = mempty
    foldMap f (Leaf x) = f x
    foldMap f (Node l k r) = foldMap f l `mappend` f k `mappend` foldMap f r

This is suitable even for abstract types, as the monoid is assumed to satisfy the monoid laws. Alternatively, one could define foldr:

 instance Foldable Tree where
    foldr f z Empty = z
    foldr f z (Leaf x) = f x z
    foldr f z (Node l k r) = foldr f (f k (foldr f z r)) l

Derive an instance of Foldable for a type constructor of any first-order kind taking at least one argument.

Functors representing data structures that can be traversed from left to right.

Minimal complete definition: traverse or sequenceA.

Instances are similar to Functor, e.g. given a data type

 data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

 instance Traversable Tree where
    traverse f Empty = pure Empty
    traverse f (Leaf x) = Leaf <$> f x
    traverse f (Node l k r) = Node <$> traverse f l <*> f k <*> traverse f r

This is suitable even for abstract types, as the laws for <*> imply a form of associativity.

The superclass instances should satisfy the following:

• In the Functor instance, fmap should be equivalent to traversal with the identity applicative functor (fmapDefault).
• In the Foldable instance, Data.Foldable.foldMap should be equivalent to traversal with a constant applicative functor (foldMapDefault).

Derive an instance of Traversable for a type constructor of any first-order kind taking at least one argument.

Derive an instance of HaskellStrict for a type constructor of any first-order kind taking at least one argument.

Signature arbitration. An instance ArbitraryF f gives rise to an instance Arbitrary (Term f).

Derive an instance of ArbitraryF for a type constructor of any first-order kind taking at least one argument. It is necessary that all types that are used by the data type definition are themselves instances of Arbitrary.

Random generation and shrinking of values.

Derive an instance of Arbitrary for a type constructor.

A class of types that can be fully evaluated.

Derive an instance of NFData for a type constructor.

Signature normal form. An instance NFDataF f gives rise to an instance NFData (Term f).

Derive an instance of NFDataF for a type constructor of any first-order kind taking at least one argument.

Derive smart constructors for a type constructor of any first-order kind taking at least one argument. The smart constructors are similar to the ordinary constructors, but an inject is automatically inserted.

Derive smart constructors with products for a type constructor of any parametric kind taking at least one argument. The smart constructors are similar to the ordinary constructors, but an injectA is automatically inserted.

Given the name of a type class, where the first parameter is a functor, lift it to sums of functors. Example: class ShowF f where ... is lifted as instance (ShowF f, ShowF g) => ShowF (f :+: g) where ... .

Utility function to case on a functor sum, without exposing the internal representation of sums.