Safe Haskell | None |
---|---|
Language | Haskell2010 |
Synopsis
- newtype ComposeT t1 t2 m a = ComposeT {
- deComposeT :: t1 (t2 m) a
- runComposeT :: (forall a. t1 (t2 m) a -> t2 m (StT t1 a)) -> (forall a. t2 m a -> m (StT t2 a)) -> forall a. ComposeT t1 t2 m a -> m (StT t2 (StT t1 a))
- runComposeT' :: (t1 (t2 m) a -> t2 m a) -> (t2 m a -> m a) -> ComposeT t1 t2 m a -> m a
ComposeT
ComposeT
can be used in monad transformer stacks to derive instances.
This also allows the usage of these instances, while in the middle of the transformer stack. This proves particularly useful, when writing a runner for a transformer stack.
newtype ComposeT t1 t2 m a Source #
A newtype wrapper for two stacked monad transformers.
Access instances of the intermediate monad (t2 m)
, whenever t1
implements MonadTrans
/
MonadTransControl
.
Type level arguments
ComposeT | |
|
Instances
(Monad (t2 m), Monoid w) => MonadRWS r w s (ComposeT (RWST r w s) t2 m) Source # | Set by |
Defined in Control.Monad.Trans.Compose | |
(Monad (t2 m), Monoid w) => MonadRWS r w s (ComposeT (RWST r w s) t2 m) Source # | Set by |
Defined in Control.Monad.Trans.Compose | |
(Monad (t1 (t2 m)), MonadTransControl t1, MonadRWS r w s (t2 m)) => MonadRWS r w s (ComposeT t1 t2 m) Source # | OVERLAPPABLE.
Elevated to |
Defined in Control.Monad.Trans.Compose | |
(Monad (t1 (t2 m)), MonadTrans (ComposeT t1 t2), MonadBase b m) => MonadBase b (ComposeT t1 t2 m) Source # | Elevated to |
Defined in Control.Monad.Trans.Compose | |
(Monad (t1 (t2 m)), MonadTransControl (ComposeT t1 t2), MonadBaseControl b m) => MonadBaseControl b (ComposeT t1 t2 m) Source # | Elevated to |
(Monad (t2 m), Monoid w) => MonadWriter w (ComposeT (RWST r w s) t2 m) Source # | Set by |
(Monad (t2 m), Monoid w) => MonadWriter w (ComposeT (RWST r w s) t2 m) Source # | Set by |
(Monad (t2 m), Monoid w) => MonadWriter w (ComposeT (WriterT w) t2 m) Source # | Set by |
(Monad (t2 m), Monoid w) => MonadWriter w (ComposeT (WriterT w) t2 m) Source # | Set by |
(Monad (t1 (t2 m)), MonadTransControl t1, MonadWriter w (t2 m)) => MonadWriter w (ComposeT t1 t2 m) Source # | OVERLAPPABLE.
Elevated to |
(Monad (t2 m), Monoid w) => MonadState s (ComposeT (RWST r w s) t2 m) Source # | Set by |
(Monad (t2 m), Monoid w) => MonadState s (ComposeT (RWST r w s) t2 m) Source # | Set by |
Monad (t2 m) => MonadState s (ComposeT (StateT s) t2 m) Source # | Set by |
Monad (t2 m) => MonadState s (ComposeT (StateT s) t2 m) Source # | Set by |
(Monad (t1 (t2 m)), MonadTrans t1, MonadState s (t2 m)) => MonadState s (ComposeT t1 t2 m) Source # | OVERLAPPABLE.
Elevated to |
(Monad (t2 m), Monoid w) => MonadReader r (ComposeT (RWST r w s) t2 m) Source # | Set by |
(Monad (t2 m), Monoid w) => MonadReader r (ComposeT (RWST r w s) t2 m) Source # | Set by |
Monad (t2 m) => MonadReader r (ComposeT (ReaderT r) t2 m) Source # | Set by |
(Monad (t1 (t2 m)), MonadTransControl t1, MonadReader r (t2 m)) => MonadReader r (ComposeT t1 t2 m) Source # | OVERLAPPABLE.
Elevated to |
Monad (t2 m) => MonadError e (ComposeT (ExceptT e) t2 m) Source # | Set by |
Defined in Control.Monad.Trans.Compose | |
(Monad (t1 (t2 m)), MonadTransControl t1, MonadError e (t2 m)) => MonadError e (ComposeT t1 t2 m) Source # | OVERLAPPABLE.
Elevated to |
Defined in Control.Monad.Trans.Compose throwError :: e -> ComposeT t1 t2 m a # catchError :: ComposeT t1 t2 m a -> (e -> ComposeT t1 t2 m a) -> ComposeT t1 t2 m a # | |
(forall (m :: Type -> Type). Monad m => Monad (t2 m), MonadTrans t1, MonadTrans t2) => MonadTrans (ComposeT t1 t2) Source # | |
Defined in Control.Monad.Trans.Compose | |
(forall (m :: Type -> Type). Monad m => Monad (t2 m), MonadTransControl t1, MonadTransControl t2) => MonadTransControl (ComposeT t1 t2) Source # | |
Monad (t1 (t2 m)) => Monad (ComposeT t1 t2 m) Source # | |
Functor (t1 (t2 m)) => Functor (ComposeT t1 t2 m) Source # | |
Applicative (t1 (t2 m)) => Applicative (ComposeT t1 t2 m) Source # | |
Defined in Control.Monad.Trans.Compose pure :: a -> ComposeT t1 t2 m a # (<*>) :: ComposeT t1 t2 m (a -> b) -> ComposeT t1 t2 m a -> ComposeT t1 t2 m b # liftA2 :: (a -> b -> c) -> ComposeT t1 t2 m a -> ComposeT t1 t2 m b -> ComposeT t1 t2 m c # (*>) :: ComposeT t1 t2 m a -> ComposeT t1 t2 m b -> ComposeT t1 t2 m b # (<*) :: ComposeT t1 t2 m a -> ComposeT t1 t2 m b -> ComposeT t1 t2 m a # | |
(Monad (t1 (t2 m)), MonadTrans (ComposeT t1 t2), MonadIO m) => MonadIO (ComposeT t1 t2 m) Source # | Elevated to |
Defined in Control.Monad.Trans.Compose | |
(Monad (t1 (t2 m)), MonadTransControl t1, MonadCont (t2 m)) => MonadCont (ComposeT t1 t2 m) Source # | OVERLAPPABLE.
Elevated to |
Monad (t2 m) => MonadCont (ComposeT (ContT r) t2 m) Source # | Set by |
type StT (ComposeT t1 t2) a Source # | |
Defined in Control.Monad.Trans.Compose | |
type StM (ComposeT t1 t2 m) a Source # | |
Run ComposeT
You have to run the composed monad transformers to get back into the base monad at some point.
:: (forall a. t1 (t2 m) a -> t2 m (StT t1 a)) | run |
-> (forall a. t2 m a -> m (StT t2 a)) | run |
-> forall a. ComposeT t1 t2 m a -> m (StT t2 (StT t1 a)) |
Run a transformer stack.
This function takes the two individual monad transformer runners as arguments.
:: (t1 (t2 m) a -> t2 m a) | run |
-> (t2 m a -> m a) | run |
-> ComposeT t1 t2 m a -> m a |
Equivalent to runComposeT
, but discards the monadic state StT
.
This is a simple approach when your monad transformer stack doesn't carry monadic state.
StT
(ComposeT
t1 t2) a ~ a
This can be used to improve error messages when modifying a monad transformer stack.
Examples
Example 1: Create a new type class
When creating a new type class that supports ComposeT
, you want to add recursive instances for
ComposeT
.
class Monad
m => MonadCustom m where
simpleMethod :: a -> m a
complicatedMethod :: (a -> m a) -> m a
You can easily derive those instances, after implementing an instance for Elevator
.
This is explained in Control.Monad.Trans.Elevator.
Then it's possible to derive the recursive instance. This is an OVERLAPPABLE instance, because we want to be able to add new "base-case" instances through transformers in a stack.
deriving viaElevator
t1 (t2 (m :: * -> *)) instance {-# OVERLAPPABLE #-} (Monad
(t1 (t2 m)) ,MonadTransControl
t1 , MonadCustom (t2 m) ) => MonadCustom (ComposeT
t1 t2 m)
Example 2: Add an instance
Add a type class instance for a new monad transformer, when there already is a recursive instance
for ComposeT
.
newtype CustomT m a = CustomT { unCustomT ::IdentityT
m a } deriving newtype (Functor
,Applicative
,Monad
) deriving newtype (MonadTrans
,MonadTransControl
)
First we need the regular instance.
The method implementations are undefined
here, because they would only distract from
ComposeT
.
instanceMonad
m => MonadCustom (CustomT m) where simpleMethod =undefined
complicatedMethod =undefined
To add a "base-case" instance, that takes priority over the recursive instance, FlexibleInstances are required.
deriving via CustomT (t2 (m :: * -> *)) instanceMonad
(t2 m) => MonadCustom (ComposeT
CustomT t2 m)
Example 3: Build a transformer stack
Create a monad transformer stack and wrap it using a newtype.
type (|.) =ComposeT
type Stack =StateT
Int
|.ReaderT
Char
|. CustomT |.ReaderT
Bool
|.IdentityT
newtype StackT m a = StackT { unStackT :: Stack m a } deriving newtype (Functor
,Applicative
,Monad
)
We are adding IdentityT
to the end of the stack, so that all the
other transformer instances end up in the stack.
Now we can simply derive just the instances, that we want.
deriving newtype (MonadState
Int
) deriving newtype MonadCustom
We can even access instances, that would have been shadowed in a regular transformer stack.
deriving newtype (MonadReader
Bool
)
Example 4: Run a transformer stack
This is the part, that actually contains your application logic.
Because of the setup with ComposeT
, we won't have to worry about lift
ing during the
initialization.
runStackT ::MonadBaseControl
IO
m => StackT m a -> m (StT StackT a) runStackT stackTma = runStateT' |. runReaderT' |. runCustomT |. (\ tma ->runReaderT
tmaTrue
) |.runIdentityT
$ unStackT stackTma where runReaderT' ::MonadReader
Bool
m =>ReaderT
Char
m a -> m a runReaderT' tma = do bool <-ask
let char = if bool then 'Y' else 'N'runReaderT
tma char runStateT' ::MonadReader
Char
m =>StateT
Int
m a -> m (a,Int
) runStateT' tma = do char <-ask
let num =fromEnum
charrunStateT
tma num