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 in a clean way.
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 (
, whenever t2
m
)t1
implements
MonadTrans
/MonadTransControl
.
Type level arguments
ComposeT | |
|
Instances
(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 (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) => 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) => 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 | |
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
.
Then it's possible to derive the recursive instance. This is an OVERLAPPABLE instance, because we want to be able to add new instances through transformers in a stack.
deriving via Elevator t1 (t2 (m :: * -> *)) instance {--} ( 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 are not related to ComposeT
.
instance Monad m => MonadCustom (CustomT m) where simpleMethod = undefined complicatedMethod = undefined
To add an instance that takes priority over the recursive instance FlexibleInstances are required.
deriving via CustomT (t2 (m :: * -> *)) instance ( Monad (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 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 use Elevator
to access instances, that have been shadowed in the stack.
deriving (MonadReader Bool) via ( (StateT Int) ( Elevator (ReaderT Char) ( CustomT ( ReaderT Bool ( IdentityT m)))))
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 = do let 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 char runStateT tma num runStateT' |. runReaderT' |. runCustomT |. (\ tma -> runReaderT tma True) |. runIdentityT $ unStackT stackTma