module Monad.Trans
( module X
, usingReader
, usingReaderT
, evaluatingState
, evaluatingStateT
, executingState
, executingStateT
, usingState
, usingStateT
) where
import Control.Monad.Catch as X (MonadCatch (catch), MonadMask (..),
MonadThrow (throwM), bracket, bracket_,
catchAll, finally)
import Control.Monad.Except as X (ExceptT (..), runExceptT)
import Control.Monad.State as X (MonadState, State, StateT (..), evalState,
evalStateT, execState, execStateT, gets,
modify, runState, state, withState)
import Control.Monad.Reader as X (MonadReader, Reader, ReaderT (..), ask, asks,
local, reader, runReader)
import Control.Monad.Trans as X (MonadIO, lift, liftIO)
import Prelude (Functor, flip, fst, snd, (<$>))
usingReaderT :: r -> ReaderT r m a -> m a
usingReaderT = flip runReaderT
usingReader :: r -> Reader r a -> a
usingReader = flip runReader
usingStateT :: s -> StateT s m a -> m (a, s)
usingStateT = flip runStateT
usingState :: s -> State s a -> (a, s)
usingState = flip runState
evaluatingStateT :: Functor f => s -> StateT s f a -> f a
evaluatingStateT s st = fst <$> usingStateT s st
evaluatingState :: s -> State s a -> a
evaluatingState s st = fst (usingState s st)
executingStateT :: Functor f => s -> StateT s f a -> f s
executingStateT s st = snd <$> usingStateT s st
executingState :: s -> State s a -> s
executingState s st = snd (usingState s st)