An old and a new library for generic deriving

I have just released generic-data, a library for metaprogramming in Haskell using GHC Generics.

One motivation was to refine the deriving technique I previously wrote about for various types such as “functor-functor”-style records, generalizing it to more classes and types while avoiding the hack using incoherent instances. This is what the result looks like now.

Among other things, generic-data has generic implementations of the type classes found in the standard library base. In that respect, it is basically a base-compatible clone of the library generic-deriving.

In this post, I want to talk about how it takes advantage of existing infrastructure in the GHC.Generics module to condense some of these generic implementations to one-liners. (Here they are, as spoilers or TL;DR.) This is what makes base a “library for generic deriving”, or more of one than it may seem at first.

Quick example: a generic Eq

Let’s say we want to derive instances of Eq with GHC Generics.

class Eq a where
  (==) :: a -> a -> Bool

A generic implementation geq would use the Generic a instance to convert (via from) the arguments of type a to a uniform representation of a type named Rep a, and then calls a function eqRep from some class GEq of representations that can be compared for equality.

geq :: (Generic a, GEq (Rep a)) => a -> a -> Bool
geq a b = eqRep (from a) (from b)

class GEq r where
  eqRep :: r p -> r p -> Bool
  -- p is a phantom parameter, for reasons not relevant to this post.

There would be instances of GEq for the “building blocks” of those representations: M1, (:+:), (:*:), K1, U1, V1. That’s all it takes to derive Eq generically, although one still needs to define GEq and write these instances.

You may have noticed that GEq looks quite like Eq, and that similarity actually extends to their instances. Indeed, we can instead directly use Eq instead to compare representations, and that’s how we get this one-liner.

-- The phantom parameter makes this implementation a bit pesky.
geq' :: forall a. (Generic a, Eq (Rep a ())) => a -> a -> Bool
geq' a b = from a == (from b :: Rep a ())

Generically equivalent instances

Some classes have what I’d call generically equivalent instances, which can be derived with GHC Generics by using instances of the same type class for the “building blocks” of generic representations: M1, (:+:), etc., as opposed to the more general approach of going through a separate “G-prefixed” class. In base, classes with generically equivalent instances include Eq, Ord, which aren’t too exciting, but also Semigroup and Monoid (for single-constructor types, i.e., products), for which there isn’t a special deriving mechanism built into GHC.

With Generic1 type constructors (which many types are not!) we can also derive in that way Eq1, Ord1, Functor, Foldable, Traversable, and for single-constructor types again, Applicative and Alternative.

As counterexamples, classes which do not have structurally generic instances include Read, Show, Enum, and Bounded, because they depend on information that needs more work to recover from the generic representations (number, names, arities of constructors).

However, Semigroup and Monoid instances are currently missing in the GHC.Generics module. Another idea to work around that was that Applicative also defines monoids if you ignore the phantom parameter. But there is again a crucially missing Applicative instance for K1. In fact, I’ve just submitted these instances to base, so that won’t be a problem in a few months. There are also missing Eq1 and Ord1 instances, although I haven’t gotten around to implement them in base, and they are going to become much less useful once GHC has quantified constraints anyway. generic-data provides those missing instances as orphans.

Other implementations

Other implementations of standard type classes can be found in various places, but you have to know where to look.

• semigroups defines generic Semigroup and Monoid via GSemigroup and GMonoid type classes.

• transformers-compat defines generic Eq1, Ord1, Read1 and Show1 also via separate G-prefixed classes, and I’ve shown they are unnecessary for the former two. This implementation is arguably impossible to find if you don’t know it’s there.

• one-liner-instances defines generic instances for many classes (Semigroup, Monoid, and numeric ones like Num) using a single class from its parent one-liner (that’s a whole other story). It is a more general approach than generically equivalent instances, but also requires more dependencies.

It’s definitely not necessary to depend on generic-data to derive generically equivalent instances; it may take less effort to just copy the one-liners you need from it. However, generic-data will make it possible to tweak the generic instances so they can be adapted to fancier types, bringing us ever closer to fully superseding the ad-hoc deriving strategies in GHC with generic deriving.