relude-1.2.0.0: Safe, performant, user-friendly and lightweight Haskell Standard Library
Copyright(c) 2016 Stephen Diehl
(c) 2016-2018 Serokell
(c) 2018-2023 Kowainik
LicenseMIT
MaintainerKowainik <xrom.xkov@gmail.com>
StabilityStable
PortabilityPortable
Safe HaskellTrustworthy
LanguageHaskell2010

Relude.Monad.Trans

Description

Monad transformers utilities.

Synopsis

Convenient functions to work with Reader monad

usingReader :: r -> Reader r a -> a Source #

Shorter and more readable alias for flip runReader.

>>> usingReader 42 $ asks (+5)
47

usingReaderT :: r -> ReaderT r m a -> m a Source #

Shorter and more readable alias for flip runReaderT.

>>> usingReaderT 42 $ asks (+5)
47

etaReaderT :: ReaderT r m a -> ReaderT r m a Source #

This function helps with optimizing performance when working with the ReaderT transformer. If you have code like below, that is called in a loop

step :: Instruction -> ReaderT Config IO Result
step instruction = case instruction of
    Add -> do stuff ...
    Del -> do stuff ...

you can improve performance of your Haskell applications by using etaReaderT in the following way:

step :: Instruction -> ReaderT Config IO Result
step instruction = etaReaderT $ case instruction of
    Add -> do stuff ...
    Del -> do stuff ...

For a detailed explanation, refer to the following blog post:

Since: 0.7.0.0

Convenient functions to work with State monad

evaluatingState :: s -> State s a -> a Source #

Alias for flip evalState. It's not shorter but sometimes more readable. Done by analogy with using* functions family.

evaluatingStateT :: Functor f => s -> StateT s f a -> f a Source #

Alias for flip evalStateT. It's not shorter but sometimes more readable. Done by analogy with using* functions family.

executingState :: s -> State s a -> s Source #

Alias for flip execState. It's not shorter but sometimes more readable. Done by analogy with using* functions family.

executingStateT :: Functor f => s -> StateT s f a -> f s Source #

Alias for flip execStateT. It's not shorter but sometimes more readable. Done by analogy with using* functions family.

usingState :: s -> State s a -> (a, s) Source #

Shorter and more readable alias for flip runState.

usingStateT :: s -> StateT s m a -> m (a, s) Source #

Shorter and more readable alias for flip runStateT.

>>> usingStateT 0 $ put 42 >> pure False
(False,42)

Lifted to Transformers

hoistMaybe :: Applicative m => Maybe a -> MaybeT m a Source #

Lift a Maybe to the MaybeT monad

Since: 0.3.0

hoistEither :: Applicative m => Either e a -> ExceptT e m a Source #

Lift a Either to the ExceptT monad

Since: 0.3.0