Use DeriveAnyClass (#2162)

* Enable DeriveAnyClass

* Use `deriving anyclass`

* stylish-haskell.yaml: language_extensions: DeriveAnyClass

Author: ttuegel

.stylish-haskell.yaml

@@ -238,6 +238,7 @@ language_extensions:
   - ConstraintKinds
   - DataKinds
   - DefaultSignatures
+  - DeriveAnyClass
   - DeriveDataTypeable
   - DeriveFoldable
   - DeriveFunctor

kore/package.yaml

@@ -103,6 +103,7 @@ default-extensions:
   - ConstraintKinds
   - DataKinds
   - DefaultSignatures
+  - DeriveAnyClass
   - DeriveDataTypeable
   - DeriveFoldable
   - DeriveFunctor

kore/src/Control/Monad/Counter.hs

@@ -58,14 +58,14 @@ type Counter = CounterT Monad.Identity.Identity
  -}
 newtype CounterT m a =
     CounterT { getCounterT :: Monad.State.Strict.StateT Natural m a }
-    deriving (Alternative, Applicative, Functor, Monad, MonadPlus, MonadTrans)
+    deriving newtype (Functor, Applicative, Monad)
+    deriving newtype (Alternative, MonadPlus)
+    deriving newtype (MonadTrans, MonadState Natural)
 
 instance Monad m => MonadCounter (CounterT m) where
     increment = CounterT incrementState
     {-# INLINE increment #-}
 
-deriving instance Monad m => MonadState Natural (CounterT m)
-
 instance MonadIO m => MonadIO (CounterT m) where
     liftIO = CounterT . liftIO
     {-# INLINE liftIO #-}

kore/src/Data/Sup.hs

@@ -34,7 +34,12 @@ If @a@ already has a least upper bound, 'Sup' is greater than that bound.
 data Sup a
     = Element !a
     | Sup  -- ^ least upper bound (supremum)
-    deriving (Data, Functor, GHC.Generic, Read, Show, Typeable)
+    deriving (Read, Show)
+    deriving (Data, Typeable)
+    deriving (Functor)
+    deriving (GHC.Generic)
+    deriving anyclass (Hashable, NFData)
+    deriving anyclass (SOP.Generic, SOP.HasDatatypeInfo)
 
 instance Eq a => Eq (Sup a) where
     (==) Sup         = \case { Sup       -> True  ; _ -> False }
@@ -44,14 +49,6 @@ instance Ord a => Ord (Sup a) where
     compare Sup         = \case { Sup       -> EQ         ; _   -> GT }
     compare (Element a) = \case { Element b -> compare a b; Sup -> LT }
 
-instance Hashable a => Hashable (Sup a)
-
-instance NFData a => NFData (Sup a)
-
-instance SOP.Generic (Sup a)
-
-instance SOP.HasDatatypeInfo (Sup a)
-
 -- | 'Sup' is the annihilator of 'Element'.
 instance Ord a => Semigroup (Sup a) where
     (<>) a b = max <$> a <*> b

kore/src/Debug.hs

@@ -377,14 +377,8 @@ only requires some instances to be derived:
 
 > data DataType = ...
 >     deriving (GHC.Generics.Generic)
->
-> instance Generics.SOP.Generic DataType
->
-> instance Generics.SOP.HasDatatypeInfo DataType
->
-> instance Debug DataType
->
-> instance Diff DataType
+>     deriving anyclass (SOP.Generic, SOP.HasDatatypeInfo)
+>     deriving anyclass (Debug, Diff)
 
  -}
 class Diff a where

kore/src/Kore/ASTVerifier/PatternVerifier/PatternVerifier.hs

@@ -75,7 +75,7 @@ newtype DeclaredVariables =
                     (SomeVariableName VariableName)
                     (SomeVariable VariableName)
         }
-    deriving (Monoid, Semigroup)
+    deriving newtype (Monoid, Semigroup)
 
 emptyDeclaredVariables :: DeclaredVariables
 emptyDeclaredVariables = mempty
@@ -131,11 +131,11 @@ verifiedModuleContext verifiedModule =
 newtype PatternVerifier a =
     PatternVerifier
         { getPatternVerifier :: ReaderT Context (Either (Error VerifyError)) a }
-    deriving (Applicative, Functor, Monad)
+    deriving newtype (Applicative, Functor, Monad)
+    deriving newtype (MonadReader Context)
 
-deriving instance MonadReader Context PatternVerifier
-
-deriving instance e ~ VerifyError => MonadError (Error e) PatternVerifier
+deriving newtype
+    instance e ~ VerifyError => MonadError (Error e) PatternVerifier
 
 runPatternVerifier
     :: Context

kore/src/Kore/ASTVerifier/Verifier.hs

@@ -78,13 +78,13 @@ newtype Verifier a =
             ::  RWST VerifierContext () VerifierState
                     (Either (Error VerifyError)) a
         }
-    deriving (Functor, Applicative, Monad)
+    deriving newtype (Functor, Applicative, Monad)
 
-deriving instance MonadReader VerifierContext Verifier
+deriving newtype instance MonadReader VerifierContext Verifier
 
-deriving instance MonadState VerifierState Verifier
+deriving newtype instance MonadState VerifierState Verifier
 
-deriving instance MonadError (Error VerifyError) Verifier
+deriving newtype instance MonadError (Error VerifyError) Verifier
 
 runVerifier
     :: Verifier a

kore/src/Kore/Attribute/Assoc.hs

@@ -22,17 +22,11 @@ import Kore.Debug
 {- | @Assoc@ represents the @assoc@ attribute for axioms.
  -}
 newtype Assoc = Assoc { isAssoc :: Bool }
-    deriving (Eq, GHC.Generic, Ord, Show)
-
-instance SOP.Generic Assoc
-
-instance SOP.HasDatatypeInfo Assoc
-
-instance Debug Assoc
-
-instance Diff Assoc
-
-instance NFData Assoc
+    deriving (Eq, Ord, Show)
+    deriving (GHC.Generic)
+    deriving anyclass (Hashable, NFData)
+    deriving anyclass (SOP.Generic, SOP.HasDatatypeInfo)
+    deriving anyclass (Debug, Diff)
 
 instance Default Assoc where
     def = Assoc False

kore/src/Kore/Attribute/Attributes.hs

@@ -81,23 +81,12 @@ It is parameterized by the types of Patterns, @pat@.
 
 newtype Attributes =
     Attributes { getAttributes :: [AttributePattern] }
-    deriving (Eq, Ord, GHC.Generic, Show)
-
-instance Hashable Attributes
-
-instance NFData Attributes
-
-instance SOP.Generic Attributes
-
-instance SOP.HasDatatypeInfo Attributes
-
-instance Debug Attributes
-
-instance Diff Attributes
-
-deriving instance Semigroup Attributes
-
-deriving instance Monoid Attributes
+    deriving (Eq, Ord, Show)
+    deriving (GHC.Generic)
+    deriving anyclass (Hashable, NFData)
+    deriving anyclass (SOP.Generic, SOP.HasDatatypeInfo)
+    deriving anyclass (Debug, Diff)
+    deriving newtype (Semigroup, Monoid)
 
 instance Unparse Attributes where
     unparse = attributes . getAttributes

kore/src/Kore/Attribute/Axiom.hs

@@ -139,19 +139,11 @@ data Axiom symbol variable =
     , owise :: !Owise
     -- ^ This is an owise evaluation rule.
     }
-    deriving (Eq, GHC.Generic, Ord, Show)
-
-instance SOP.Generic (Axiom symbol variable)
-
-instance SOP.HasDatatypeInfo (Axiom symbol variable)
-
-instance (Debug symbol, Debug variable) => Debug (Axiom symbol variable)
-
-instance
-    (Debug symbol, Debug variable, Diff symbol, Diff variable)
-    => Diff (Axiom symbol variable)
-
-instance (NFData symbol, NFData variable) => NFData (Axiom symbol variable)
+    deriving (Eq, Ord, Show)
+    deriving (GHC.Generic)
+    deriving anyclass (NFData)
+    deriving anyclass (SOP.Generic, SOP.HasDatatypeInfo)
+    deriving anyclass (Debug, Diff)
 
 instance Default (Axiom symbol variable) where
     def =
@@ -330,4 +322,3 @@ getPriorityOfAxiom
                 <> show errorCase
                 <> " Please report this error."
                 )
-