Default implementation of bmap based on Generic.

CanDeriveFunctorB B f g is in practice a predicate about B only. Intuitively, it says that the following holds, for any arbitrary f:

• There is an instance of Generic (B f).
• B f can contain fields of type b f as long as there exists a FunctorB b instance. In particular, recursive usages of B f are allowed.
• B f can also contain usages of b f under a Functor h. For example, one could use Maybe (B f) when defining B f.

CanDeriveFunctorT T f g x is in practice a predicate about T only. Intuitively, it says that the following holds, for any arbitrary f:

• There is an instance of Generic (T f).
• T f x can contain fields of type t f y as long as there exists a FunctorT t instance. In particular, recursive usages of T f y are allowed.
• T f x can also contain usages of t f y under a Functor h. For example, one could use Maybe (T f y) when defining T f y.

Default implementation of btraverse based on Generic.

CanDeriveTraversableB B f g is in practice a predicate about B only. It is analogous to CanDeriveFunctorB, so it essentially requires the following to hold, for any arbitrary f:

• There is an instance of Generic (B f).
• B f can contain fields of type b f as long as there exists a TraversableB b instance. In particular, recursive usages of B f are allowed.
• B f can also contain usages of b f under a Traversable h. For example, one could use Maybe (B f) when defining B f.

CanDeriveTraversableT T f g x is in practice a predicate about T only. It is analogous to CanDeriveFunctorT, so it essentially requires the following to hold, for any arbitrary f:

• There is an instance of Generic (T f x).
• T f x can contain fields of type t f x as long as there exists a TraversableT t instance. In particular, recursive usages of T f x are allowed.
• T f x can also contain usages of t f x under a Traversable h. For example, one could use Maybe (T f x) when defining T f x.

Default implementation of bdistribute based on Generic.

CanDeriveDistributiveB B f g is in practice a predicate about B only. Intuitively, it says the the following holds for any arbitrary f:

• There is an instance of Generic (B f).
• (B f) has only one constructor, and doesn't contain "naked" fields (that is, not covered by f).
• B f can contain fields of type b f as long as there exists a DistributiveB b instance. In particular, recursive usages of B f are allowed.
• B f can also contain usages of b f under a Distributive h. For example, one could use a -> (B f) as a field of B f.

CanDeriveDistributiveT T f g x is in practice a predicate about T only. Intuitively, it says the the following holds for any arbitrary f:

• There is an instance of Generic (B f x).
• (B f x) has only one constructor, and doesn't contain "naked" fields (that is, not covered by f). In particular, x needs to occur under f.
• B f x can contain fields of type b f y as long as there exists a DistributiveT b instance. In particular, recursive usages of B f x are allowed.
• B f x can also contain usages of b f y under a Distributive h. For example, one could use a -> (B f x) as a field of B f x.

Default implementation of bprod based on Generic.

CanDeriveApplicativeB B f g is in practice a predicate about B only. Intuitively, it says that the following holds, for any arbitrary f:

• There is an instance of Generic (B f).
• B has only one constructor (that is, it is not a sum-type).
• Every field of B f is either a monoid, or of the form f a, for some type a.

CanDeriveApplicativeT T f g x is in practice a predicate about T only. Intuitively, it says that the following holds, for any arbitrary f:

• There is an instance of Generic (T f).
• T has only one constructor (that is, it is not a sum-type).
• Every field of T f x is either a monoid, or of the form f a, for some type a.

Default implementation of baddDicts based on Generic.

CanDeriveConstraintsB B f g is in practice a predicate about B only. Intuitively, it says that the following holds, for any arbitrary f:

• There is an instance of Generic (B f).
• B f can contain fields of type b f as long as there exists a ConstraintsB b instance. In particular, recursive usages of B f are allowed.

CanDeriveConstraintsT T f g x is in practice a predicate about T only. Intuitively, it says that the following holds, for any arbitrary f and x:

• There is an instance of Generic (T f x).
• T f can contain fields of type t f x as long as there exists a ConstraintsT t instance. In particular, recursive usages of T f x are allowed.

The representation used for the generic computation of the AllB c b constraints. Here X is an arbitrary constant since the actual argument to b is irrelevant.

The representation used for the generic computation of the AllT c t constraints. Here X and Y are arbitrary constants since the actual argument to t is irrelevant.

We use the type-families to generically compute AllB c b. Intuitively, if b' f occurs inside b f, then we should just add AllB b' c to AllB b c. The problem is that if b is a recursive type, and b' is b, then ghc will choke and blow the stack (instead of computing a fixpoint).

So, we would like to behave differently when b = b' and add () instead of AllB b f to break the recursion. Our trick will be to use a type family to inspect RepN (b f) and distinguish recursive usages from non-recursive ones, tagging them with different types, so we can distinguish them in the instances.

Default implementation of bstrip based on Generic.

Default implementation of bstrip based on Generic.

All types that admit a generic FunctorB instance, and have all their occurrences of f under a Wear admit a generic BareB instance.