Control.Monad.Trans.Compose

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

A newtype wrapper for two stacked monad transformers.

Access instances of the intermediate monad (t2 m), whenever t1 implements MonadTrans/MonadTransControl.

Type level arguments

t1 :: (Type -> Type) -> Type -> Type

outer monad transformer

t2 :: (Type -> Type) -> Type -> Type

inner monad transformer

m :: Type -> Type

monad

a :: Type

value

Constructors

ComposeT

Fields

• deComposeT :: t1 (t2 m) a

Instances

(Monad (t1 (t2 m)), MonadTrans (ComposeT t1 t2), MonadBase b m) => MonadBase b (ComposeT t1 t2 m)

Elevated to m.

Defined in Control.Monad.Trans.Compose

Methods

liftBase :: b α -> ComposeT t1 t2 m α

(Monad (t1 (t2 m)), MonadTransControl (ComposeT t1 t2), MonadBaseControl b m) => MonadBaseControl b (ComposeT t1 t2 m)

Elevated to m.

Defined in Control.Monad.Trans.Compose

Associated Types

type StM (ComposeT t1 t2 m) a

Methods

liftBaseWith :: (RunInBase (ComposeT t1 t2 m) b -> b a) -> ComposeT t1 t2 m a

restoreM :: StM (ComposeT t1 t2 m) a -> ComposeT t1 t2 m a

(Monad (t2 m), Monoid w) => MonadWriter w (ComposeT (WriterT w) t2 m)

Set by WriterT.

Defined in Control.Monad.Trans.Compose

Methods

writer :: (a, w) -> ComposeT (WriterT w) t2 m a

tell :: w -> ComposeT (WriterT w) t2 m ()

listen :: ComposeT (WriterT w) t2 m a -> ComposeT (WriterT w) t2 m (a, w)

pass :: ComposeT (WriterT w) t2 m (a, w -> w) -> ComposeT (WriterT w) t2 m a

(Monad (t1 (t2 m)), MonadTransControl t1, MonadWriter w (t2 m)) => MonadWriter w (ComposeT t1 t2 m)

OVERLAPPABLE. Elevated to (t2 m).

Defined in Control.Monad.Trans.Compose

Methods

writer :: (a, w) -> ComposeT t1 t2 m a

tell :: w -> ComposeT t1 t2 m ()

listen :: ComposeT t1 t2 m a -> ComposeT t1 t2 m (a, w)

pass :: ComposeT t1 t2 m (a, w -> w) -> ComposeT t1 t2 m a

Monad (t2 m) => MonadState s (ComposeT (StateT s) t2 m)

Set by StateT.

Defined in Control.Monad.Trans.Compose

Methods

get :: ComposeT (StateT s) t2 m s

put :: s -> ComposeT (StateT s) t2 m ()

state :: (s -> (a, s)) -> ComposeT (StateT s) t2 m a

(Monad (t1 (t2 m)), MonadTrans t1, MonadState s (t2 m)) => MonadState s (ComposeT t1 t2 m)

OVERLAPPABLE. Elevated to (t2 m).

Defined in Control.Monad.Trans.Compose

Methods

get :: ComposeT t1 t2 m s

put :: s -> ComposeT t1 t2 m ()

state :: (s -> (a, s)) -> ComposeT t1 t2 m a

Monad (t2 m) => MonadReader r (ComposeT (ReaderT r) t2 m)

Set by ReaderT.

Defined in Control.Monad.Trans.Compose

Methods

ask :: ComposeT (ReaderT r) t2 m r

local :: (r -> r) -> ComposeT (ReaderT r) t2 m a -> ComposeT (ReaderT r) t2 m a

reader :: (r -> a) -> ComposeT (ReaderT r) t2 m a

(Monad (t1 (t2 m)), MonadTransControl t1, MonadReader r (t2 m)) => MonadReader r (ComposeT t1 t2 m)

OVERLAPPABLE. Elevated to (t2 m).

Defined in Control.Monad.Trans.Compose

Methods

ask :: ComposeT t1 t2 m r

local :: (r -> r) -> ComposeT t1 t2 m a -> ComposeT t1 t2 m a

reader :: (r -> a) -> ComposeT t1 t2 m a

Monad (t2 m) => MonadError e (ComposeT (ExceptT e) t2 m)

Set by ExceptT.

Defined in Control.Monad.Trans.Compose

Methods

throwError :: e -> ComposeT (ExceptT e) t2 m a

catchError :: ComposeT (ExceptT e) t2 m a -> (e -> ComposeT (ExceptT e) t2 m a) -> ComposeT (ExceptT e) t2 m a

(Monad (t1 (t2 m)), MonadTransControl t1, MonadError e (t2 m)) => MonadError e (ComposeT t1 t2 m)

OVERLAPPABLE. Elevated to (t2 m).

Defined in Control.Monad.Trans.Compose

Methods

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)

Defined in Control.Monad.Trans.Compose

Methods

lift :: Monad m => m a -> ComposeT t1 t2 m a

(forall (m :: Type -> Type). Monad m => Monad (t2 m), MonadTransControl t1, MonadTransControl t2) => MonadTransControl (ComposeT t1 t2)

Defined in Control.Monad.Trans.Compose

Associated Types

type StT (ComposeT t1 t2) a

Methods

liftWith :: Monad m => (Run (ComposeT t1 t2) -> m a) -> ComposeT t1 t2 m a

restoreT :: Monad m => m (StT (ComposeT t1 t2) a) -> ComposeT t1 t2 m a

Monad (t1 (t2 m)) => Monad (ComposeT t1 t2 m)

Defined in Control.Monad.Trans.Compose

Methods

(>>=) :: ComposeT t1 t2 m a -> (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 b

return :: a -> ComposeT t1 t2 m a

Functor (t1 (t2 m)) => Functor (ComposeT t1 t2 m)

Defined in Control.Monad.Trans.Compose

Methods

fmap :: (a -> b) -> ComposeT t1 t2 m a -> ComposeT t1 t2 m b

(<$) :: a -> ComposeT t1 t2 m b -> ComposeT t1 t2 m a

Applicative (t1 (t2 m)) => Applicative (ComposeT t1 t2 m)

Defined in Control.Monad.Trans.Compose

Methods

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)

Elevated to m.

Defined in Control.Monad.Trans.Compose

Methods

liftIO :: IO a -> ComposeT t1 t2 m a

type StT (ComposeT t1 t2) a

Defined in Control.Monad.Trans.Compose

type StT (ComposeT t1 t2) a = StT t2 (StT t1 a)

type StM (ComposeT t1 t2 m) a

Defined in Control.Monad.Trans.Compose

type StM (ComposeT t1 t2 m) a = StM (Elevator (ComposeT t1 t2) m) a

Run ComposeT

You have to run the composed monad transformers to get back into the base monad at some point.

runComposeT

Arguments

:: (forall a. t1 (t2 m) a -> t2 m (StT t1 a))

run t1

-> (forall a. t2 m a -> m (StT t2 a))

run t2

-> 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.

runComposeT'

Arguments

:: (t1 (t2 m) a -> t2 m a)

run t1

-> (t2 m a -> m a)

run t2

-> 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 lifting 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