Provides a field wrapper type to make Generic1 work with Functor10 etc.

GHC can't derive Generic1 instances for types that apply their type parameter to a constant type (e.g. data Thing f = Thing (f Int), but it can handle the equivalent type when the application is hidden under a newtype: data Thing f = Thing (Ap10 Int f). So, by wrapping each field in this newtype and providing the appropriate instances, we can use Generics to derive instances for the whole hierarchy of Functor10 and related classes.

Note: Ap10 instances

Since Ap10 a f is a newtype over f a, it can adopt any instance that f a has, e.g. Eq (f a) => Eq (Ap10 a f). This doesn't play very nicely with inference of derived instance contexts, though: if you say deriving Eq on a type with an f type parameter with an Ap10 T f field, GHC will complain about the missing instance Eq (f T) rather than adding it to the context. However, if we can arrange for this to be expressed as a Haskell98-looking constraint of the form C f, GHC will be willing to add that to the inferred context.

We can do this by adding a new class EqAp f with the instance we really want as a superclass, and using that as the context of Ap10's Eq instance. Now when trying to solve Eq (Ap10 T f), GHC will simplify to (EqAp f, EqCtx f T). However, if we have just a catch-all instance for EqAp, GHC will simplify it further to the instance context of that instance, which would bring us back to a constraint GHC won't add to the context, forall a. Eq a => Eq (f a). We have to prevent GHC from doing that simplification, which we can achieve by overlapping it with some other instance, so that GHC can't choose the catch-all instance without knowing more about f. To avoid weird behavior from the overlap, we make an otherwise-unused type Decoy to carry the instance.

Finally, because Ap10 is poly-kinded, if we used Eq directly as the context of that quantified constraint, we'd be saying that Ap10 can only be Eq when its hidden kind parameter is Type. Instead, we generalize it to an associated type family EqCtx. This might be e.g. KnownNat for Nats, or simply nothing for phantom type parameters. I'm not yet sure how to approach the instances for other kinds -- for instance, should we provide stock ones, or expect users to write kind-level newtypes and provide their own instances?

This trickery is applied to all the instances of Ap10. In particular this means deriving (Eq, Ord, Read, Show, Default, NFData) and deriving (Portray, Diff) via Wrapped Generic T will all work.