Request for feedback: deriving strategies syntax

[Ryan Scott]

Andres,

> The objects probably shouldn't be type synonyms, but
> they could be special datatypes or type families, perhaps.

I considered that - we already have some special datatypes, type
families, and type classes currently. However, neither datatypes nor
type families are allowed to appear as the outermost type in an
instance declaration (unless we bake in a very prominent exception to
this rule), and if we imbued type classes with this magic, one might
think that "deriving (GND Eq)" means we're deriving an instance for
the magical GND class, not Eq. So those approaches don't sound
satisfying to me on a cursory examination.

Richard,

> The one idea I can suggest in this space (somewhat tongue-in-cheek, but feel free to take it seriously) is `bespoke`

It might be a tongue-in-cheek suggestion, but I _really_ like it. It
captures the intended semantics better than any other previous
suggestion, I think. And we're already going to be appropriating a new
keyword with "anyclass", so why not take "bespoke" as well? :)

Please stop me if I've slipped into madness here.

> I thought about verbosity here, and it's not clear which one is more verbose. For example, I frequently define a new newtype and then wish to use GND to derive a whole host of instances. In this case (is it common?), `deriving (X, Y) deriving newtype (A,B,C,D,E,F)` is shorter than putting newtype on each class name.

That's a good point. Another thing to consider is that I suspect in
90% of the time, users are only going to be reaching for
-XDerivingStrategies in the scenario when they enable both
-XGeneralizedNewtypeDeriving and -XDeriveAnyClass. That will happen
when they want to derive instances for newtypes, and as you said, you
typically derive several instances at a time when defining newtypes.
Therefore, it seems less noisy to factor out the deriving strategy
names so that readers can tell at a glance which batch of instances
are newtype-derived and which are anyclass-derived, instead of having
to read a keyword before every single type.

Plus, on a superficial level, I like keeping the deriving strategy
name outside of the parentheses. I think it makes clear that these
keywords aren't modifying the type we're deriving, only the means by
which we're deriving it. Of course, you may feel differently than I
do, so please speak up if you disagree!


Ryan S.