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."
                 )
-

kore/src/Kore/Attribute/Axiom/Concrete.hs

@@ -43,17 +43,12 @@ import Kore.Syntax.Variable hiding
  -}
 newtype Concrete variable =
     Concrete { unConcrete :: FreeVariables variable }
-    deriving (Eq, GHC.Generic, Ord, Show, Semigroup, Monoid)
-
-instance SOP.Generic (Concrete variable)
-
-instance SOP.HasDatatypeInfo (Concrete variable)
-
-instance Debug variable => Debug (Concrete variable)
-
-instance (Debug variable, Diff variable) => Diff (Concrete variable)
-
-instance NFData variable => NFData (Concrete variable)
+    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 Default (Concrete variable) where
     def = Concrete FreeVariables.emptyFreeVariables

kore/src/Kore/Attribute/Axiom/Symbolic.hs

@@ -36,17 +36,12 @@ import Kore.Syntax.Variable
  -}
 newtype Symbolic variable =
     Symbolic { unSymbolic :: FreeVariables variable }
-    deriving (Eq, GHC.Generic, Ord, Show, Semigroup, Monoid)
-
-instance SOP.Generic (Symbolic variable)
-
-instance SOP.HasDatatypeInfo (Symbolic variable)
-
-instance Debug variable => Debug (Symbolic variable)
-
-instance (Debug variable, Diff variable) => Diff (Symbolic variable)
-
-instance NFData variable => NFData (Symbolic variable)
+    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 Default (Symbolic variable) where
     def = Symbolic FreeVariables.emptyFreeVariables

kore/src/Kore/Attribute/Axiom/Unit.hs

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

kore/src/Kore/Attribute/Comm.hs

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

kore/src/Kore/Attribute/Constructor.hs

@@ -13,6 +13,7 @@ module Kore.Attribute.Constructor
 
 import Prelude.Kore
 
+import qualified Data.Monoid as Monoid
 import qualified Generics.SOP as SOP
 import qualified GHC.Generics as GHC
 
@@ -21,27 +22,16 @@ import Kore.Debug
 
 -- | @Constructor@ represents the @constructor@ attribute for symbols.
 newtype Constructor = Constructor { isConstructor :: Bool }
-    deriving (GHC.Generic, Eq, Ord, Show)
-
-instance Semigroup Constructor where
-    (<>) (Constructor a) (Constructor b) = Constructor (a || b)
-
-instance Monoid Constructor where
-    mempty = Constructor False
+    deriving (Eq, Ord, Show)
+    deriving (GHC.Generic)
+    deriving anyclass (Hashable, NFData)
+    deriving anyclass (SOP.Generic, SOP.HasDatatypeInfo)
+    deriving anyclass (Debug, Diff)
+    deriving (Semigroup, Monoid) via Monoid.Any
 
 instance Default Constructor where
     def = mempty
 
-instance NFData Constructor
-
-instance SOP.Generic Constructor
-
-instance SOP.HasDatatypeInfo Constructor
-
-instance Debug Constructor
-
-instance Diff Constructor
-
 -- | Kore identifier representing the @constructor@ attribute symbol.
 constructorId :: Id
 constructorId = "constructor"

kore/src/Kore/Attribute/Function.hs

@@ -21,7 +21,11 @@ import Kore.Debug
 
 -- | @Function@ represents the @function@ attribute for symbols.
 newtype Function = Function { isDeclaredFunction :: Bool }
-    deriving (GHC.Generic, Eq, Ord, Show)
+    deriving (Eq, Ord, Show)
+    deriving (GHC.Generic)
+    deriving anyclass (Hashable, NFData)
+    deriving anyclass (SOP.Generic, SOP.HasDatatypeInfo)
+    deriving anyclass (Debug, Diff)
 
 instance Semigroup Function where
     (<>) (Function a) (Function b) = Function (a || b)
@@ -32,16 +36,6 @@ instance Monoid Function where
 instance Default Function where
     def = mempty
 
-instance NFData Function
-
-instance SOP.Generic Function
-
-instance SOP.HasDatatypeInfo Function
-
-instance Debug Function
-
-instance Diff Function
-
 -- | Kore identifier representing the @function@ attribute symbol.
 functionId :: Id
 functionId = "function"