Control.Monad.Trans.MultiRWS.Lazy

The multi-valued version of mtl's RWS / RWST

MultiRWST

newtype MultiRWST r w s m a

Constructors

MultiRWST

Fields

• runMultiRWSTRaw :: StateT (HList r, HList w, HList s) m a

Instances

MonadBase b m => MonadBase b (MultiRWST r w s m)

Methods

liftBase :: b α -> MultiRWST r w s m α

MonadBaseControl b m => MonadBaseControl b (MultiRWST r w s m)

Associated Types

type StM (MultiRWST r w s m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (MultiRWST r w s m) b -> b a) -> MultiRWST r w s m a

restoreM :: StM (MultiRWST r w s m) a -> MultiRWST r w s m a

(Monad m, ContainsType a w, Monoid a) => MonadMultiWriter a (MultiRWST r w s m)

Methods

mTell :: a -> MultiRWST r w s m ()

(Monad m, ContainsType a r) => MonadMultiReader a (MultiRWST r w s m)

Methods

mAsk :: MultiRWST r w s m a

(Monad m, ContainsType a s) => MonadMultiGet a (MultiRWST r w s m)

Methods

mGet :: MultiRWST r w s m a

(Monad m, ContainsType a s) => MonadMultiState a (MultiRWST r w s m)

Methods

mSet :: a -> MultiRWST r w s m ()

MonadTrans (MultiRWST r w s)

Methods

lift :: Monad m => m a -> MultiRWST r w s m a

MonadTransControl (MultiRWST r w s)

Associated Types

type StT (MultiRWST r w s :: (* -> *) -> * -> *) a :: *

Methods

liftWith :: Monad m => (Run (MultiRWST r w s) -> m a) -> MultiRWST r w s m a

restoreT :: Monad m => m (StT (MultiRWST r w s) a) -> MultiRWST r w s m a

Monad m => Monad (MultiRWST r w s m)

Methods

(>>=) :: MultiRWST r w s m a -> (a -> MultiRWST r w s m b) -> MultiRWST r w s m b

(>>) :: MultiRWST r w s m a -> MultiRWST r w s m b -> MultiRWST r w s m b

return :: a -> MultiRWST r w s m a

fail :: String -> MultiRWST r w s m a

Functor f => Functor (MultiRWST r w s f)

Methods

fmap :: (a -> b) -> MultiRWST r w s f a -> MultiRWST r w s f b

(<$) :: a -> MultiRWST r w s f b -> MultiRWST r w s f a

MonadFix m => MonadFix (MultiRWST r w s m)

Methods

mfix :: (a -> MultiRWST r w s m a) -> MultiRWST r w s m a

(Applicative m, Monad m) => Applicative (MultiRWST r w s m)

Methods

pure :: a -> MultiRWST r w s m a

(<*>) :: MultiRWST r w s m (a -> b) -> MultiRWST r w s m a -> MultiRWST r w s m b

(*>) :: MultiRWST r w s m a -> MultiRWST r w s m b -> MultiRWST r w s m b

(<*) :: MultiRWST r w s m a -> MultiRWST r w s m b -> MultiRWST r w s m a

MonadIO m => MonadIO (MultiRWST r w s m)

Methods

liftIO :: IO a -> MultiRWST r w s m a

(Functor m, Applicative m, MonadPlus m) => Alternative (MultiRWST r w s m)

Methods

empty :: MultiRWST r w s m a

(<|>) :: MultiRWST r w s m a -> MultiRWST r w s m a -> MultiRWST r w s m a

some :: MultiRWST r w s m a -> MultiRWST r w s m [a]

many :: MultiRWST r w s m a -> MultiRWST r w s m [a]

MonadPlus m => MonadPlus (MultiRWST r w s m)

Methods

mzero :: MultiRWST r w s m a

mplus :: MultiRWST r w s m a -> MultiRWST r w s m a -> MultiRWST r w s m a

type StT (MultiRWST r w s) a

type StT (MultiRWST r w s) a = (a, (HList r, HList w, HList s))

type StM (MultiRWST r w s m) a

type StM (MultiRWST r w s m) a = ComposeSt (MultiRWST r w s) m a

type MultiRWSTNull = MultiRWST '[] '[] '[]

type MultiRWS r w s = MultiRWST r w s Identity

MonadMulti classes

class Monad m => MonadMultiReader a m where

All methods must be defined.

The idea is: Any monad stack is instance of MonadMultiReader a, iff the stack contains a MultiReaderT x with a element of x.

Minimal complete definition

mAsk

Methods

mAsk :: m a

Instances

(MonadTrans t, Monad (t m), MonadMultiReader a m) => MonadMultiReader a (t m)

Methods

mAsk :: t m a

(Monad m, ContainsType a c) => MonadMultiReader a (MultiReaderT c m)

Methods

mAsk :: MultiReaderT c m a

(Monad m, ContainsType a c) => MonadMultiReader a (MultiReaderT c m)

Methods

mAsk :: MultiReaderT c m a

(Monad m, ContainsType a r) => MonadMultiReader a (MultiRWST r w s m)

Methods

mAsk :: MultiRWST r w s m a

(Monad m, ContainsType a r) => MonadMultiReader a (MultiRWST r w s m)

Methods

mAsk :: MultiRWST r w s m a

class (Monad m, Monoid a) => MonadMultiWriter a m where

Minimal complete definition

mTell

Methods

mTell :: a -> m ()

Instances

(MonadTrans t, Monad (t m), MonadMultiWriter a m) => MonadMultiWriter a (t m)

Methods

mTell :: a -> t m ()

(Monad m, ContainsType a c, Monoid a) => MonadMultiWriter a (MultiWriterT c m)

Methods

mTell :: a -> MultiWriterT c m ()

(Monad m, ContainsType a c, Monoid a) => MonadMultiWriter a (MultiWriterT c m)

Methods

mTell :: a -> MultiWriterT c m ()

(Monad m, Monoid a, HListMContains TellableFlag a cts) => MonadMultiWriter a (MultiGSTT cts m)

Methods

mTell :: a -> MultiGSTT cts m ()

(Monad m, Monoid a, HListMContains TellableFlag a cts) => MonadMultiWriter a (MultiGSTT cts m)

Methods

mTell :: a -> MultiGSTT cts m ()

(Monad m, ContainsType a w, Monoid a) => MonadMultiWriter a (MultiRWST r w s m)

Methods

mTell :: a -> MultiRWST r w s m ()

(Monad m, ContainsType a w, Monoid a) => MonadMultiWriter a (MultiRWST r w s m)

Methods

mTell :: a -> MultiRWST r w s m ()

class Monad m => MonadMultiGet a m where

In contrast to MonadMultiReader, MonadMultiGet is defined for State too, so it corresponds to read-access of any kind.

Note however that for MultiRWS, only the values from the state part can be accessed via MonadMultiGet, due to limitations of the design of MultiRWS and of the type system. This is issue is resolved in the MultiGST type.

Minimal complete definition

mGet

Methods

mGet :: m a

Instances

(MonadTrans t, Monad (t m), MonadMultiGet a m) => MonadMultiGet a (t m)

Methods

mGet :: t m a

(Monad m, ContainsType a c) => MonadMultiGet a (MultiReaderT c m)

Methods

mGet :: MultiReaderT c m a

(Monad m, ContainsType a c) => MonadMultiGet a (MultiReaderT c m)

Methods

mGet :: MultiReaderT c m a

(Monad m, ContainsType a c) => MonadMultiGet a (MultiStateT c m)

Methods

mGet :: MultiStateT c m a

(Monad m, ContainsType a c) => MonadMultiGet a (MultiStateT c m)

Methods

mGet :: MultiStateT c m a

(Monad m, HListMContains GettableFlag a cts) => MonadMultiGet a (MultiGSTT cts m)

Methods

mGet :: MultiGSTT cts m a

(Monad m, HListMContains GettableFlag a cts) => MonadMultiGet a (MultiGSTT cts m)

Methods

mGet :: MultiGSTT cts m a

(Monad m, ContainsType a s) => MonadMultiGet a (MultiRWST r w s m)

Methods

mGet :: MultiRWST r w s m a

(Monad m, ContainsType a s) => MonadMultiGet a (MultiRWST r w s m)

Methods

mGet :: MultiRWST r w s m a

class MonadMultiGet a m => MonadMultiState a m where

Minimal complete definition

mSet

Methods

mSet :: a -> m ()

Instances

(MonadTrans t, Monad (t m), MonadMultiState a m) => MonadMultiState a (t m)

Methods

mSet :: a -> t m ()

(Monad m, ContainsType a c) => MonadMultiState a (MultiStateT c m)

Methods

mSet :: a -> MultiStateT c m ()

(Monad m, ContainsType a c) => MonadMultiState a (MultiStateT c m)

Methods

mSet :: a -> MultiStateT c m ()

(Monad m, HListMContains SettableFlag a cts) => MonadMultiState a (MultiGSTT cts m)

Methods

mSet :: a -> MultiGSTT cts m ()

(Monad m, HListMContains SettableFlag a cts) => MonadMultiState a (MultiGSTT cts m)

Methods

mSet :: a -> MultiGSTT cts m ()

(Monad m, ContainsType a s) => MonadMultiState a (MultiRWST r w s m)

Methods

mSet :: a -> MultiRWST r w s m ()

(Monad m, ContainsType a s) => MonadMultiState a (MultiRWST r w s m)

Methods

mSet :: a -> MultiRWST r w s m ()

run-functions (extracting from RWST)

runMultiRWST :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList s, HList w)

runMultiRWSTASW :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList s, HList w)

runMultiRWSTW :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (HList w)

runMultiRWSTAW :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList w)

runMultiRWSTSW :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (HList s, HList w)

runMultiRWSTNil :: Monad m => MultiRWST '[] '[] '[] m a -> m a

runMultiRWSTNil_ :: (Monad m, Functor m) => MultiRWST '[] '[] '[] m a -> m ()

with-functions (extending an RWST)

withMultiReader :: Monad m => r -> MultiRWST (r ': rs) w s m a -> MultiRWST rs w s m a

withMultiReader_ :: (Functor m, Monad m) => r -> MultiRWST (r ': rs) w s m a -> MultiRWST rs w s m ()

withMultiReaders :: Monad m => HList r1 -> MultiRWST (Append r1 r2) w s m a -> MultiRWST r2 w s m a

withMultiReaders_ :: (Functor m, Monad m) => HList r1 -> MultiRWST (Append r1 r2) w s m a -> MultiRWST r2 w s m ()

withMultiWriter :: (Monoid w, Monad m) => MultiRWST r (w ': ws) s m a -> MultiRWST r ws s m (a, w)

withMultiWriterAW :: (Monoid w, Monad m) => MultiRWST r (w ': ws) s m a -> MultiRWST r ws s m (a, w)

withMultiWriterWA :: (Monoid w, Monad m) => MultiRWST r (w ': ws) s m a -> MultiRWST r ws s m (w, a)

withMultiWriterW :: (Monoid w, Monad m) => MultiRWST r (w ': ws) s m a -> MultiRWST r ws s m w

withMultiWriters :: forall r w1 w2 s m a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (a, HList w1)

withMultiWritersAW :: forall r w1 w2 s m a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (a, HList w1)

withMultiWritersWA :: forall r w1 w2 s m a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (HList w1, a)

withMultiWritersW :: forall r w1 w2 s m a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (HList w1)

withMultiState :: Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m (a, s)

withMultiStateAS :: Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m (a, s)

withMultiStateSA :: Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m (s, a)

withMultiStateA :: Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m a

withMultiStateS :: Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m s

withMultiState_ :: (Functor m, Monad m) => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m ()

withMultiStates :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (a, HList s1)

withMultiStatesAS :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (a, HList s1)

withMultiStatesSA :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (HList s1, a)

withMultiStatesA :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m a

withMultiStatesS :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (HList s1)

withMultiStates_ :: (Functor m, Monad m) => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m ()

without-functions (reducing an RWST; inverse of with)

withoutMultiReader :: Monad m => MultiRWST rs w s m a -> MultiRWST (r ': rs) w s m a

withoutMultiState :: Monad m => MultiRWST r w ss m a -> MultiRWST r w (s ': ss) m a

inflate-functions (run simple transformer in MultiRWST)

inflateReader :: (Monad m, ContainsType r rs) => ReaderT r m a -> MultiRWST rs w s m a

inflateMultiReader :: Monad m => MultiReaderT r m a -> MultiRWST r w s m a

inflateWriter :: (Monad m, ContainsType w ws, Monoid w) => WriterT w m a -> MultiRWST r ws s m a

inflateMultiWriter :: (Functor m, Monad m, Monoid (HList w)) => MultiWriterT w m a -> MultiRWST r w s m a

inflateState :: (Monad m, MonadMultiState s (t m), MonadTrans t) => StateT s m a -> t m a

inflateMultiState :: (Functor m, Monad m) => MultiStateT s m a -> MultiRWST r w s m a

other functions

mapMultiRWST :: ss ~ (HList r, HList w, HList s) => (m (a, ss) -> m' (a', ss)) -> MultiRWST r w s m a -> MultiRWST r w s m' a'

mGetRawR :: Monad m => MultiRWST r w s m (HList r)

mGetRawW :: Monad m => MultiRWST r w s m (HList w)

mGetRawS :: Monad m => MultiRWST r w s m (HList s)

mPutRawR :: Monad m => HList r -> MultiRWST r w s m ()

mPutRawW :: Monad m => HList w -> MultiRWST r w s m ()

mPutRawS :: Monad m => HList s -> MultiRWST r w s m ()