Barbies.Internal

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.

The representation used for the generic computation of the AllT c t constraints. .

We use the type-families to generically compute Barbies.AllB c b. Intuitively, if b' f' occurs inside b f, then we should just add Barbies.AllB b' c to Barbies.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 Barbies.AllB b c to break the recursion. Our trick will be to use a type family to inspect Rep (b X), for an arbitrary X, and distinguish recursive usages from non-recursive ones, tagging them with different types, so we can distinguish them in the instances.

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

So, we would like to behave differently when t = t' and add () instead of Barbies.AllT t c to break the recursion. Our trick will be to use a type family to inspect Rep (t X Y), for arbitrary X and Y 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.

Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.

A Generic instance must satisfy the following laws:

from . to ≡ Prelude.id
to . from ≡ Prelude.id