Deriving Strategies in Haskell

A deriving clause in Haskell can mean four different things, and for most of the language's history there was no way to say which one you meant. Deriving strategies make the choice explicit. This is what each one generates and when it is the right answer.

Haskell 98 had one kind of deriving, for a fixed list of classes the compiler knew how to write instances for: Eq, Ord, Show, and a handful more. GeneralizedNewtypeDeriving arrived to let a newtype borrow its underlying type's instances. DeriveAnyClass arrived to generate an empty instance so a class's default methods apply. Both attach to the same deriving keyword, so once both were enabled the meaning of a clause depended on a resolution order most people could not recite. DerivingStrategies (GHC 8.2) added the keywords to disambiguate, and DerivingVia (GHC 8.6) added a fourth strategy that generalizes the newtype one.

{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DerivingVia #-}

ghc-options: -Wmissing-deriving-strategies

The compiler writes the instance itself, using knowledge built into GHC about that specific class. This is the Haskell 98 behaviour, plus the classes unlocked by the Derive* extensions: Functor, Foldable, Traversable, Generic, Data, Lift.

data Config = Config
  { host :: String
  , port :: Int
  }
  deriving stock (Eq, Show, Generic)

ghci> show (Config "localhost" 8080)
Config {host = "localhost", port = 8080}

The list is fixed. You cannot derive stock for a class of your own, no matter how mechanical the instance would be. That restriction is what the other three strategies exist to work around.

A newtype has the same runtime representation as the type it wraps, so any instance the underlying type has can be reused by coercion, at no cost. This is the strategy for wrappers that exist to add type safety rather than behaviour.

newtype UserId = UserId Int
  deriving newtype (Eq, Ord, Num, Hashable)

newtype UserId = UserId Int deriving stock   (Show)
UserId 42
 
newtype UserId = UserId Int deriving newtype (Show)
42

newtype Meters = Meters Double
  deriving stock   (Show)
  deriving newtype (Eq, Ord, Num, Fractional)

The limit is coercibility. GHC has to be able to convert between the class's methods at the two types, which fails when the type variable appears somewhere the role system will not allow, such as inside a type family or a Data.Set whose ordering would change.

Generates an empty instance body, so every method falls back to the class's default implementation. This is only useful for classes whose defaults actually do something, which in practice means classes with Generic-based defaults.

data Config = Config
  { host :: String
  , port :: Int
  }
  deriving stock    (Generic)
  deriving anyclass (ToJSON, FromJSON)

instance ToJSON Config
instance FromJSON Config

newtype UserId = UserId Int
  deriving anyclass (Eq)   -- compiles, then loops forever

Nothing warns you about that, because an empty instance is exactly what you asked for. The rule worth keeping: reach for anyclass only when you know the class has defaults that stand on their own, and never for a class that also appears in the stock list.

The newtype strategy coerces through the type immediately underneath. via lets you name any type with the same representation and borrow its instance instead. That turns "which behaviour do I want" into a type you write down, rather than a hand-written instance.

newtype Score = Score Int
  deriving stock (Show, Eq)
  deriving (Semigroup, Monoid) via (Sum Int)
 
newtype HighScore = HighScore Int
  deriving stock (Show, Eq)
  deriving (Semigroup, Monoid) via (Max Int)

ghci> foldMap Score [1, 2, 3]
Score 6
ghci> foldMap HighScore [1, 2, 3]
HighScore 3

data User = User
  { userName  :: String
  , userEmail :: String
  }
  deriving stock (Generic)
  deriving (ToJSON, FromJSON)
    via CustomJSON
           '[ FieldLabelModifier (StripPrefix "user", CamelToSnake) ]
           User

ghci> encode (User "ada" "ada@example.com")
{"name":"ada","email":"ada@example.com"}

newtype AsMillis a = AsMillis a
 
instance ToJSON (AsMillis NominalDiffTime) where
  toJSON (AsMillis t) = toJSON (round (t * 1000) :: Int)
 
newtype Timeout = Timeout NominalDiffTime
  deriving ToJSON via (AsMillis NominalDiffTime)

A strategy can also be applied in a standalone clause, away from the data declaration. You need this when the instance requires a context the inline form cannot express, when the type is defined in another module, or when the via type needs to mention a type variable.

deriving stock    instance Show a => Show (Tree a)
deriving newtype  instance Num Meters
deriving anyclass instance ToJSON Config

data Rose a = Rose a [Rose a]
 
deriving stock instance Eq a  => Eq (Rose a)
deriving stock instance Ord a => Ord (Rose a)

Is it Eq/Ord/Show/Read/Enum/Bounded/Ix/Functor/
Foldable/Traversable/Generic/Data/Lift?
  -> stock
 
Is it a newtype that should behave exactly like its
underlying type?
  -> newtype
 
Do you want behaviour that some other type already has,
or that you can name in a type?
  -> via
 
Does the class have Generic-based defaults that are
complete on their own?
  -> anyclass

$ ghc -ddump-deriv -dsuppress-all Config.hs

The short version: turn on -Wmissing-deriving-strategies, write the keyword every time, use newtype for wrappers that should disappear at runtime, via when the behaviour you want already exists somewhere with a name, and anyclass only for classes whose defaults are the real implementation.