diff --git a/Algebra.hs b/Algebra.hs
--- a/Algebra.hs
+++ b/Algebra.hs
@@ -97,7 +97,7 @@
 
 instance Group b => Group (a -> b) where invert = (.) invert
 
-deriving instance Group (k b a) => Group (C.Dual k a b)
+deriving via (k b a :: *) instance Group (k b a) => Group (C.Dual k a b)
 
 instance {-# OVERLAPPABLE #-} Base.Num a => Group (Sum a) where invert (Sum a) = Sum (Base.negate a)
 instance {-# OVERLAPPABLE #-} Base.Fractional a => Group (Product a) where invert (Product a) = Product (Base.recip a)
diff --git a/Data/BitSet.hs b/Data/BitSet.hs
--- a/Data/BitSet.hs
+++ b/Data/BitSet.hs
@@ -13,7 +13,7 @@
 import Relation.Binary.Comparison
 
 newtype BitSet a = BitSet { bits :: a }
-  deriving (Base.Eq, Bits, FiniteBits, Base.Read, Base.Show)
+  deriving (Base.Eq, Bits, FiniteBits, Base.Read, Base.Show) via a
 
 instance Bits a => Preord (BitSet a) where
     BitSet x ≤ BitSet y = x .&. y == x
diff --git a/Relation/Binary/Comparison.hs b/Relation/Binary/Comparison.hs
--- a/Relation/Binary/Comparison.hs
+++ b/Relation/Binary/Comparison.hs
@@ -53,9 +53,9 @@
     Down a ≥ Down b = a ≤ b
     Down a < Down b = a > b
     Down a > Down b = a < b
-deriving instance PartialEq a => PartialEq (Down a)
+deriving via (a :: *) instance PartialEq a => PartialEq (Down a)
 instance PartialOrd a => PartialOrd (Down a) where Down a `tryCompare` Down b = tryCompare b a
-deriving instance Eq a => Eq (Down a)
+deriving via (a :: *) instance Eq a => Eq (Down a)
 instance Ord a => Ord (Down a)
 
 instance Preord () where () ≤ () = True
@@ -251,7 +251,8 @@
 instance (Eq a) => Eq (Lexical (Maybe a))
 instance (Ord a) => Ord (Lexical (Maybe a))
 
-newtype Lexical a = Lexical { unLexical :: a } deriving (PartialEq, Semigroup, Monoid, Group)
+newtype Lexical a = Lexical { unLexical :: a }
+  deriving (PartialEq, Semigroup, Monoid, Group) via a
 
 instance PartialEq a => PartialEq (Maybe a) where (≡) = (≡) `on` maybe (Left ()) Right
 instance Preord a => Preord (Maybe a) where (≤) = (≤) `on` maybe (Left ()) Right
@@ -262,11 +263,11 @@
 class (Monoid a, Abelian a, PartialOrd a) => Monus a where
     monus :: a -> a -> a
 
-deriving instance Preord (Sum Natural)
-deriving instance PartialEq (Sum Natural)
-deriving instance PartialOrd (Sum Natural)
-deriving instance Eq (Sum Natural)
-deriving instance Ord (Sum Natural)
+deriving via Natural instance Preord (Sum Natural)
+deriving via Natural instance PartialEq (Sum Natural)
+deriving via Natural instance PartialOrd (Sum Natural)
+deriving via Natural instance Eq (Sum Natural)
+deriving via Natural instance Ord (Sum Natural)
 
 instance Monus (Sum Natural) where
     0 `monus` _ = 0
@@ -280,8 +281,8 @@
 max a b | a > b = a | otherwise = b
 min a b | a < b = a | otherwise = b
 
-newtype Max a = Max { unMax :: a } deriving (Prelude.Eq, Bits, FiniteBits, Prelude.Read, Prelude.Show)
-newtype Min a = Min { unMin :: a } deriving (Prelude.Eq, Bits, FiniteBits, Prelude.Read, Prelude.Show)
+newtype Max a = Max { unMax :: a } deriving (Prelude.Eq, Bits, FiniteBits, Prelude.Read, Prelude.Show) via a
+newtype Min a = Min { unMin :: a } deriving (Prelude.Eq, Bits, FiniteBits, Prelude.Read, Prelude.Show) via a
 
 instance {-# OVERLAPPABLE #-} Ord a => Semigroup (Max a) where Max a <> Max b = Max (max a b)
 instance {-# OVERLAPPABLE #-} Ord a => Semigroup (Min a) where Min a <> Min b = Min (min a b)
diff --git a/alg.cabal b/alg.cabal
--- a/alg.cabal
+++ b/alg.cabal
@@ -1,5 +1,5 @@
 name:                alg
-version:             0.2.13.0
+version:             0.2.13.1
 synopsis:            Algebraic structures
 -- description:         
 license:             BSD3
@@ -34,5 +34,6 @@
                      , FlexibleContexts
                      , FlexibleInstances
                      , StandaloneDeriving
-                     , GeneralizedNewtypeDeriving
+                     , DerivingVia
+                     , Safe
   ghc-options:         -Wall -Wcompat -Wredundant-constraints -Wno-partial-type-signatures