acid-state 0.16.1.3 → 0.16.1.4

raw patch · 27 files changed

+73/−230 lines, 27 filesdep −hspec-discoverdep ~Win32dep ~arraydep ~basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies removed: hspec-discover

Dependency ranges changed: Win32, array, base, bytestring, cereal, containers, directory, filelock, filepath, mtl, network, template-haskell, th-expand-syns, unix

API changes (from Hackage documentation)

Files

• CHANGELOG.md +8/−0
• acid-state.cabal +46/−42
• examples/CheckpointCutsEvent.hs +1/−3
• examples/HelloDatabase.hs +0/−1
• examples/HelloWorld.hs +1/−3
• examples/HelloWorldNoTH.hs +1/−7
• examples/KeyValue.hs +0/−4
• examples/KeyValueNoTH.hs +0/−7
• examples/MonadStateConstraint.hs +1/−3
• examples/ParameterisedState.hs +0/−5
• examples/Proxy.hs +0/−4
• examples/RemoteCommon.hs +1/−3
• examples/SlowCheckpoint.hs +0/−1
• examples/StressTest.hs +0/−4
• examples/StressTestNoTH.hs +0/−6
• examples/errors/Exceptions.hs +1/−7
• examples/errors/RemoveEvent.hs +0/−3
• src/Data/Acid/Abstract.hs +0/−24
• src/Data/Acid/Common.hs +0/−4
• src/Data/Acid/Core.hs +2/−18
• src/Data/Acid/Local.hs +3/−6
• src/Data/Acid/Memory.hs +2/−3
• src/Data/Acid/Memory/Pure.hs +1/−1
• src/Data/Acid/Remote.hs +2/−7
• src/Data/Acid/TemplateHaskell.hs +2/−48
• test/Data/Acid/KeyValueStateMachine.hs +1/−2
• test/Data/Acid/TemplateHaskellSpec.hs +0/−14

@@ -1,3 +1,11 @@+0.16.1.4+=========++_Andreas Abel, 2025-08-27_++- Drop support for GHC 7+- Tested with GHC 8.2 - 9.14.1-alpha1+ 0.16.1.3 ======== 

@@ -1,5 +1,6 @@+Cabal-version:       1.18 Name:                acid-state-Version:             0.16.1.3+Version:             0.16.1.4 Synopsis:            Add ACID guarantees to any serializable Haskell data structure. Description:         Use regular Haskell data structures as your database and get stronger ACID guarantees than most RDBMS offer. Homepage:            https://github.com/acid-state/acid-state@@ -9,11 +10,14 @@ -- Copyright: Category:            Database Build-type:          Simple-Cabal-version:       >=1.10  tested-with:-  GHC == 9.6.2-  GHC == 9.4.5+  GHC == 9.14.1+  GHC == 9.12.2+  GHC == 9.10.2+  GHC == 9.8.4+  GHC == 9.6.7+  GHC == 9.4.8   GHC == 9.2.8   GHC == 9.0.2   GHC == 8.10.7@@ -21,12 +25,13 @@   GHC == 8.6.5   GHC == 8.4.4   GHC == 8.2.2-  GHC == 8.0.2-  GHC == 7.10.3-  GHC == 7.8.4+  -- cabal-3.12 cannot install dependency system-filepath any more in the GHC 8.0 environment+  -- https://github.com/haskell/cabal/issues/10379+  -- GHC == 8.0.2 -Extra-source-files:+Extra-doc-files:         CHANGELOG.md+Extra-source-files:         test-state/OldStateTest1/*.log         test-state/OldStateTest1/*.version         test-state/OldStateTest2/*.log@@ -44,40 +49,41 @@   manual: False  Library-  Exposed-Modules:     Data.Acid,-                       Data.Acid.Archive,-                       Data.Acid.Common,-                       Data.Acid.Local, Data.Acid.Memory,-                       Data.Acid.Memory.Pure, Data.Acid.Remote,-                       Data.Acid.Advanced,-                       Data.Acid.Log, Data.Acid.CRC,-                       Data.Acid.Abstract, Data.Acid.Core,+  Exposed-Modules:     Data.Acid+                       Data.Acid.Archive+                       Data.Acid.Common+                       Data.Acid.Local Data.Acid.Memory+                       Data.Acid.Memory.Pure Data.Acid.Remote+                       Data.Acid.Advanced+                       Data.Acid.Log Data.Acid.CRC+                       Data.Acid.Abstract Data.Acid.Core                        Data.Acid.TemplateHaskell                        Data.Acid.Repair -  Other-modules:       Paths_acid_state,+  Other-modules:       Paths_acid_state                        FileIO -  Build-depends:       array,-                       base >= 4.7 && < 5,-                       bytestring >= 0.10.2,-                       cereal >= 0.4.1.0,-                       containers,-                       safecopy >= 0.6 && < 0.11,-                       stm >= 2.4,-                       directory,-                       filelock,-                       filepath,-                       mtl,-                       network < 3.2,-                       network-bsd,-                       template-haskell < 2.22,-                       th-expand-syns+  -- Lower bounds taken from GHC 8.0 / LTS 7.0+  Build-depends:       array             >= 0.5.1.1+                     , base              >= 4.9        && < 5+                     , bytestring        >= 0.10.8.0+                     , cereal            >= 0.5.3.0+                     , containers        >= 0.5.7.1+                     , safecopy          >= 0.6        && < 0.11+                     , stm               >= 2.4+                     , directory         >= 1.2.6.2+                     , filelock          >= 0.1.0.1+                     , filepath          >= 1.4.1.0+                     , mtl               >= 2.2.1+                     , network           >= 2.6.3.1    && < 3.3+                     , network-bsd+                     , template-haskell  >= 2.11.0.0   && < 2.25+                     , th-expand-syns    >= 0.4.0.0    if os(windows)-     Build-depends:       Win32+     Build-depends:       Win32          >= 2.3.1.1   else-     Build-depends:       unix+     Build-depends:       unix           >= 2.7.2.0    Hs-Source-Dirs:      src/ @@ -88,13 +94,12 @@    default-language:    Haskell2010   GHC-Options:         -Wall-                       -fno-warn-dodgy-imports-                       -fno-warn-missing-signatures-                       -fno-warn-name-shadowing-                       -fno-warn-unused-do-bind-                       -fno-warn-unused-matches-  if impl(ghc >= 8.0)-    ghc-options:       -Wcompat+                       -Wcompat+                       -Wno-dodgy-imports+                       -Wno-missing-signatures+                       -Wno-name-shadowing+                       -Wno-unused-do-bind+                       -Wno-unused-matches  executable acid-state-repair   hs-source-dirs: repair@@ -113,7 +118,6 @@                      , acid-state                      , deepseq                      , hspec-                     , hspec-discover                      , mtl                      , safecopy                      , template-haskell

@@ -14,7 +14,6 @@ files should contain 10 checkpoints each.  -}-{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE TemplateHaskell    #-} {-# LANGUAGE TypeFamilies       #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-}@@ -27,7 +26,6 @@ import           Data.Acid import           Data.List            ( sort ) import           Data.SafeCopy-import           Data.Typeable import           System.Directory import           System.Environment @@ -35,7 +33,7 @@ -- The Haskell structure that we want to encapsulate  newtype Counter = Counter { unCounter :: Integer }-    deriving (Show, Typeable)+    deriving (Show)  $(deriveSafeCopy 0 'base ''Counter) 

@@ -1,4 +1,3 @@-{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE TemplateHaskell    #-} {-# LANGUAGE TypeFamilies       #-} 

@@ -1,4 +1,3 @@-{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE TemplateHaskell    #-} {-# LANGUAGE TypeFamilies       #-} @@ -8,14 +7,13 @@ import           Control.Monad.State import           Data.Acid import           Data.SafeCopy-import           Data.Typeable import           System.Environment  ------------------------------------------------------ -- The Haskell structure that we want to encapsulate  data HelloWorldState = HelloWorldState String-    deriving (Show, Typeable)+    deriving (Show)  $(deriveSafeCopy 0 'base ''HelloWorldState) 

@@ -1,4 +1,3 @@-{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TypeFamilies       #-} @@ -13,13 +12,11 @@ import           Data.SafeCopy import           System.Environment -import           Data.Typeable- ------------------------------------------------------ -- The Haskell structure that we want to encapsulate  data HelloWorldState = HelloWorldState String-    deriving (Show, Typeable)+    deriving (Show)  instance SafeCopy HelloWorldState where     putCopy (HelloWorldState state) = contain $ safePut state@@ -57,8 +54,6 @@ data WriteState = WriteState String data QueryState = QueryState --deriving instance Typeable WriteState instance SafeCopy WriteState where     putCopy (WriteState st) = contain $ safePut st     getCopy = contain $ liftM WriteState safeGet@@ -67,7 +62,6 @@     type MethodState WriteState = HelloWorldState instance UpdateEvent WriteState -deriving instance Typeable QueryState instance SafeCopy QueryState where     putCopy QueryState = contain $ return ()     getCopy = contain $ return QueryState

@@ -1,4 +1,3 @@-{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE TemplateHaskell    #-} {-# LANGUAGE TypeFamilies       #-} @@ -15,8 +14,6 @@ import           System.Exit import           System.IO -import           Data.Typeable- import qualified Data.Map             as Map  ------------------------------------------------------@@ -26,7 +23,6 @@ type Value = String  data KeyValue = KeyValue !(Map.Map Key Value)-    deriving (Typeable)  $(deriveSafeCopy 0 'base ''KeyValue) 

@@ -1,4 +1,3 @@-{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TypeFamilies       #-} @@ -15,8 +14,6 @@ import           System.Environment import           System.IO -import           Data.Typeable- import qualified Data.Map             as Map  ------------------------------------------------------@@ -26,7 +23,6 @@ type Value = String  data KeyValue = KeyValue !(Map.Map Key Value)-    deriving (Typeable)  instance SafeCopy KeyValue where     putCopy (KeyValue state) = contain $ safePut state@@ -74,8 +70,6 @@ data InsertKey = InsertKey Key Value data LookupKey = LookupKey Key --deriving instance Typeable InsertKey instance SafeCopy InsertKey where     putCopy (InsertKey key value) = contain $ safePut key >> safePut value     getCopy = contain $ InsertKey <$> safeGet <*> safeGet@@ -84,7 +78,6 @@     type MethodState InsertKey = KeyValue instance UpdateEvent InsertKey -deriving instance Typeable LookupKey instance SafeCopy LookupKey where     putCopy (LookupKey key) = contain $ safePut key     getCopy = contain $ LookupKey <$> safeGet

@@ -1,4 +1,3 @@-{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE FlexibleContexts   #-} {-# LANGUAGE TemplateHaskell    #-} {-# LANGUAGE TypeFamilies       #-}@@ -9,14 +8,13 @@ import           Control.Monad.State import           Data.Acid import           Data.SafeCopy-import           Data.Typeable import           System.Environment  ------------------------------------------------------ -- The Haskell structure that we want to encapsulate  data HelloWorldState = HelloWorldState String-    deriving (Show, Typeable)+    deriving (Show)  $(deriveSafeCopy 0 'base ''HelloWorldState) 

@@ -1,5 +1,4 @@ {-# LANGUAGE CPP #-}-{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeFamilies #-}@@ -28,10 +27,6 @@  newtype Store k = Store { store :: Map.Map k (Entry k) }     deriving (Eq, Generic)--#if __GLASGOW_HASKELL__ <= 708-deriving instance Typeable1 Store-#endif  instance (Ord k, Serialize k, SafeCopy k, Typeable k) => SafeCopy (Store k) instance (Ord k, Serialize k) => Serialize (Store k)

@@ -1,4 +1,3 @@-{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE TemplateHaskell    #-} {-# LANGUAGE TypeFamilies       #-} @@ -15,13 +14,10 @@ import           System.Environment import           System.IO -import           Data.Typeable- ------------------------------------------------------ -- The Haskell structure that we want to encapsulate  data ProxyStressState = StressState !Int-    deriving (Typeable)  $(deriveSafeCopy 0 'base ''ProxyStressState) 

@@ -1,4 +1,3 @@-{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE TemplateHaskell    #-} {-# LANGUAGE TypeFamilies       #-} @@ -8,12 +7,11 @@ import           Control.Monad.State import           Data.Acid import           Data.SafeCopy-import           Data.Typeable  ------------------------------------------------------ -- The Haskell structure that we want to encapsulate -data StressState = StressState !Int deriving (Typeable)+data StressState = StressState !Int  $(deriveSafeCopy 0 'base ''StressState) 

@@ -1,4 +1,3 @@-{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE TemplateHaskell    #-} {-# LANGUAGE TypeFamilies       #-} 

@@ -1,4 +1,3 @@-{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE TemplateHaskell    #-} {-# LANGUAGE TypeFamilies       #-} @@ -13,13 +12,10 @@ import           System.Environment import           System.IO -import           Data.Typeable- ------------------------------------------------------ -- The Haskell structure that we want to encapsulate  data StressState = StressState !Int-    deriving (Typeable)  $(deriveSafeCopy 0 'base ''StressState) 

@@ -1,4 +1,3 @@-{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TypeFamilies       #-} @@ -14,13 +13,10 @@ import           System.Environment import           System.IO -import           Data.Typeable- ------------------------------------------------------ -- The Haskell structure that we want to encapsulate  data StressState = StressState !Int-    deriving (Typeable)  instance SafeCopy StressState where     putCopy (StressState state) = contain $ safePut state@@ -66,7 +62,6 @@ data PokeState = PokeState data QueryState = QueryState -deriving instance Typeable PokeState instance SafeCopy PokeState where     putCopy PokeState = contain $ return ()     getCopy = contain $ return PokeState@@ -75,7 +70,6 @@     type MethodState PokeState = StressState instance UpdateEvent PokeState -deriving instance Typeable QueryState instance SafeCopy QueryState where     putCopy QueryState = contain $ return ()     getCopy = contain $ return QueryState

@@ -1,5 +1,4 @@ {-# LANGUAGE CPP #-}-{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE TemplateHaskell    #-} {-# LANGUAGE TypeFamilies       #-} @@ -8,17 +7,12 @@ import           Data.Acid import           Data.Acid.Local     (createCheckpointAndClose) -#if !MIN_VERSION_base(4,8,0)-import           Control.Applicative-#endif import           Control.Monad import           Control.Monad.State ( get, put ) import           Data.SafeCopy import           System.Directory import           System.Environment -import           Data.Typeable- import           Control.Exception import           Prelude             hiding (catch) @@ -26,7 +20,7 @@ -- The Haskell structure that we want to encapsulate  data MyState = MyState Integer-    deriving (Show, Typeable)+    deriving (Show)  $(deriveSafeCopy 0 'base ''MyState) 

@@ -1,4 +1,3 @@-{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE TemplateHaskell    #-} {-# LANGUAGE TypeFamilies       #-} @@ -11,8 +10,6 @@ import           System.Directory import           System.Environment import           Data.List (isSuffixOf)--import           Data.Typeable  import           Control.Exception import           Prelude             hiding (catch)

@@ -18,18 +18,10 @@ import Data.ByteString.Lazy    ( ByteString ) import Control.Monad           ( void ) import Control.Monad.Trans     ( MonadIO(liftIO) )-#if __GLASGOW_HASKELL__ >= 707 import Data.Typeable           ( Typeable, gcast, typeOf )-#else-import Data.Typeable           ( Typeable1, gcast1, typeOf1 )-#endif  data AnyState st where-#if __GLASGOW_HASKELL__ >= 707   AnyState :: Typeable sub_st => sub_st st -> AnyState st-#else-  AnyState :: Typeable1 sub_st => sub_st st -> AnyState st-#endif  -- Haddock doesn't get the types right on its own. {-| State container offering full ACID (Atomicity, Consistency, Isolation and Durability)@@ -116,14 +108,9 @@ query' :: (QueryEvent event, MonadIO m) => AcidState (EventState event) -> event -> m (EventResult event) query' acidState event = liftIO (query acidState event) -#if __GLASGOW_HASKELL__ >= 707 mkAnyState :: Typeable sub_st => sub_st st -> AnyState st-#else-mkAnyState :: Typeable1 sub_st => sub_st st -> AnyState st-#endif mkAnyState = AnyState -#if __GLASGOW_HASKELL__ >= 707 downcast :: (Typeable sub, Typeable st) => AcidState st -> sub st downcast AcidState{acidSubState = AnyState sub}   = r@@ -133,14 +120,3 @@          _ ->            error $             "Data.Acid.Abstract: Invalid subtype cast: " ++ show (typeOf sub) ++ " -> " ++ show (typeOf r)-#else-downcast :: Typeable1 sub => AcidState st -> sub st-downcast AcidState{acidSubState = AnyState sub}-  = r- where-   r = case gcast1 (Just sub) of-         Just (Just x) -> x-         _ ->-           error $-            "Data.Acid.Abstract: Invalid subtype cast: " ++ show (typeOf1 sub) ++ " -> " ++ show (typeOf1 r)-#endif

@@ -17,10 +17,6 @@ import Control.Monad import Control.Monad.State   (MonadState, get, State) import Control.Monad.Reader  (MonadReader, Reader, runReader)-#if !MIN_VERSION_base(4,8,0)-import Control.Applicative-#endif-  class IsAcidic st where     acidEvents :: [Event st]

@@ -1,4 +1,4 @@-{-# LANGUAGE CPP, GADTs, DeriveDataTypeable, TypeFamilies,+{-# LANGUAGE CPP, GADTs, TypeFamilies,              FlexibleContexts, BangPatterns,              DefaultSignatures, ScopedTypeVariables #-} -----------------------------------------------------------------------------@@ -60,17 +60,9 @@ import Data.Serialize                     ( runPutLazy, runGetLazy ) import Data.SafeCopy                      ( SafeCopy, safeGet, safePut ) -import Data.Typeable                      ( Typeable, TypeRep, typeRepTyCon, typeOf )+import Data.Typeable                      ( Typeable, TypeRep, typeRepTyCon, typeOf, tyConModule ) import Unsafe.Coerce                      ( unsafeCoerce ) -#if MIN_VERSION_base(4,5,0)-import Data.Typeable                      ( tyConModule )-#else-import Data.Typeable.Internal             ( tyConModule )-#endif--#if MIN_VERSION_base(4,4,0)- -- in base >= 4.4 the Show instance for TypeRep no longer provides a -- fully qualified name. But we have old data around that expects the -- FQN. So we will recreate the old naming system for newer versions@@ -79,14 +71,6 @@ showQualifiedTypeRep :: TypeRep -> String showQualifiedTypeRep tr = tyConModule con ++ "." ++ show tr   where con = typeRepTyCon tr--#else--showQualifiedTypeRep :: TypeRep -> String-showQualifiedTypeRep tr = show tr--#endif-  -- | Interface for (de)serialising values of type @a@. --

@@ -1,4 +1,4 @@-{-# LANGUAGE DeriveDataTypeable, BangPatterns, CPP #-}+{-# LANGUAGE BangPatterns, CPP #-} ----------------------------------------------------------------------------- -- | -- Module      :  Data.Acid.Local@@ -41,9 +41,6 @@ import Control.Exception              ( onException, evaluate, Exception, throwIO ) import Control.Monad.State            ( runState ) import Control.Monad                  ( join )-#if !MIN_VERSION_base(4,8,0)-import Control.Applicative            ( (<$>), (<*>) )-#endif import Data.ByteString.Lazy           ( ByteString ) import qualified Data.ByteString.Lazy as Lazy ( length ) @@ -76,9 +73,9 @@                  , localEvents      :: FileLog (Tagged ByteString)                  , localCheckpoints :: FileLog (Checkpoint st)                  , localLock        :: FileLock-                 } deriving (Typeable)+                 } -newtype StateIsLocked = StateIsLocked FilePath deriving (Show, Typeable)+newtype StateIsLocked = StateIsLocked FilePath deriving (Show)  instance Exception StateIsLocked 

@@ -1,4 +1,4 @@-{-# LANGUAGE DeriveDataTypeable, BangPatterns #-}+{-# LANGUAGE BangPatterns #-} ----------------------------------------------------------------------------- -- | -- Module      :  Data.Acid.Memory@@ -22,7 +22,6 @@ import Control.Concurrent             ( newEmptyMVar, putMVar, MVar ) import Control.Monad.State            ( runState ) import Data.ByteString.Lazy           ( ByteString )-import Data.Typeable                  ( Typeable ) import Data.IORef                     ( IORef, newIORef, readIORef, writeIORef )  @@ -42,7 +41,7 @@ data MemoryState st     = MemoryState { localCore    :: Core st                   , localCopy    :: IORef st-                  } deriving (Typeable)+                  }  -- | Create an 'AcidState' given an initial value.  The state is kept only in -- memory, so it is not durable.

@@ -1,4 +1,4 @@-{-# LANGUAGE DeriveDataTypeable, BangPatterns #-}+{-# LANGUAGE BangPatterns #-} ----------------------------------------------------------------------------- -- | -- Module      :  Data.Acid.Memory.Pure

@@ -1,4 +1,4 @@-{-# LANGUAGE CPP, DeriveDataTypeable, RankNTypes, RecordWildCards, ScopedTypeVariables #-}+{-# LANGUAGE CPP, RankNTypes, RecordWildCards, ScopedTypeVariables #-} ----------------------------------------------------------------------------- {- |  Module      :  Data.Acid.Remote@@ -96,9 +96,6 @@     ) where  import Prelude                                hiding ( catch )-#if !MIN_VERSION_base(4,8,0)-import Control.Applicative-#endif import Control.Concurrent.STM                        ( atomically ) import Control.Concurrent.STM.TMVar                  ( newEmptyTMVar, readTMVar, takeTMVar, tryTakeTMVar, putTMVar ) import Control.Concurrent.STM.TQueue@@ -122,7 +119,6 @@ import Data.IORef                                    ( newIORef, readIORef, writeIORef ) import Data.Serialize import Data.Set                                      ( Set, member )-import Data.Typeable                                 ( Typeable ) import GHC.IO.Exception                              ( IOErrorType(..) ) import Network.BSD                                   ( PortNumber, getProtocolNumber, getHostByName, hostAddress ) import Network.Socket@@ -150,7 +146,7 @@     | AcidStateClosed     | SerializeError String     | AuthenticationError String-      deriving (Eq, Show, Typeable)+      deriving (Eq, Show) instance Exception AcidRemoteException  -- | create a 'CommChannel' from a 'Handle'. The 'Handle' should be@@ -380,7 +376,6 @@                                 writeChan chan (return Acknowledgement)  data RemoteState st = RemoteState (Command -> IO (MVar Response)) (IO ())-                    deriving (Typeable)  {- | Connect to an acid-state server which is sharing an 'AcidState'. -} openRemoteState :: IsAcidic st =>

@@ -17,9 +17,6 @@ #if !MIN_VERSION_base(4,11,0) import Data.Monoid ((<>)) #endif-#if !MIN_VERSION_base(4,8,0)-import Control.Applicative-#endif import Control.Monad import Control.Monad.State (MonadState) import Control.Monad.Reader (MonadReader)@@ -89,22 +86,14 @@            TyConI tycon              ->case tycon of -#if MIN_VERSION_template_haskell(2,11,0)                  DataD _cxt _name tyvars _kind constructors _derivs-#else-                 DataD _cxt _name tyvars constructors _derivs-#endif #if MIN_VERSION_template_haskell(2,21,0)                    -> makeAcidic' ss eventNames stateName (map void tyvars) constructors #else                    -> makeAcidic' ss eventNames stateName tyvars constructors #endif -#if MIN_VERSION_template_haskell(2,11,0)                  NewtypeD _cxt _name tyvars _kind constructor _derivs-#else-                 NewtypeD _cxt _name tyvars constructor _derivs-#endif #if MIN_VERSION_template_haskell(2,21,0)                    -> makeAcidic' ss eventNames stateName (map void tyvars) [constructor] #else@@ -156,11 +145,7 @@ getEventType eventName     = do eventInfo <- reify eventName          case eventInfo of-#if MIN_VERSION_template_haskell(2,11,0)            VarI _name eventType _decl-#else-           VarI _name eventType _decl _fixity-#endif              -> expandSyns eventType            _ -> error $ "Data.Acid.TemplateHaskell: Events must be functions: " ++ show eventName @@ -239,12 +224,7 @@     where       -- | rename the type variables in a Pred       unify :: [(Name, Name)] -> Pred -> Pred-#if MIN_VERSION_template_haskell(2,10,0)       unify table p = rename p table p -- in 2.10.0: type Pred = Type-#else-      unify table p@(ClassP n tys) = ClassP n (map (rename p table) tys)-      unify table p@(EqualP a b)   = EqualP (rename p table a) (rename p table b)-#endif        -- | rename the type variables in a Type       rename :: Pred -> [(Name, Name)] -> Type -> Type@@ -289,12 +269,7 @@ renameState :: Type -> Type -> Cxt -> Cxt renameState tfrom tto cxt = map renamePred cxt   where-#if MIN_VERSION_template_haskell(2,10,0)     renamePred p = renameType p -- in 2.10.0: type Pred = Type-#else-    renamePred (ClassP n tys) = ClassP n (map renameType tys)-    renamePred (EqualP a b)   = EqualP (renameType a) (renameType b)-#endif     renameType n | n == tfrom = tto     renameType (AppT a b)     = AppT (renameType a) (renameType b)     renameType (SigT a k)     = SigT (renameType a) k@@ -328,18 +303,11 @@                       , pprint stateType                       ] ---data MyUpdateEvent = MyUpdateEvent Arg1 Arg2---  deriving (Typeable)+-- data MyUpdateEvent = MyUpdateEvent Arg1 Arg2 makeEventDataType :: Name -> Type -> DecQ makeEventDataType eventName eventType     = do let con = normalC eventStructName [ strictType notStrict (return arg) | arg <- args ]-#if MIN_VERSION_template_haskell(2,12,0)-             cxt = [derivClause Nothing [conT ''Typeable]]-#elif MIN_VERSION_template_haskell(2,11,0)-             cxt = mapM conT [''Typeable]-#else-             cxt = [''Typeable]-#endif+             cxt = []          case args of #if MIN_VERSION_template_haskell(2,21,0)           [_] -> newtypeD (return []) eventStructName (map (BndrReq <$) tyvars) Nothing con cxt@@ -445,7 +413,6 @@ analyseType :: Name -> Type -> TypeAnalysis analyseType eventName t = go [] [] [] t   where-#if MIN_VERSION_template_haskell(2,10,0)     getMonadReader :: Cxt -> Name -> [(Type, Type)]     getMonadReader cxt m = do        constraint@(AppT (AppT (ConT c) x) m') <- cxt@@ -457,19 +424,6 @@        constraint@(AppT (AppT (ConT c) x) m') <- cxt        guard (c == ''MonadState && m' == VarT m)        return (constraint, x)-#else-    getMonadReader :: Cxt -> Name -> [(Pred, Type)]-    getMonadReader cxt m = do-       constraint@(ClassP c [x, m']) <- cxt-       guard (c == ''MonadReader && m' == VarT m)-       return (constraint, x)--    getMonadState :: Cxt -> Name -> [(Pred, Type)]-    getMonadState cxt m = do-       constraint@(ClassP c [x, m']) <- cxt-       guard (c == ''MonadState && m' == VarT m)-       return (constraint, x)-#endif      -- a -> b     go tyvars cxt args (AppT (AppT ArrowT a) b)

@@ -17,7 +17,6 @@ import           Data.Acid.StateMachineTest import           Data.SafeCopy import qualified Data.Map as Map-import           Data.Typeable import           GHC.Generics import           Hedgehog import qualified Hedgehog.Gen as Gen@@ -28,7 +27,7 @@ type Value = String  data KeyValue = KeyValue !(Map.Map Key Value)-    deriving (Eq, Show, Typeable)+    deriving (Eq, Show)  $(deriveSafeCopy 0 'base ''KeyValue) 

@@ -11,7 +11,6 @@ import Test.Hspec hiding (context)  import Data.SafeCopy (SafeCopy)-import Data.Typeable (Typeable) import Control.DeepSeq (force) import Control.Exception (evaluate) import Language.Haskell.TH@@ -105,15 +104,10 @@                 `shouldBe` TypeAnalysis                     { tyvars = []                     , context =-#if MIN_VERSION_template_haskell(2,10,0)                         [ ConT ''MonadReader                             `AppT` ConT ''Int                             `AppT` VarT m                         ]-#else-                        [ ClassP ''MonadReader [ConT ''Int, VarT m]-                        ]-#endif                     , argumentTypes = [ConT ''Int]                     , stateType = ConT ''Int                     , resultType = VarT m `AppT` TupleT 0@@ -155,21 +149,13 @@              eventCxts stateType binders name eventType                 `shouldBe`-#if MIN_VERSION_template_haskell(2,10,0)                     [ConT ''Ord `AppT` VarT x]-#else-                    [ClassP ''Ord [VarT x]]-#endif          it "can rename a polymorphic state" $ do             eventType <- runQ [t| forall r m. (MonadReader r m, Ord r) => Int -> m Char |]             eventCxts stateType binders name eventType                 `shouldBe`-#if MIN_VERSION_template_haskell(2,10,0)                     [ConT ''Ord `AppT` ConT ''Char]-#else-                    [ClassP ''Ord [ConT ''Char]]-#endif   quoteShouldBe :: (Eq a, Show a) => Q a -> Q [a] -> Expectation