Safe Haskell | Safe-Inferred |
---|---|
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
/ MonadTransControlIdentity
.
Type level arguments:
ComposeT | |
|
Instances
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 two stacked monad transformers.
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
,MonadTransControlIdentity
)
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 AppStackT =TransparentT
.|>
ReaderT
Bool
.|>
CustomT.|>
ReaderT
Char
.|>
StateT
Int
newtype AppT m a = AppT { unAppT :: AppStackT m a } deriving newtype (Functor
,Applicative
,Monad
)
Using .|>
we can write AppStackT
in the order of initialization.
We are adding TransparentT
to the bottom of the stack,
so that all the other transformer instances actually end up in the stack.
Now we can simply derive just the instances, that we want.
deriving newtype (MonadTrans
,MonadTransControl
) 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.
With ..>
we can use the order of initialization again.
runAppT :: AppT m a -> m (StT
AppT a) runAppT appTma =runTransparentT
./>
(\ tma ->runReaderT
tmaTrue
)./>
runCustomT./>
runReaderT'./>
runStateT' $ unAppT appTma 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