Using DerivingVia to Reuse Typeclass Instances in Haskell

Why DerivingVia matters

DerivingVia lets you obtain instances for a newtype by reusing the instances of another type that is representationally equal (coercible). This avoids writing boilerplate instance definitions when the newtype merely wraps an existing type.

Worked example: MinInt via Min

{-# LANGUAGE DerivingVia #-}
import Data.Semigroup (Semigroup(..), Min(..))
import Data.Monoid (Monoid(..))

newtype MinInt = MinInt Int
  deriving (Semigroup, Monoid) via (Min Int)

-- Example usage
example :: MinInt
example = MinInt 3 <> MinInt 4  -- uses Semigroup of Min Int

The derived Semigroup instance for MinInt forwards to the Min Int instance, so example evaluates to MinInt (Min 4). You can confirm this with getMin:

getMin (getMin example)  -- yields 4

Requirements and limits

• GHC version 8.6 or later.
• Enable the extension with {-# LANGUAGE DerivingVia #-} or the flag -XDerivingVia.
• The newtype must be representationally equal to the via‑type (i.e., Coercible newtype via-type holds).
• Only types that already have the desired instances for the via‑type can be derived; otherwise you get a missing‑instance error.
• DerivingVia does not work for GADTs, data types with multiple constructors, or types whose runtime representation differs from the via‑type.

Common mistakes

• Forgetting to enable the extension – the compiler will reject the via clause.
• Applying DerivingVia to a regular data type with several constructors; the coercibility check fails.
• Choosing a via‑type that lacks the needed class instance (e.g., trying to derive Show via a type without a Show instance).
• Assuming the derived instance behaves exactly like the wrapper type’s instance when the via‑type uses a different semantic (e.g., using Max instead of Min when you need the opposite ordering).

How to verify it works

1. Check GHC version: run ghc --version and ensure it is 8.6 or newer.
2. Compile the module with the extension enabled (via the pragma or Cabal/stack flag).
3. Load the module in GHCi and evaluate an expression that uses the derived class, e.g. let x = MinInt 3 <> MinInt 4 then getMin (getMin x) should return 4.