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.

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.

Default implementation of bprod based on Generic.

CanDeriveProductB 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 of the form f a, for some type a. In other words, B has no "hidden" structure.

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.

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.

We use 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 bproof based on Generic.

Every type that admits a generic instance of ProductB and ConstraintsB, has a generic instance of ProductBC as well.

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.