{-# LANGUAGE TypeFamilies #-}
module Database.Persist.Monad.Class
( MonadSqlQuery(..)
) where
import Control.Monad.Trans.Class (lift)
import qualified Control.Monad.Trans.Except as Except
import qualified Control.Monad.Trans.Identity as Identity
import qualified Control.Monad.Trans.Maybe as Maybe
import qualified Control.Monad.Trans.RWS.Lazy as RWS.Lazy
import qualified Control.Monad.Trans.RWS.Strict as RWS.Strict
import qualified Control.Monad.Trans.Reader as Reader
import qualified Control.Monad.Trans.State.Lazy as State.Lazy
import qualified Control.Monad.Trans.State.Strict as State.Strict
import qualified Control.Monad.Trans.Writer.Lazy as Writer.Lazy
import qualified Control.Monad.Trans.Writer.Strict as Writer.Strict
import Data.Kind (Type)
import Data.Typeable (Typeable)
import Database.Persist.Monad.SqlQueryRep (SqlQueryRep)
class Monad m => MonadSqlQuery m where
type TransactionM m :: Type -> Type
runQueryRep :: Typeable record => SqlQueryRep record a -> m a
withTransaction :: TransactionM m a -> m a
instance MonadSqlQuery m => MonadSqlQuery (Reader.ReaderT r m) where
type TransactionM (Reader.ReaderT r m) = TransactionM m
runQueryRep :: SqlQueryRep record a -> ReaderT r m a
runQueryRep = m a -> ReaderT r m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ReaderT r m a)
-> (SqlQueryRep record a -> m a)
-> SqlQueryRep record a
-> ReaderT r m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SqlQueryRep record a -> m a
forall (m :: * -> *) record a.
(MonadSqlQuery m, Typeable record) =>
SqlQueryRep record a -> m a
runQueryRep
withTransaction :: TransactionM (ReaderT r m) a -> ReaderT r m a
withTransaction = m a -> ReaderT r m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ReaderT r m a)
-> (TransactionM m a -> m a) -> TransactionM m a -> ReaderT r m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TransactionM m a -> m a
forall (m :: * -> *) a. MonadSqlQuery m => TransactionM m a -> m a
withTransaction
instance MonadSqlQuery m => MonadSqlQuery (Except.ExceptT e m) where
type TransactionM (Except.ExceptT e m) = TransactionM m
runQueryRep :: SqlQueryRep record a -> ExceptT e m a
runQueryRep = m a -> ExceptT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ExceptT e m a)
-> (SqlQueryRep record a -> m a)
-> SqlQueryRep record a
-> ExceptT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SqlQueryRep record a -> m a
forall (m :: * -> *) record a.
(MonadSqlQuery m, Typeable record) =>
SqlQueryRep record a -> m a
runQueryRep
withTransaction :: TransactionM (ExceptT e m) a -> ExceptT e m a
withTransaction = m a -> ExceptT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ExceptT e m a)
-> (TransactionM m a -> m a) -> TransactionM m a -> ExceptT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TransactionM m a -> m a
forall (m :: * -> *) a. MonadSqlQuery m => TransactionM m a -> m a
withTransaction
instance MonadSqlQuery m => MonadSqlQuery (Identity.IdentityT m) where
type TransactionM (Identity.IdentityT m) = TransactionM m
runQueryRep :: SqlQueryRep record a -> IdentityT m a
runQueryRep = m a -> IdentityT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> IdentityT m a)
-> (SqlQueryRep record a -> m a)
-> SqlQueryRep record a
-> IdentityT m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SqlQueryRep record a -> m a
forall (m :: * -> *) record a.
(MonadSqlQuery m, Typeable record) =>
SqlQueryRep record a -> m a
runQueryRep
withTransaction :: TransactionM (IdentityT m) a -> IdentityT m a
withTransaction = m a -> IdentityT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> IdentityT m a)
-> (TransactionM m a -> m a) -> TransactionM m a -> IdentityT m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TransactionM m a -> m a
forall (m :: * -> *) a. MonadSqlQuery m => TransactionM m a -> m a
withTransaction
instance MonadSqlQuery m => MonadSqlQuery (Maybe.MaybeT m) where
type TransactionM (Maybe.MaybeT m) = TransactionM m
runQueryRep :: SqlQueryRep record a -> MaybeT m a
runQueryRep = m a -> MaybeT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> MaybeT m a)
-> (SqlQueryRep record a -> m a)
-> SqlQueryRep record a
-> MaybeT m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SqlQueryRep record a -> m a
forall (m :: * -> *) record a.
(MonadSqlQuery m, Typeable record) =>
SqlQueryRep record a -> m a
runQueryRep
withTransaction :: TransactionM (MaybeT m) a -> MaybeT m a
withTransaction = m a -> MaybeT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> MaybeT m a)
-> (TransactionM m a -> m a) -> TransactionM m a -> MaybeT m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TransactionM m a -> m a
forall (m :: * -> *) a. MonadSqlQuery m => TransactionM m a -> m a
withTransaction
instance (Monoid w, MonadSqlQuery m) => MonadSqlQuery (RWS.Lazy.RWST r w s m) where
type TransactionM (RWS.Lazy.RWST r w s m) = TransactionM m
runQueryRep :: SqlQueryRep record a -> RWST r w s m a
runQueryRep = m a -> RWST r w s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> RWST r w s m a)
-> (SqlQueryRep record a -> m a)
-> SqlQueryRep record a
-> RWST r w s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SqlQueryRep record a -> m a
forall (m :: * -> *) record a.
(MonadSqlQuery m, Typeable record) =>
SqlQueryRep record a -> m a
runQueryRep
withTransaction :: TransactionM (RWST r w s m) a -> RWST r w s m a
withTransaction = m a -> RWST r w s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> RWST r w s m a)
-> (TransactionM m a -> m a) -> TransactionM m a -> RWST r w s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TransactionM m a -> m a
forall (m :: * -> *) a. MonadSqlQuery m => TransactionM m a -> m a
withTransaction
instance (Monoid w, MonadSqlQuery m) => MonadSqlQuery (RWS.Strict.RWST r w s m) where
type TransactionM (RWS.Strict.RWST r w s m) = TransactionM m
runQueryRep :: SqlQueryRep record a -> RWST r w s m a
runQueryRep = m a -> RWST r w s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> RWST r w s m a)
-> (SqlQueryRep record a -> m a)
-> SqlQueryRep record a
-> RWST r w s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SqlQueryRep record a -> m a
forall (m :: * -> *) record a.
(MonadSqlQuery m, Typeable record) =>
SqlQueryRep record a -> m a
runQueryRep
withTransaction :: TransactionM (RWST r w s m) a -> RWST r w s m a
withTransaction = m a -> RWST r w s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> RWST r w s m a)
-> (TransactionM m a -> m a) -> TransactionM m a -> RWST r w s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TransactionM m a -> m a
forall (m :: * -> *) a. MonadSqlQuery m => TransactionM m a -> m a
withTransaction
instance MonadSqlQuery m => MonadSqlQuery (State.Lazy.StateT s m) where
type TransactionM (State.Lazy.StateT s m) = TransactionM m
runQueryRep :: SqlQueryRep record a -> StateT s m a
runQueryRep = m a -> StateT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> StateT s m a)
-> (SqlQueryRep record a -> m a)
-> SqlQueryRep record a
-> StateT s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SqlQueryRep record a -> m a
forall (m :: * -> *) record a.
(MonadSqlQuery m, Typeable record) =>
SqlQueryRep record a -> m a
runQueryRep
withTransaction :: TransactionM (StateT s m) a -> StateT s m a
withTransaction = m a -> StateT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> StateT s m a)
-> (TransactionM m a -> m a) -> TransactionM m a -> StateT s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TransactionM m a -> m a
forall (m :: * -> *) a. MonadSqlQuery m => TransactionM m a -> m a
withTransaction
instance MonadSqlQuery m => MonadSqlQuery (State.Strict.StateT s m) where
type TransactionM (State.Strict.StateT s m) = TransactionM m
runQueryRep :: SqlQueryRep record a -> StateT s m a
runQueryRep = m a -> StateT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> StateT s m a)
-> (SqlQueryRep record a -> m a)
-> SqlQueryRep record a
-> StateT s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SqlQueryRep record a -> m a
forall (m :: * -> *) record a.
(MonadSqlQuery m, Typeable record) =>
SqlQueryRep record a -> m a
runQueryRep
withTransaction :: TransactionM (StateT s m) a -> StateT s m a
withTransaction = m a -> StateT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> StateT s m a)
-> (TransactionM m a -> m a) -> TransactionM m a -> StateT s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TransactionM m a -> m a
forall (m :: * -> *) a. MonadSqlQuery m => TransactionM m a -> m a
withTransaction
instance (Monoid w, MonadSqlQuery m) => MonadSqlQuery (Writer.Lazy.WriterT w m) where
type TransactionM (Writer.Lazy.WriterT w m) = TransactionM m
runQueryRep :: SqlQueryRep record a -> WriterT w m a
runQueryRep = m a -> WriterT w m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> WriterT w m a)
-> (SqlQueryRep record a -> m a)
-> SqlQueryRep record a
-> WriterT w m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SqlQueryRep record a -> m a
forall (m :: * -> *) record a.
(MonadSqlQuery m, Typeable record) =>
SqlQueryRep record a -> m a
runQueryRep
withTransaction :: TransactionM (WriterT w m) a -> WriterT w m a
withTransaction = m a -> WriterT w m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> WriterT w m a)
-> (TransactionM m a -> m a) -> TransactionM m a -> WriterT w m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TransactionM m a -> m a
forall (m :: * -> *) a. MonadSqlQuery m => TransactionM m a -> m a
withTransaction
instance (Monoid w, MonadSqlQuery m) => MonadSqlQuery (Writer.Strict.WriterT w m) where
type TransactionM (Writer.Strict.WriterT w m) = TransactionM m
runQueryRep :: SqlQueryRep record a -> WriterT w m a
runQueryRep = m a -> WriterT w m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> WriterT w m a)
-> (SqlQueryRep record a -> m a)
-> SqlQueryRep record a
-> WriterT w m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SqlQueryRep record a -> m a
forall (m :: * -> *) record a.
(MonadSqlQuery m, Typeable record) =>
SqlQueryRep record a -> m a
runQueryRep
withTransaction :: TransactionM (WriterT w m) a -> WriterT w m a
withTransaction = m a -> WriterT w m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> WriterT w m a)
-> (TransactionM m a -> m a) -> TransactionM m a -> WriterT w m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TransactionM m a -> m a
forall (m :: * -> *) a. MonadSqlQuery m => TransactionM m a -> m a
withTransaction