{-# LANGUAGE CPP #-}
module Database.PostgreSQL.PQTypes.Internal.Monad (
    DBT_(..)
  , DBT
  , runDBT
  , mapDBT
  ) where

import Control.Applicative
import Control.Concurrent.MVar
import Control.Monad.Base
import Control.Monad.Catch
import Control.Monad.Error.Class
import Control.Monad.Reader.Class
import Control.Monad.State.Strict
import Control.Monad.Trans.Control
import Control.Monad.Writer.Class
import qualified Control.Monad.Trans.State.Strict as S
import qualified Control.Monad.Fail as MF

import Database.PostgreSQL.PQTypes.Class
import Database.PostgreSQL.PQTypes.Internal.Connection
import Database.PostgreSQL.PQTypes.Internal.Error
import Database.PostgreSQL.PQTypes.Internal.Notification
import Database.PostgreSQL.PQTypes.Internal.Query
import Database.PostgreSQL.PQTypes.Internal.State
import Database.PostgreSQL.PQTypes.SQL
import Database.PostgreSQL.PQTypes.SQL.Class
import Database.PostgreSQL.PQTypes.Transaction
import Database.PostgreSQL.PQTypes.Transaction.Settings
import Database.PostgreSQL.PQTypes.Utils

type InnerDBT m = StateT (DBState m)

-- | Monad transformer for adding database
-- interaction capabilities to the underlying monad.
newtype DBT_ m n a = DBT { DBT_ m n a -> InnerDBT m n a
unDBT :: InnerDBT m n a }
  deriving (Applicative (DBT_ m n)
DBT_ m n a
Applicative (DBT_ m n)
-> (forall a. DBT_ m n a)
-> (forall a. DBT_ m n a -> DBT_ m n a -> DBT_ m n a)
-> (forall a. DBT_ m n a -> DBT_ m n [a])
-> (forall a. DBT_ m n a -> DBT_ m n [a])
-> Alternative (DBT_ m n)
DBT_ m n a -> DBT_ m n a -> DBT_ m n a
DBT_ m n a -> DBT_ m n [a]
DBT_ m n a -> DBT_ m n [a]
forall a. DBT_ m n a
forall a. DBT_ m n a -> DBT_ m n [a]
forall a. DBT_ m n a -> DBT_ m n a -> DBT_ m n a
forall (f :: * -> *).
Applicative f
-> (forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
forall (m :: * -> *) (n :: * -> *).
MonadPlus n =>
Applicative (DBT_ m n)
forall (m :: * -> *) (n :: * -> *) a. MonadPlus n => DBT_ m n a
forall (m :: * -> *) (n :: * -> *) a.
MonadPlus n =>
DBT_ m n a -> DBT_ m n [a]
forall (m :: * -> *) (n :: * -> *) a.
MonadPlus n =>
DBT_ m n a -> DBT_ m n a -> DBT_ m n a
many :: DBT_ m n a -> DBT_ m n [a]
$cmany :: forall (m :: * -> *) (n :: * -> *) a.
MonadPlus n =>
DBT_ m n a -> DBT_ m n [a]
some :: DBT_ m n a -> DBT_ m n [a]
$csome :: forall (m :: * -> *) (n :: * -> *) a.
MonadPlus n =>
DBT_ m n a -> DBT_ m n [a]
<|> :: DBT_ m n a -> DBT_ m n a -> DBT_ m n a
$c<|> :: forall (m :: * -> *) (n :: * -> *) a.
MonadPlus n =>
DBT_ m n a -> DBT_ m n a -> DBT_ m n a
empty :: DBT_ m n a
$cempty :: forall (m :: * -> *) (n :: * -> *) a. MonadPlus n => DBT_ m n a
$cp1Alternative :: forall (m :: * -> *) (n :: * -> *).
MonadPlus n =>
Applicative (DBT_ m n)
Alternative, Functor (DBT_ m n)
a -> DBT_ m n a
Functor (DBT_ m n)
-> (forall a. a -> DBT_ m n a)
-> (forall a b. DBT_ m n (a -> b) -> DBT_ m n a -> DBT_ m n b)
-> (forall a b c.
    (a -> b -> c) -> DBT_ m n a -> DBT_ m n b -> DBT_ m n c)
-> (forall a b. DBT_ m n a -> DBT_ m n b -> DBT_ m n b)
-> (forall a b. DBT_ m n a -> DBT_ m n b -> DBT_ m n a)
-> Applicative (DBT_ m n)
DBT_ m n a -> DBT_ m n b -> DBT_ m n b
DBT_ m n a -> DBT_ m n b -> DBT_ m n a
DBT_ m n (a -> b) -> DBT_ m n a -> DBT_ m n b
(a -> b -> c) -> DBT_ m n a -> DBT_ m n b -> DBT_ m n c
forall a. a -> DBT_ m n a
forall a b. DBT_ m n a -> DBT_ m n b -> DBT_ m n a
forall a b. DBT_ m n a -> DBT_ m n b -> DBT_ m n b
forall a b. DBT_ m n (a -> b) -> DBT_ m n a -> DBT_ m n b
forall a b c.
(a -> b -> c) -> DBT_ m n a -> DBT_ m n b -> DBT_ m n c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
forall (m :: * -> *) (n :: * -> *). Monad n => Functor (DBT_ m n)
forall (m :: * -> *) (n :: * -> *) a. Monad n => a -> DBT_ m n a
forall (m :: * -> *) (n :: * -> *) a b.
Monad n =>
DBT_ m n a -> DBT_ m n b -> DBT_ m n a
forall (m :: * -> *) (n :: * -> *) a b.
Monad n =>
DBT_ m n a -> DBT_ m n b -> DBT_ m n b
forall (m :: * -> *) (n :: * -> *) a b.
Monad n =>
DBT_ m n (a -> b) -> DBT_ m n a -> DBT_ m n b
forall (m :: * -> *) (n :: * -> *) a b c.
Monad n =>
(a -> b -> c) -> DBT_ m n a -> DBT_ m n b -> DBT_ m n c
<* :: DBT_ m n a -> DBT_ m n b -> DBT_ m n a
$c<* :: forall (m :: * -> *) (n :: * -> *) a b.
Monad n =>
DBT_ m n a -> DBT_ m n b -> DBT_ m n a
*> :: DBT_ m n a -> DBT_ m n b -> DBT_ m n b
$c*> :: forall (m :: * -> *) (n :: * -> *) a b.
Monad n =>
DBT_ m n a -> DBT_ m n b -> DBT_ m n b
liftA2 :: (a -> b -> c) -> DBT_ m n a -> DBT_ m n b -> DBT_ m n c
$cliftA2 :: forall (m :: * -> *) (n :: * -> *) a b c.
Monad n =>
(a -> b -> c) -> DBT_ m n a -> DBT_ m n b -> DBT_ m n c
<*> :: DBT_ m n (a -> b) -> DBT_ m n a -> DBT_ m n b
$c<*> :: forall (m :: * -> *) (n :: * -> *) a b.
Monad n =>
DBT_ m n (a -> b) -> DBT_ m n a -> DBT_ m n b
pure :: a -> DBT_ m n a
$cpure :: forall (m :: * -> *) (n :: * -> *) a. Monad n => a -> DBT_ m n a
$cp1Applicative :: forall (m :: * -> *) (n :: * -> *). Monad n => Functor (DBT_ m n)
Applicative, a -> DBT_ m n b -> DBT_ m n a
(a -> b) -> DBT_ m n a -> DBT_ m n b
(forall a b. (a -> b) -> DBT_ m n a -> DBT_ m n b)
-> (forall a b. a -> DBT_ m n b -> DBT_ m n a)
-> Functor (DBT_ m n)
forall a b. a -> DBT_ m n b -> DBT_ m n a
forall a b. (a -> b) -> DBT_ m n a -> DBT_ m n b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
forall (m :: * -> *) (n :: * -> *) a b.
Functor n =>
a -> DBT_ m n b -> DBT_ m n a
forall (m :: * -> *) (n :: * -> *) a b.
Functor n =>
(a -> b) -> DBT_ m n a -> DBT_ m n b
<$ :: a -> DBT_ m n b -> DBT_ m n a
$c<$ :: forall (m :: * -> *) (n :: * -> *) a b.
Functor n =>
a -> DBT_ m n b -> DBT_ m n a
fmap :: (a -> b) -> DBT_ m n a -> DBT_ m n b
$cfmap :: forall (m :: * -> *) (n :: * -> *) a b.
Functor n =>
(a -> b) -> DBT_ m n a -> DBT_ m n b
Functor, Applicative (DBT_ m n)
a -> DBT_ m n a
Applicative (DBT_ m n)
-> (forall a b. DBT_ m n a -> (a -> DBT_ m n b) -> DBT_ m n b)
-> (forall a b. DBT_ m n a -> DBT_ m n b -> DBT_ m n b)
-> (forall a. a -> DBT_ m n a)
-> Monad (DBT_ m n)
DBT_ m n a -> (a -> DBT_ m n b) -> DBT_ m n b
DBT_ m n a -> DBT_ m n b -> DBT_ m n b
forall a. a -> DBT_ m n a
forall a b. DBT_ m n a -> DBT_ m n b -> DBT_ m n b
forall a b. DBT_ m n a -> (a -> DBT_ m n b) -> DBT_ m n b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
forall (m :: * -> *) (n :: * -> *).
Monad n =>
Applicative (DBT_ m n)
forall (m :: * -> *) (n :: * -> *) a. Monad n => a -> DBT_ m n a
forall (m :: * -> *) (n :: * -> *) a b.
Monad n =>
DBT_ m n a -> DBT_ m n b -> DBT_ m n b
forall (m :: * -> *) (n :: * -> *) a b.
Monad n =>
DBT_ m n a -> (a -> DBT_ m n b) -> DBT_ m n b
return :: a -> DBT_ m n a
$creturn :: forall (m :: * -> *) (n :: * -> *) a. Monad n => a -> DBT_ m n a
>> :: DBT_ m n a -> DBT_ m n b -> DBT_ m n b
$c>> :: forall (m :: * -> *) (n :: * -> *) a b.
Monad n =>
DBT_ m n a -> DBT_ m n b -> DBT_ m n b
>>= :: DBT_ m n a -> (a -> DBT_ m n b) -> DBT_ m n b
$c>>= :: forall (m :: * -> *) (n :: * -> *) a b.
Monad n =>
DBT_ m n a -> (a -> DBT_ m n b) -> DBT_ m n b
$cp1Monad :: forall (m :: * -> *) (n :: * -> *).
Monad n =>
Applicative (DBT_ m n)
Monad, Monad (DBT_ m n)
Monad (DBT_ m n)
-> (forall a. String -> DBT_ m n a) -> MonadFail (DBT_ m n)
String -> DBT_ m n a
forall a. String -> DBT_ m n a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
forall (m :: * -> *) (n :: * -> *). MonadFail n => Monad (DBT_ m n)
forall (m :: * -> *) (n :: * -> *) a.
MonadFail n =>
String -> DBT_ m n a
fail :: String -> DBT_ m n a
$cfail :: forall (m :: * -> *) (n :: * -> *) a.
MonadFail n =>
String -> DBT_ m n a
$cp1MonadFail :: forall (m :: * -> *) (n :: * -> *). MonadFail n => Monad (DBT_ m n)
MF.MonadFail, MonadBase b, MonadThrow (DBT_ m n)
MonadThrow (DBT_ m n)
-> (forall e a.
    Exception e =>
    DBT_ m n a -> (e -> DBT_ m n a) -> DBT_ m n a)
-> MonadCatch (DBT_ m n)
DBT_ m n a -> (e -> DBT_ m n a) -> DBT_ m n a
forall e a.
Exception e =>
DBT_ m n a -> (e -> DBT_ m n a) -> DBT_ m n a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
forall (m :: * -> *) (n :: * -> *).
MonadCatch n =>
MonadThrow (DBT_ m n)
forall (m :: * -> *) (n :: * -> *) e a.
(MonadCatch n, Exception e) =>
DBT_ m n a -> (e -> DBT_ m n a) -> DBT_ m n a
catch :: DBT_ m n a -> (e -> DBT_ m n a) -> DBT_ m n a
$ccatch :: forall (m :: * -> *) (n :: * -> *) e a.
(MonadCatch n, Exception e) =>
DBT_ m n a -> (e -> DBT_ m n a) -> DBT_ m n a
$cp1MonadCatch :: forall (m :: * -> *) (n :: * -> *).
MonadCatch n =>
MonadThrow (DBT_ m n)
MonadCatch, Monad (DBT_ m n)
Monad (DBT_ m n)
-> (forall a. IO a -> DBT_ m n a) -> MonadIO (DBT_ m n)
IO a -> DBT_ m n a
forall a. IO a -> DBT_ m n a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
forall (m :: * -> *) (n :: * -> *). MonadIO n => Monad (DBT_ m n)
forall (m :: * -> *) (n :: * -> *) a.
MonadIO n =>
IO a -> DBT_ m n a
liftIO :: IO a -> DBT_ m n a
$cliftIO :: forall (m :: * -> *) (n :: * -> *) a.
MonadIO n =>
IO a -> DBT_ m n a
$cp1MonadIO :: forall (m :: * -> *) (n :: * -> *). MonadIO n => Monad (DBT_ m n)
MonadIO, MonadCatch (DBT_ m n)
MonadCatch (DBT_ m n)
-> (forall b.
    ((forall a. DBT_ m n a -> DBT_ m n a) -> DBT_ m n b) -> DBT_ m n b)
-> (forall b.
    ((forall a. DBT_ m n a -> DBT_ m n a) -> DBT_ m n b) -> DBT_ m n b)
-> (forall a b c.
    DBT_ m n a
    -> (a -> ExitCase b -> DBT_ m n c)
    -> (a -> DBT_ m n b)
    -> DBT_ m n (b, c))
-> MonadMask (DBT_ m n)
DBT_ m n a
-> (a -> ExitCase b -> DBT_ m n c)
-> (a -> DBT_ m n b)
-> DBT_ m n (b, c)
((forall a. DBT_ m n a -> DBT_ m n a) -> DBT_ m n b) -> DBT_ m n b
((forall a. DBT_ m n a -> DBT_ m n a) -> DBT_ m n b) -> DBT_ m n b
forall b.
((forall a. DBT_ m n a -> DBT_ m n a) -> DBT_ m n b) -> DBT_ m n b
forall a b c.
DBT_ m n a
-> (a -> ExitCase b -> DBT_ m n c)
-> (a -> DBT_ m n b)
-> DBT_ m n (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
forall (m :: * -> *) (n :: * -> *).
MonadMask n =>
MonadCatch (DBT_ m n)
forall (m :: * -> *) (n :: * -> *) b.
MonadMask n =>
((forall a. DBT_ m n a -> DBT_ m n a) -> DBT_ m n b) -> DBT_ m n b
forall (m :: * -> *) (n :: * -> *) a b c.
MonadMask n =>
DBT_ m n a
-> (a -> ExitCase b -> DBT_ m n c)
-> (a -> DBT_ m n b)
-> DBT_ m n (b, c)
generalBracket :: DBT_ m n a
-> (a -> ExitCase b -> DBT_ m n c)
-> (a -> DBT_ m n b)
-> DBT_ m n (b, c)
$cgeneralBracket :: forall (m :: * -> *) (n :: * -> *) a b c.
MonadMask n =>
DBT_ m n a
-> (a -> ExitCase b -> DBT_ m n c)
-> (a -> DBT_ m n b)
-> DBT_ m n (b, c)
uninterruptibleMask :: ((forall a. DBT_ m n a -> DBT_ m n a) -> DBT_ m n b) -> DBT_ m n b
$cuninterruptibleMask :: forall (m :: * -> *) (n :: * -> *) b.
MonadMask n =>
((forall a. DBT_ m n a -> DBT_ m n a) -> DBT_ m n b) -> DBT_ m n b
mask :: ((forall a. DBT_ m n a -> DBT_ m n a) -> DBT_ m n b) -> DBT_ m n b
$cmask :: forall (m :: * -> *) (n :: * -> *) b.
MonadMask n =>
((forall a. DBT_ m n a -> DBT_ m n a) -> DBT_ m n b) -> DBT_ m n b
$cp1MonadMask :: forall (m :: * -> *) (n :: * -> *).
MonadMask n =>
MonadCatch (DBT_ m n)
MonadMask, Monad (DBT_ m n)
Alternative (DBT_ m n)
DBT_ m n a
Alternative (DBT_ m n)
-> Monad (DBT_ m n)
-> (forall a. DBT_ m n a)
-> (forall a. DBT_ m n a -> DBT_ m n a -> DBT_ m n a)
-> MonadPlus (DBT_ m n)
DBT_ m n a -> DBT_ m n a -> DBT_ m n a
forall a. DBT_ m n a
forall a. DBT_ m n a -> DBT_ m n a -> DBT_ m n a
forall (m :: * -> *).
Alternative m
-> Monad m
-> (forall a. m a)
-> (forall a. m a -> m a -> m a)
-> MonadPlus m
forall (m :: * -> *) (n :: * -> *). MonadPlus n => Monad (DBT_ m n)
forall (m :: * -> *) (n :: * -> *).
MonadPlus n =>
Alternative (DBT_ m n)
forall (m :: * -> *) (n :: * -> *) a. MonadPlus n => DBT_ m n a
forall (m :: * -> *) (n :: * -> *) a.
MonadPlus n =>
DBT_ m n a -> DBT_ m n a -> DBT_ m n a
mplus :: DBT_ m n a -> DBT_ m n a -> DBT_ m n a
$cmplus :: forall (m :: * -> *) (n :: * -> *) a.
MonadPlus n =>
DBT_ m n a -> DBT_ m n a -> DBT_ m n a
mzero :: DBT_ m n a
$cmzero :: forall (m :: * -> *) (n :: * -> *) a. MonadPlus n => DBT_ m n a
$cp2MonadPlus :: forall (m :: * -> *) (n :: * -> *). MonadPlus n => Monad (DBT_ m n)
$cp1MonadPlus :: forall (m :: * -> *) (n :: * -> *).
MonadPlus n =>
Alternative (DBT_ m n)
MonadPlus, Monad (DBT_ m n)
e -> DBT_ m n a
Monad (DBT_ m n)
-> (forall e a. Exception e => e -> DBT_ m n a)
-> MonadThrow (DBT_ m n)
forall e a. Exception e => e -> DBT_ m n a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
forall (m :: * -> *) (n :: * -> *).
MonadThrow n =>
Monad (DBT_ m n)
forall (m :: * -> *) (n :: * -> *) e a.
(MonadThrow n, Exception e) =>
e -> DBT_ m n a
throwM :: e -> DBT_ m n a
$cthrowM :: forall (m :: * -> *) (n :: * -> *) e a.
(MonadThrow n, Exception e) =>
e -> DBT_ m n a
$cp1MonadThrow :: forall (m :: * -> *) (n :: * -> *).
MonadThrow n =>
Monad (DBT_ m n)
MonadThrow, m a -> DBT_ m m a
(forall (m :: * -> *) a. Monad m => m a -> DBT_ m m a)
-> MonadTrans (DBT_ m)
forall (m :: * -> *) a. Monad m => m a -> DBT_ m m a
forall (m :: * -> *) (m :: * -> *) a. Monad m => m a -> DBT_ m m a
forall (t :: (* -> *) -> * -> *).
(forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
lift :: m a -> DBT_ m m a
$clift :: forall (m :: * -> *) (m :: * -> *) a. Monad m => m a -> DBT_ m m a
MonadTrans)

type DBT m = DBT_ m m

-- | Evaluate monadic action with supplied
-- connection source and transaction settings.
{-# INLINABLE runDBT #-}
runDBT
  :: (MonadBase IO m, MonadMask m)
  => ConnectionSourceM m
  -> TransactionSettings
  -> DBT m a
  -> m a
runDBT :: ConnectionSourceM m -> TransactionSettings -> DBT m a -> m a
runDBT ConnectionSourceM m
cs TransactionSettings
ts DBT m a
m = ConnectionSourceM m -> forall r. (Connection -> m r) -> m r
forall (m :: * -> *).
ConnectionSourceM m -> forall r. (Connection -> m r) -> m r
withConnection ConnectionSourceM m
cs ((Connection -> m a) -> m a) -> (Connection -> m a) -> m a
forall a b. (a -> b) -> a -> b
$ \Connection
conn -> do
  StateT (DBState m) m a -> DBState m -> m a
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT StateT (DBState m) m a
action (DBState m -> m a) -> DBState m -> m a
forall a b. (a -> b) -> a -> b
$ DBState :: forall (m :: * -> *).
Connection
-> ConnectionSourceM m
-> TransactionSettings
-> SomeSQL
-> Bool
-> (forall row. FromRow row => Maybe (QueryResult row))
-> DBState m
DBState {
    dbConnection :: Connection
dbConnection = Connection
conn
  , dbConnectionSource :: ConnectionSourceM m
dbConnectionSource = ConnectionSourceM m
cs
  , dbTransactionSettings :: TransactionSettings
dbTransactionSettings = TransactionSettings
ts
  , dbLastQuery :: SomeSQL
dbLastQuery = SQL -> SomeSQL
forall sql. IsSQL sql => sql -> SomeSQL
SomeSQL (SQL
forall a. Monoid a => a
mempty::SQL)
  , dbRecordLastQuery :: Bool
dbRecordLastQuery = Bool
True
  , dbQueryResult :: forall row. FromRow row => Maybe (QueryResult row)
dbQueryResult = forall a. Maybe a
forall row. FromRow row => Maybe (QueryResult row)
Nothing
  }
  where
    action :: StateT (DBState m) m a
action = DBT m a -> StateT (DBState m) m a
forall (m :: * -> *) (n :: * -> *) a. DBT_ m n a -> InnerDBT m n a
unDBT (DBT m a -> StateT (DBState m) m a)
-> DBT m a -> StateT (DBState m) m a
forall a b. (a -> b) -> a -> b
$ if TransactionSettings -> Bool
tsAutoTransaction TransactionSettings
ts
      then TransactionSettings -> DBT m a -> DBT m a
forall (m :: * -> *) a.
(MonadDB m, MonadMask m) =>
TransactionSettings -> m a -> m a
withTransaction' (TransactionSettings
ts { tsAutoTransaction :: Bool
tsAutoTransaction = Bool
False }) DBT m a
m
      else DBT m a
m

-- | Transform the underlying monad.
{-# INLINABLE mapDBT #-}
mapDBT
  :: (DBState n -> DBState m)
  -> (m (a, DBState m) -> n (b, DBState n))
  -> DBT m a
  -> DBT n b
mapDBT :: (DBState n -> DBState m)
-> (m (a, DBState m) -> n (b, DBState n)) -> DBT m a -> DBT n b
mapDBT DBState n -> DBState m
f m (a, DBState m) -> n (b, DBState n)
g DBT m a
m = InnerDBT n n b -> DBT n b
forall (m :: * -> *) (n :: * -> *) a. InnerDBT m n a -> DBT_ m n a
DBT (InnerDBT n n b -> DBT n b)
-> ((DBState n -> n (b, DBState n)) -> InnerDBT n n b)
-> (DBState n -> n (b, DBState n))
-> DBT n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DBState n -> n (b, DBState n)) -> InnerDBT n n b
forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
StateT ((DBState n -> n (b, DBState n)) -> DBT n b)
-> (DBState n -> n (b, DBState n)) -> DBT n b
forall a b. (a -> b) -> a -> b
$ m (a, DBState m) -> n (b, DBState n)
g (m (a, DBState m) -> n (b, DBState n))
-> (DBState n -> m (a, DBState m)) -> DBState n -> n (b, DBState n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StateT (DBState m) m a -> DBState m -> m (a, DBState m)
forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT (DBT m a -> StateT (DBState m) m a
forall (m :: * -> *) (n :: * -> *) a. DBT_ m n a -> InnerDBT m n a
unDBT DBT m a
m) (DBState m -> m (a, DBState m))
-> (DBState n -> DBState m) -> DBState n -> m (a, DBState m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DBState n -> DBState m
f

----------------------------------------

instance (m ~ n, MonadBase IO m, MonadMask m) => MonadDB (DBT_ m n) where
  runQuery :: sql -> DBT_ m n Int
runQuery sql
sql = InnerDBT m n Int -> DBT_ m n Int
forall (m :: * -> *) (n :: * -> *) a. InnerDBT m n a -> DBT_ m n a
DBT (InnerDBT m n Int -> DBT_ m n Int)
-> ((DBState m -> n (Int, DBState m)) -> InnerDBT m n Int)
-> (DBState m -> n (Int, DBState m))
-> DBT_ m n Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DBState m -> n (Int, DBState m)) -> InnerDBT m n Int
forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
StateT ((DBState m -> n (Int, DBState m)) -> DBT_ m n Int)
-> (DBState m -> n (Int, DBState m)) -> DBT_ m n Int
forall a b. (a -> b) -> a -> b
$ IO (Int, DBState m) -> n (Int, DBState m)
forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase (IO (Int, DBState m) -> n (Int, DBState m))
-> (DBState m -> IO (Int, DBState m))
-> DBState m
-> n (Int, DBState m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. sql -> DBState m -> IO (Int, DBState m)
forall sql (m :: * -> *).
IsSQL sql =>
sql -> DBState m -> IO (Int, DBState m)
runQueryIO sql
sql
  getLastQuery :: DBT_ m n SomeSQL
getLastQuery = InnerDBT m n SomeSQL -> DBT_ m n SomeSQL
forall (m :: * -> *) (n :: * -> *) a. InnerDBT m n a -> DBT_ m n a
DBT (InnerDBT m n SomeSQL -> DBT_ m n SomeSQL)
-> ((DBState n -> SomeSQL) -> InnerDBT m n SomeSQL)
-> (DBState n -> SomeSQL)
-> DBT_ m n SomeSQL
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DBState n -> SomeSQL) -> InnerDBT m n SomeSQL
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ((DBState n -> SomeSQL) -> DBT_ m n SomeSQL)
-> (DBState n -> SomeSQL) -> DBT_ m n SomeSQL
forall a b. (a -> b) -> a -> b
$ DBState n -> SomeSQL
forall (m :: * -> *). DBState m -> SomeSQL
dbLastQuery

  withFrozenLastQuery :: DBT_ m n a -> DBT_ m n a
withFrozenLastQuery DBT_ m n a
callback = InnerDBT m n a -> DBT_ m n a
forall (m :: * -> *) (n :: * -> *) a. InnerDBT m n a -> DBT_ m n a
DBT (InnerDBT m n a -> DBT_ m n a)
-> ((DBState m -> n (a, DBState m)) -> InnerDBT m n a)
-> (DBState m -> n (a, DBState m))
-> DBT_ m n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DBState m -> n (a, DBState m)) -> InnerDBT m n a
forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
StateT ((DBState m -> n (a, DBState m)) -> DBT_ m n a)
-> (DBState m -> n (a, DBState m)) -> DBT_ m n a
forall a b. (a -> b) -> a -> b
$ \DBState m
st -> do
    let st' :: DBState m
st' = DBState m
st { dbRecordLastQuery :: Bool
dbRecordLastQuery = Bool
False }
    (a
x, DBState m
st'') <- InnerDBT m n a -> DBState m -> n (a, DBState m)
forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT (DBT_ m n a -> InnerDBT m n a
forall (m :: * -> *) (n :: * -> *) a. DBT_ m n a -> InnerDBT m n a
unDBT DBT_ m n a
callback) DBState m
st'
    (a, DBState m) -> n (a, DBState m)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a
x, DBState m
st'' { dbRecordLastQuery :: Bool
dbRecordLastQuery = DBState m -> Bool
forall (m :: * -> *). DBState m -> Bool
dbRecordLastQuery DBState m
st })

  getConnectionStats :: DBT_ m n ConnectionStats
getConnectionStats = do
    Maybe ConnectionData
mconn <- InnerDBT m n (Maybe ConnectionData)
-> DBT_ m n (Maybe ConnectionData)
forall (m :: * -> *) (n :: * -> *) a. InnerDBT m n a -> DBT_ m n a
DBT (InnerDBT m n (Maybe ConnectionData)
 -> DBT_ m n (Maybe ConnectionData))
-> InnerDBT m n (Maybe ConnectionData)
-> DBT_ m n (Maybe ConnectionData)
forall a b. (a -> b) -> a -> b
$ IO (Maybe ConnectionData) -> InnerDBT m n (Maybe ConnectionData)
forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase (IO (Maybe ConnectionData) -> InnerDBT m n (Maybe ConnectionData))
-> (MVar (Maybe ConnectionData) -> IO (Maybe ConnectionData))
-> MVar (Maybe ConnectionData)
-> InnerDBT m n (Maybe ConnectionData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MVar (Maybe ConnectionData) -> IO (Maybe ConnectionData)
forall a. MVar a -> IO a
readMVar (MVar (Maybe ConnectionData)
 -> InnerDBT m n (Maybe ConnectionData))
-> StateT (DBState m) n (MVar (Maybe ConnectionData))
-> InnerDBT m n (Maybe ConnectionData)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (DBState n -> MVar (Maybe ConnectionData))
-> StateT (DBState m) n (MVar (Maybe ConnectionData))
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets (Connection -> MVar (Maybe ConnectionData)
unConnection (Connection -> MVar (Maybe ConnectionData))
-> (DBState n -> Connection)
-> DBState n
-> MVar (Maybe ConnectionData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DBState n -> Connection
forall (m :: * -> *). DBState m -> Connection
dbConnection)
    case Maybe ConnectionData
mconn of
      Maybe ConnectionData
Nothing -> HPQTypesError -> DBT_ m n ConnectionStats
forall e (m :: * -> *) a.
(Exception e, MonadDB m, MonadThrow m) =>
e -> m a
throwDB (HPQTypesError -> DBT_ m n ConnectionStats)
-> HPQTypesError -> DBT_ m n ConnectionStats
forall a b. (a -> b) -> a -> b
$ String -> HPQTypesError
HPQTypesError String
"getConnectionStats: no connection"
      Just ConnectionData
cd -> ConnectionStats -> DBT_ m n ConnectionStats
forall (m :: * -> *) a. Monad m => a -> m a
return (ConnectionStats -> DBT_ m n ConnectionStats)
-> ConnectionStats -> DBT_ m n ConnectionStats
forall a b. (a -> b) -> a -> b
$ ConnectionData -> ConnectionStats
cdStats ConnectionData
cd

  getQueryResult :: DBT_ m n (Maybe (QueryResult row))
getQueryResult = InnerDBT m n (Maybe (QueryResult row))
-> DBT_ m n (Maybe (QueryResult row))
forall (m :: * -> *) (n :: * -> *) a. InnerDBT m n a -> DBT_ m n a
DBT (InnerDBT m n (Maybe (QueryResult row))
 -> DBT_ m n (Maybe (QueryResult row)))
-> ((DBState n -> Maybe (QueryResult row))
    -> InnerDBT m n (Maybe (QueryResult row)))
-> (DBState n -> Maybe (QueryResult row))
-> DBT_ m n (Maybe (QueryResult row))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DBState n -> Maybe (QueryResult row))
-> InnerDBT m n (Maybe (QueryResult row))
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ((DBState n -> Maybe (QueryResult row))
 -> DBT_ m n (Maybe (QueryResult row)))
-> (DBState n -> Maybe (QueryResult row))
-> DBT_ m n (Maybe (QueryResult row))
forall a b. (a -> b) -> a -> b
$ \DBState n
st -> DBState n -> forall row. FromRow row => Maybe (QueryResult row)
forall (m :: * -> *).
DBState m -> forall row. FromRow row => Maybe (QueryResult row)
dbQueryResult DBState n
st
  clearQueryResult :: DBT_ m n ()
clearQueryResult = InnerDBT m n () -> DBT_ m n ()
forall (m :: * -> *) (n :: * -> *) a. InnerDBT m n a -> DBT_ m n a
DBT (InnerDBT m n () -> DBT_ m n ())
-> ((DBState n -> DBState n) -> InnerDBT m n ())
-> (DBState n -> DBState n)
-> DBT_ m n ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DBState n -> DBState n) -> InnerDBT m n ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((DBState n -> DBState n) -> DBT_ m n ())
-> (DBState n -> DBState n) -> DBT_ m n ()
forall a b. (a -> b) -> a -> b
$ \DBState n
st -> DBState n
st { dbQueryResult :: forall row. FromRow row => Maybe (QueryResult row)
dbQueryResult = forall a. Maybe a
forall row. FromRow row => Maybe (QueryResult row)
Nothing }

  getTransactionSettings :: DBT_ m n TransactionSettings
getTransactionSettings = InnerDBT m n TransactionSettings -> DBT_ m n TransactionSettings
forall (m :: * -> *) (n :: * -> *) a. InnerDBT m n a -> DBT_ m n a
DBT (InnerDBT m n TransactionSettings -> DBT_ m n TransactionSettings)
-> ((DBState n -> TransactionSettings)
    -> InnerDBT m n TransactionSettings)
-> (DBState n -> TransactionSettings)
-> DBT_ m n TransactionSettings
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DBState n -> TransactionSettings)
-> InnerDBT m n TransactionSettings
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ((DBState n -> TransactionSettings)
 -> DBT_ m n TransactionSettings)
-> (DBState n -> TransactionSettings)
-> DBT_ m n TransactionSettings
forall a b. (a -> b) -> a -> b
$ DBState n -> TransactionSettings
forall (m :: * -> *). DBState m -> TransactionSettings
dbTransactionSettings
  setTransactionSettings :: TransactionSettings -> DBT_ m n ()
setTransactionSettings TransactionSettings
ts = InnerDBT m n () -> DBT_ m n ()
forall (m :: * -> *) (n :: * -> *) a. InnerDBT m n a -> DBT_ m n a
DBT (InnerDBT m n () -> DBT_ m n ())
-> ((DBState n -> DBState n) -> InnerDBT m n ())
-> (DBState n -> DBState n)
-> DBT_ m n ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DBState n -> DBState n) -> InnerDBT m n ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((DBState n -> DBState n) -> DBT_ m n ())
-> (DBState n -> DBState n) -> DBT_ m n ()
forall a b. (a -> b) -> a -> b
$ \DBState n
st -> DBState n
st { dbTransactionSettings :: TransactionSettings
dbTransactionSettings = TransactionSettings
ts }

  getNotification :: Int -> DBT_ m n (Maybe Notification)
getNotification Int
time = InnerDBT m n (Maybe Notification) -> DBT_ m n (Maybe Notification)
forall (m :: * -> *) (n :: * -> *) a. InnerDBT m n a -> DBT_ m n a
DBT (InnerDBT m n (Maybe Notification)
 -> DBT_ m n (Maybe Notification))
-> ((DBState m -> n (Maybe Notification, DBState m))
    -> InnerDBT m n (Maybe Notification))
-> (DBState m -> n (Maybe Notification, DBState m))
-> DBT_ m n (Maybe Notification)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DBState m -> n (Maybe Notification, DBState m))
-> InnerDBT m n (Maybe Notification)
forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
StateT ((DBState m -> n (Maybe Notification, DBState m))
 -> DBT_ m n (Maybe Notification))
-> (DBState m -> n (Maybe Notification, DBState m))
-> DBT_ m n (Maybe Notification)
forall a b. (a -> b) -> a -> b
$ \DBState m
st -> (, DBState m
st)
    (Maybe Notification -> (Maybe Notification, DBState m))
-> n (Maybe Notification) -> n (Maybe Notification, DBState m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO (Maybe Notification) -> n (Maybe Notification)
forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase (DBState m -> Int -> IO (Maybe Notification)
forall (m :: * -> *). DBState m -> Int -> IO (Maybe Notification)
getNotificationIO DBState m
st Int
time)

  withNewConnection :: DBT_ m n a -> DBT_ m n a
withNewConnection DBT_ m n a
m = InnerDBT m m a -> DBT_ m m a
forall (m :: * -> *) (n :: * -> *) a. InnerDBT m n a -> DBT_ m n a
DBT (InnerDBT m m a -> DBT_ m m a)
-> ((DBState m -> m (a, DBState m)) -> InnerDBT m m a)
-> (DBState m -> m (a, DBState m))
-> DBT_ m m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DBState m -> m (a, DBState m)) -> InnerDBT m m a
forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
StateT ((DBState m -> m (a, DBState m)) -> DBT_ m m a)
-> (DBState m -> m (a, DBState m)) -> DBT_ m m a
forall a b. (a -> b) -> a -> b
$ \DBState m
st -> do
    let cs :: ConnectionSourceM m
cs = DBState m -> ConnectionSourceM m
forall (m :: * -> *). DBState m -> ConnectionSourceM m
dbConnectionSource DBState m
st
        ts :: TransactionSettings
ts = DBState m -> TransactionSettings
forall (m :: * -> *). DBState m -> TransactionSettings
dbTransactionSettings DBState m
st
    a
res <- ConnectionSourceM m -> TransactionSettings -> DBT_ m m a -> m a
forall (m :: * -> *) a.
(MonadBase IO m, MonadMask m) =>
ConnectionSourceM m -> TransactionSettings -> DBT m a -> m a
runDBT ConnectionSourceM m
cs TransactionSettings
ts DBT_ m m a
DBT_ m n a
m
    (a, DBState m) -> m (a, DBState m)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
res, DBState m
st)

  {-# INLINABLE runQuery #-}
  {-# INLINABLE getLastQuery #-}
  {-# INLINABLE withFrozenLastQuery #-}
  {-# INLINABLE getConnectionStats #-}
  {-# INLINABLE getQueryResult #-}
  {-# INLINABLE clearQueryResult #-}
  {-# INLINABLE getTransactionSettings #-}
  {-# INLINABLE setTransactionSettings #-}
  {-# INLINABLE getNotification #-}
  {-# INLINABLE withNewConnection #-}

----------------------------------------

instance MonadTransControl (DBT_ m) where
#if MIN_VERSION_monad_control(1,0,0)
  type StT (DBT_ m) a = StT (InnerDBT m) a
  liftWith :: (Run (DBT_ m) -> m a) -> DBT_ m m a
liftWith = (forall b. StateT (DBState m) m b -> DBT_ m m b)
-> (forall (o :: * -> *) b. DBT_ m o b -> StateT (DBState m) o b)
-> (RunDefault (DBT_ m) (StateT (DBState m)) -> m a)
-> DBT_ m m a
forall (m :: * -> *) (n :: (* -> *) -> * -> *)
       (t :: (* -> *) -> * -> *) a.
(Monad m, MonadTransControl n) =>
(forall b. n m b -> t m b)
-> (forall (o :: * -> *) b. t o b -> n o b)
-> (RunDefault t n -> m a)
-> t m a
defaultLiftWith forall b. StateT (DBState m) m b -> DBT_ m m b
forall (m :: * -> *) (n :: * -> *) a. InnerDBT m n a -> DBT_ m n a
DBT forall (o :: * -> *) b. DBT_ m o b -> StateT (DBState m) o b
forall (m :: * -> *) (n :: * -> *) a. DBT_ m n a -> InnerDBT m n a
unDBT
  restoreT :: m (StT (DBT_ m) a) -> DBT_ m m a
restoreT = (StateT (DBState m) m a -> DBT_ m m a)
-> m (StT (StateT (DBState m)) a) -> DBT_ m m a
forall (m :: * -> *) (n :: (* -> *) -> * -> *) a
       (t :: (* -> *) -> * -> *).
(Monad m, MonadTransControl n) =>
(n m a -> t m a) -> m (StT n a) -> t m a
defaultRestoreT StateT (DBState m) m a -> DBT_ m m a
forall (m :: * -> *) (n :: * -> *) a. InnerDBT m n a -> DBT_ m n a
DBT
  {-# INLINE liftWith #-}
  {-# INLINE restoreT #-}
#else
  newtype StT (DBT_ m) a = StDBT { unStDBT :: StT (InnerDBT m) a }
  liftWith = defaultLiftWith DBT unDBT StDBT
  restoreT = defaultRestoreT DBT unStDBT
  {-# INLINE liftWith #-}
  {-# INLINE restoreT #-}
#endif

instance (m ~ n, MonadBaseControl b m) => MonadBaseControl b (DBT_ m n) where
#if MIN_VERSION_monad_control(1,0,0)
  type StM (DBT_ m n) a = ComposeSt (DBT_ m) m a
  liftBaseWith :: (RunInBase (DBT_ m n) b -> b a) -> DBT_ m n a
liftBaseWith = (RunInBase (DBT_ m n) b -> b a) -> DBT_ m n a
forall (t :: (* -> *) -> * -> *) (b :: * -> *) (m :: * -> *) a.
(MonadTransControl t, MonadBaseControl b m) =>
(RunInBaseDefault t m b -> b a) -> t m a
defaultLiftBaseWith
  restoreM :: StM (DBT_ m n) a -> DBT_ m n a
restoreM     = StM (DBT_ m n) a -> DBT_ m n a
forall (t :: (* -> *) -> * -> *) (b :: * -> *) (m :: * -> *) a.
(MonadTransControl t, MonadBaseControl b m) =>
ComposeSt t m a -> t m a
defaultRestoreM
  {-# INLINE liftBaseWith #-}
  {-# INLINE restoreM #-}
#else
  newtype StM (DBT m) a = StMDBT { unStMDBT :: ComposeSt (DBT_ m) m a }
  liftBaseWith = defaultLiftBaseWith StMDBT
  restoreM     = defaultRestoreM unStMDBT
  {-# INLINE liftBaseWith #-}
  {-# INLINE restoreM #-}
#endif

instance (m ~ n, MonadError e m) => MonadError e (DBT_ m n) where
  throwError :: e -> DBT_ m n a
throwError = n a -> DBT_ m n a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (n a -> DBT_ m n a) -> (e -> n a) -> e -> DBT_ m n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> n a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError
  catchError :: DBT_ m n a -> (e -> DBT_ m n a) -> DBT_ m n a
catchError DBT_ m n a
m e -> DBT_ m n a
h = InnerDBT m n a -> DBT_ m n a
forall (m :: * -> *) (n :: * -> *) a. InnerDBT m n a -> DBT_ m n a
DBT (InnerDBT m n a -> DBT_ m n a) -> InnerDBT m n a -> DBT_ m n a
forall a b. (a -> b) -> a -> b
$ Catch e n (a, DBState m) -> Catch e (StateT (DBState m) n) a
forall e (m :: * -> *) a s.
Catch e m (a, s) -> Catch e (StateT s m) a
S.liftCatch Catch e n (a, DBState m)
forall e (m :: * -> *) a.
MonadError e m =>
m a -> (e -> m a) -> m a
catchError (DBT_ m n a -> InnerDBT m n a
forall (m :: * -> *) (n :: * -> *) a. DBT_ m n a -> InnerDBT m n a
unDBT DBT_ m n a
m) (DBT_ m n a -> InnerDBT m n a
forall (m :: * -> *) (n :: * -> *) a. DBT_ m n a -> InnerDBT m n a
unDBT (DBT_ m n a -> InnerDBT m n a)
-> (e -> DBT_ m n a) -> e -> InnerDBT m n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> DBT_ m n a
h)
  {-# INLINE throwError #-}
  {-# INLINE catchError #-}

instance (m ~ n, MonadReader r m) => MonadReader r (DBT_ m n) where
  ask :: DBT_ m n r
ask = n r -> DBT_ m n r
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift n r
forall r (m :: * -> *). MonadReader r m => m r
ask
  local :: (r -> r) -> DBT_ m n a -> DBT_ m n a
local r -> r
f = (DBState m -> DBState m)
-> (m (a, DBState m) -> m (a, DBState m)) -> DBT m a -> DBT m a
forall (n :: * -> *) (m :: * -> *) a b.
(DBState n -> DBState m)
-> (m (a, DBState m) -> n (b, DBState n)) -> DBT m a -> DBT n b
mapDBT DBState m -> DBState m
forall a. a -> a
id ((r -> r) -> m (a, DBState m) -> m (a, DBState m)
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local r -> r
f)
  reader :: (r -> a) -> DBT_ m n a
reader = n a -> DBT_ m n a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (n a -> DBT_ m n a) -> ((r -> a) -> n a) -> (r -> a) -> DBT_ m n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (r -> a) -> n a
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader
  {-# INLINE ask #-}
  {-# INLINE local #-}
  {-# INLINE reader #-}

instance (m ~ n, MonadState s m) => MonadState s (DBT_ m n) where
  get :: DBT_ m n s
get = n s -> DBT_ m n s
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift n s
forall s (m :: * -> *). MonadState s m => m s
get
  put :: s -> DBT_ m n ()
put = n () -> DBT_ m n ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (n () -> DBT_ m n ()) -> (s -> n ()) -> s -> DBT_ m n ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> n ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put
  state :: (s -> (a, s)) -> DBT_ m n a
state = n a -> DBT_ m n a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (n a -> DBT_ m n a)
-> ((s -> (a, s)) -> n a) -> (s -> (a, s)) -> DBT_ m n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (s -> (a, s)) -> n a
forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state
  {-# INLINE get #-}
  {-# INLINE put #-}
  {-# INLINE state #-}

instance (m ~ n, MonadWriter w m) => MonadWriter w (DBT_ m n) where
  writer :: (a, w) -> DBT_ m n a
writer = n a -> DBT_ m n a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (n a -> DBT_ m n a) -> ((a, w) -> n a) -> (a, w) -> DBT_ m n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, w) -> n a
forall w (m :: * -> *) a. MonadWriter w m => (a, w) -> m a
writer
  tell :: w -> DBT_ m n ()
tell = n () -> DBT_ m n ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (n () -> DBT_ m n ()) -> (w -> n ()) -> w -> DBT_ m n ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. w -> n ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell
  listen :: DBT_ m n a -> DBT_ m n (a, w)
listen = InnerDBT m n (a, w) -> DBT_ m n (a, w)
forall (m :: * -> *) (n :: * -> *) a. InnerDBT m n a -> DBT_ m n a
DBT (InnerDBT m n (a, w) -> DBT_ m n (a, w))
-> (DBT_ m n a -> InnerDBT m n (a, w))
-> DBT_ m n a
-> DBT_ m n (a, w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Listen w n (a, DBState m) -> Listen w (StateT (DBState m) n) a
forall (m :: * -> *) w a s.
Monad m =>
Listen w m (a, s) -> Listen w (StateT s m) a
S.liftListen Listen w n (a, DBState m)
forall w (m :: * -> *) a. MonadWriter w m => m a -> m (a, w)
listen Listen w (StateT (DBState m) n) a
-> (DBT_ m n a -> StateT (DBState m) n a)
-> DBT_ m n a
-> InnerDBT m n (a, w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DBT_ m n a -> StateT (DBState m) n a
forall (m :: * -> *) (n :: * -> *) a. DBT_ m n a -> InnerDBT m n a
unDBT
  pass :: DBT_ m n (a, w -> w) -> DBT_ m n a
pass = InnerDBT m n a -> DBT_ m n a
forall (m :: * -> *) (n :: * -> *) a. InnerDBT m n a -> DBT_ m n a
DBT (InnerDBT m n a -> DBT_ m n a)
-> (DBT_ m n (a, w -> w) -> InnerDBT m n a)
-> DBT_ m n (a, w -> w)
-> DBT_ m n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Pass w n (a, DBState m) -> Pass w (StateT (DBState m) n) a
forall (m :: * -> *) w a s.
Monad m =>
Pass w m (a, s) -> Pass w (StateT s m) a
S.liftPass Pass w n (a, DBState m)
forall w (m :: * -> *) a. MonadWriter w m => m (a, w -> w) -> m a
pass Pass w (StateT (DBState m) n) a
-> (DBT_ m n (a, w -> w) -> StateT (DBState m) n (a, w -> w))
-> DBT_ m n (a, w -> w)
-> InnerDBT m n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DBT_ m n (a, w -> w) -> StateT (DBState m) n (a, w -> w)
forall (m :: * -> *) (n :: * -> *) a. DBT_ m n a -> InnerDBT m n a
unDBT
  {-# INLINE writer #-}
  {-# INLINE tell #-}
  {-# INLINE listen #-}
  {-# INLINE pass #-}