Copyright	(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001, (C) 2015 KONISHI Yohsuke
License	BSD-style (see the file LICENSE)
Maintainer	ocean0yohsuke@gmail.com
Stability	experimental
Portability	---
Safe Haskell	Safe
Language	Haskell2010

DeepControl.Monad.Trans

Contents

MonadIO
MonadTrans
Level-2 example
Level-2 example2

Description

This module enables you to program in Monad-Transformer style for more deeper level than the usual Control.Monad.Trans module expresses. You would realize exactly what more deeper level means by reading the example codes, which are attached on the page bottom. Note: many instances for Level-4 and Level-5 haven't been written yet.

Synopsis

MonadIO

class Monad m => MonadIO m where

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

```
liftIO . return = return
```

liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Methods

liftIO :: IO a -> m a

Lift a computation from the IO monad.

Instances

MonadIO IO
MonadIO m => MonadIO (ListT m)
MonadIO m => MonadIO (MaybeT m)
MonadIO m => MonadIO (IdentityT m)
MonadIO m => MonadIO (ReaderT r m)
MonadIO m => MonadIO (StateT s m)
MonadIO m => MonadIO (StateT s m)
MonadIO m => MonadIO (ExceptT e m)
(Error e, MonadIO m) => MonadIO (ErrorT e m)
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
(MonadIO m1, Monad m1, Monad2 m2) => MonadIO (IdentityT2 m1 m2)
(MonadIO m1, Monad m1, Monad2 m2, Monad3 m3) => MonadIO (IdentityT3 m1 m2 m3)
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
(MonadIO m1, Monad m1, Monad2 m2, Monad3 m3, Monad4 m4) => MonadIO (IdentityT4 m1 m2 m3 m4)
(MonadIO m1, Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5) => MonadIO (IdentityT5 m1 m2 m3 m4 m5)

MonadTrans

Level-1

lift

class MonadTrans t where

The class of monad transformers. Instances should satisfy the following laws, which state that lift is a monad transformation:

```
lift . return = return
```
```
lift (m >>= f) = lift m >>= (lift . f)
```

Methods

lift :: Monad m => m a -> t m a

Lift a computation from the argument monad to the constructed monad.

Instances

MonadTrans ListT
MonadTrans MaybeT
MonadTrans IdentityT
MonadTrans (ReaderT r)
MonadTrans (StateT s)
MonadTrans (StateT s)
MonadTrans (ExceptT e)
Error e => MonadTrans (ErrorT e)
Monoid w => MonadTrans (WriterT w)
Monoid w => MonadTrans (WriterT w)
Monoid w => MonadTrans (RWST r w s)
Monoid w => MonadTrans (RWST r w s)

liftT :: (Monad m, MonadTrans t) => m a -> t m a Source

Alias for lift

liftTT :: (Monad m, Monad (t1 m), MonadTrans t, MonadTrans t1) => m a -> t (t1 m) a Source

liftTTT :: (Monad m, Monad (t1 (t2 m)), Monad (t2 m), MonadTrans t, MonadTrans t1, MonadTrans t2) => m a -> t (t1 (t2 m)) a Source

liftTTTT :: (Monad m, Monad (t1 (t2 (t3 m))), Monad (t2 (t3 m)), Monad (t3 m), MonadTrans t, MonadTrans t1, MonadTrans t2, MonadTrans t3) => m a -> t (t1 (t2 (t3 m))) a Source

liftTTTTT :: (Monad m, Monad (t1 (t2 (t3 (t4 m)))), Monad (t2 (t3 (t4 m))), Monad (t3 (t4 m)), Monad (t4 m), MonadTrans t, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) => m a -> t (t1 (t2 (t3 (t4 m)))) a Source

transdown

class (Monad (TransDown t1), MonadTrans t1) => MonadTransDown t1 Source

Associated Types

type TransDown t1 :: * -> * Source

Instances

MonadTransDown ListT Source
MonadTransDown MaybeT Source
MonadTransDown (ExceptT e) Source

type M t1 = TransDown t1 Source

cover

class MonadTransDown t1 => MonadTransCover t1 where Source

Methods

(|*|) :: Monad m1 => TransDown t1 a -> t1 m1 a infixl 3 Source

Instances

MonadTransCover ListT Source
MonadTransCover MaybeT Source
MonadTransCover (ExceptT e) Source

other

class MonadTrans_ t where Source

Required only for MonadTransFold2 and MonadTransFold3

Methods

trans :: Monad m => m (TransDown t a) -> t m a Source

untrans :: Monad m => t m a -> m (TransDown t a) Source

Instances

MonadTrans_ ListT Source
MonadTrans_ MaybeT Source
MonadTrans_ (ExceptT e) Source

Level-2

lift

class MonadTrans2 t where Source

Methods

liftT2 :: (Monad m1, Monad2 m2) => m1 (m2 a) -> t m1 m2 a Source

Instances

MonadTrans2 IdentityT2 Source

liftTT2 :: (Monad m1, Monad (t2 m1 m2), Monad2 m2, MonadTrans t1, MonadTrans2 t2) => m1 (m2 a) -> t1 (t2 m1 m2) a Source

liftTTT2 :: (Monad m1, Monad (t1 (t2 m1 m2)), Monad (t2 m1 m2), Monad2 m2, MonadTrans t, MonadTrans t1, MonadTrans2 t2) => m1 (m2 a) -> t (t1 (t2 m1 m2)) a Source

liftTTTT2 :: (Monad m1, Monad (t1 (t1' (t2 m1 m2))), Monad (t1' (t2 m1 m2)), Monad (t2 m1 m2), Monad2 m2, MonadTrans t, MonadTrans t1, MonadTrans t1', MonadTrans2 t2) => m1 (m2 a) -> t (t1 (t1' (t2 m1 m2))) a Source

liftTTTTT2 :: (Monad m1, Monad (t1 (t1' (t1'' (t2 m1 m2)))), Monad (t1' (t1'' (t2 m1 m2))), Monad (t1'' (t2 m1 m2)), Monad (t2 m1 m2), Monad2 m2, MonadTrans t, MonadTrans t1, MonadTrans t1', MonadTrans t1'', MonadTrans2 t2) => m1 (m2 a) -> t (t1 (t1' (t1'' (t2 m1 m2)))) a Source

transdown

class (MonadTrans (Trans2Down t2), MonadTrans2 t2) => MonadTrans2Down t2 Source

Associated Types

type Trans2Down t2 :: (* -> *) -> * -> * Source

Instances

MonadTrans2Down IdentityT2 Source

type M_ t2 = TransDown (T_ t2) Source

type T_ t2 = Trans2Down t2 Source

fold

class (MonadTrans (T_ t), MonadTrans2 t) => MonadTransFold2 t where Source

Following property holds.

untransfold2 . transfold2 == id

Methods

transfold2 :: (Monad m1, Monad (t2 m1), MonadTrans_ t2) => t m1 (TransDown t2) a -> T_ t (t2 m1) a Source

untransfold2 :: (Monad m1, Monad (t2 m1), MonadTrans_ t2) => T_ t (t2 m1) a -> t m1 (TransDown t2) a Source

Instances

MonadTransFold2 IdentityT2 Source

cover

class MonadTransCover (Trans2Down t2) => MonadTransCover2 t2 where Source

Methods

(|-*|) :: (Monad m1, Monad2 m2) => Trans2Down t2 m1 a -> t2 m1 m2 a infixl 3 Source

(|*-|) :: (Monad m1, Monad2 m2) => Trans2Down t2 m2 a -> t2 m1 m2 a infixl 3 Source

Instances

MonadTransCover2 IdentityT2 Source

(|**|) :: (Monad m1, Monad2 m2, MonadTransCover2 t2) => M_ t2 a -> t2 m1 m2 a infixl 3 Source

other

trans2 :: (Monad m, Monad (t1 m), MonadTrans_ t1, MonadTrans_ t2) => m (TransDown t1 (TransDown t2 a)) -> t2 (t1 m) a Source

untrans2 :: (Monad m, Monad (t1 m), MonadTrans_ t1, MonadTrans_ t2) => t2 (t1 m) a -> m (TransDown t1 (TransDown t2 a)) Source

Level-3

lift

class MonadTrans3 t where Source

Methods

liftT3 :: (Monad m1, Monad2 m2, Monad3 m3) => m1 (m2 (m3 a)) -> t m1 m2 m3 a Source

Instances

MonadTrans3 IdentityT3 Source

liftTT3 :: (Monad m1, Monad (t3 m1 m2 m3), Monad2 m2, Monad3 m3, MonadTrans t, MonadTrans3 t3) => m1 (m2 (m3 a)) -> t (t3 m1 m2 m3) a Source

liftTTT3 :: (Monad m1, Monad (t1 (t3 m1 m2 m3)), Monad (t3 m1 m2 m3), Monad2 m2, Monad3 m3, MonadTrans t, MonadTrans t1, MonadTrans3 t3) => m1 (m2 (m3 a)) -> t (t1 (t3 m1 m2 m3)) a Source

liftTTTT3 :: (Monad m1, Monad (t1 (t1' (t3 m1 m2 m3))), Monad (t1' (t3 m1 m2 m3)), Monad (t3 m1 m2 m3), Monad2 m2, Monad3 m3, MonadTrans t, MonadTrans t1, MonadTrans t1', MonadTrans3 t3) => m1 (m2 (m3 a)) -> t (t1 (t1' (t3 m1 m2 m3))) a Source

liftTTTTT3 :: (Monad m1, Monad (t1 (t1' (t1'' (t3 m1 m2 m3)))), Monad (t1' (t1'' (t3 m1 m2 m3))), Monad (t1'' (t3 m1 m2 m3)), Monad (t3 m1 m2 m3), Monad2 m2, Monad3 m3, MonadTrans t, MonadTrans t1, MonadTrans t1', MonadTrans t1'', MonadTrans3 t3) => m1 (m2 (m3 a)) -> t (t1 (t1' (t1'' (t3 m1 m2 m3)))) a Source

transdown

class (MonadTrans2 (Trans3Down t3), MonadTrans3 t3) => MonadTrans3Down t3 Source

Associated Types

type Trans3Down t3 :: (* -> *) -> (* -> *) -> * -> * Source

Instances

MonadTrans3Down IdentityT3 Source

type M__ t3 = M_ (Trans3Down t3) Source

type T__ t3 = T_ (Trans3Down t3) Source

fold

class (MonadTrans (T__ t), MonadTrans3 t) => MonadTransFold3 t where Source

Following property holds.

untransfold3 . transfold3 == id

Methods

transfold3 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), MonadTrans t2, MonadTrans_ t2, MonadTrans t3, MonadTrans_ t3) => t m1 (TransDown t2) (TransDown t3) a -> T__ t (t3 (t2 m1)) a Source

untransfold3 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), MonadTrans t2, MonadTrans_ t2, MonadTrans t3, MonadTrans_ t3) => T__ t (t3 (t2 m1)) a -> t m1 (TransDown t2) (TransDown t3) a Source

Instances

MonadTransFold3 IdentityT3 Source

cover

class MonadTransCover2 (Trans3Down t3) => MonadTransCover3 t3 where Source

Methods

(|--*|) :: (Monad m1, Monad2 m2, Monad3 m3) => Trans3Down t3 m1 m2 a -> t3 m1 m2 m3 a infixl 3 Source

(|-*-|) :: (Monad m1, Monad2 m2, Monad3 m3) => Trans3Down t3 m1 m3 a -> t3 m1 m2 m3 a infixl 3 Source

(|*--|) :: (Monad m1, Monad2 m2, Monad3 m3) => Trans3Down t3 m2 m3 a -> t3 m1 m2 m3 a infixl 3 Source

Instances

MonadTransCover3 IdentityT3 Source

(|***|) :: (Monad m1, Monad2 m2, Monad3 m3, MonadTransCover3 t3) => M__ t3 a -> t3 m1 m2 m3 a infixl 3 Source

(|-**|) :: (Monad m1, Monad2 m2, Monad3 m3, MonadTransCover3 t3) => T__ t3 m1 a -> t3 m1 m2 m3 a infixl 3 Source

(|*-*|) :: (Monad m1, Monad2 m2, Monad3 m3, MonadTransCover3 t3) => T__ t3 m2 a -> t3 m1 m2 m3 a infixl 3 Source

(|**-|) :: (Monad m1, Monad2 m2, Monad3 m3, MonadTransCover3 t3) => T__ t3 m3 a -> t3 m1 m2 m3 a infixl 3 Source

other

trans3 :: (Monad m, Monad (t2 (t1 m)), Monad (t1 m), MonadTrans_ t1, MonadTrans_ t2, MonadTrans_ t3) => m (TransDown t1 (TransDown t2 (TransDown t3 a))) -> t3 (t2 (t1 m)) a Source

untrans3 :: (Monad m, Monad (t2 (t1 m)), Monad (t1 m), MonadTrans_ t1, MonadTrans_ t2, MonadTrans_ t3) => t3 (t2 (t1 m)) a -> m (TransDown t1 (TransDown t2 (TransDown t3 a))) Source

Level-4

lift

class MonadTrans4 t where Source

Methods

liftT4 :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4) => m1 (m2 (m3 (m4 a))) -> t m1 m2 m3 m4 a Source

Instances

MonadTrans4 IdentityT4 Source

transdown

class (MonadTrans3 (Trans4Down t4), MonadTrans4 t4) => MonadTrans4Down t4 Source

Associated Types

type Trans4Down t4 :: (* -> *) -> (* -> *) -> (* -> *) -> * -> * Source

Instances

MonadTrans4Down IdentityT4 Source

type M___ t4 = M__ (Trans4Down t4) Source

type T___ t4 = T__ (Trans4Down t4) Source

type T2__ t4 = Trans3Down (Trans4Down t4) Source

fold

class (MonadTrans (T___ t), MonadTrans4 t) => MonadTransFold4 t where Source

Following property holds.

untransfold4 . transfold4 == id

Methods

transfold4 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), Monad (t4 (t3 (t2 m1))), MonadTrans t2, MonadTrans_ t2, MonadTrans t3, MonadTrans_ t3, MonadTrans t4, MonadTrans_ t4) => t m1 (TransDown t2) (TransDown t3) (TransDown t4) a -> T___ t (t4 (t3 (t2 m1))) a Source

untransfold4 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), Monad (t4 (t3 (t2 m1))), MonadTrans t2, MonadTrans_ t2, MonadTrans t3, MonadTrans_ t3, MonadTrans t4, MonadTrans_ t4) => T___ t (t4 (t3 (t2 m1))) a -> t m1 (TransDown t2) (TransDown t3) (TransDown t4) a Source

Instances

MonadTransFold4 IdentityT4 Source

cover

class MonadTransCover3 (Trans4Down t4) => MonadTransCover4 t4 where Source

Methods

(|---*|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4) => Trans4Down t4 m1 m2 m3 a -> t4 m1 m2 m3 m4 a infixl 3 Source

(|--*-|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4) => Trans4Down t4 m1 m2 m4 a -> t4 m1 m2 m3 m4 a infixl 3 Source

(|-*--|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4) => Trans4Down t4 m1 m3 m4 a -> t4 m1 m2 m3 m4 a infixl 3 Source

(|*---|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4) => Trans4Down t4 m2 m3 m4 a -> t4 m1 m2 m3 m4 a infixl 3 Source

Instances

MonadTransCover4 IdentityT4 Source

(|****|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, MonadTransCover4 t4) => M___ t4 a -> t4 m1 m2 m3 m4 a infixl 3 Source

(|--**|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, MonadTransCover4 t4) => T2__ t4 m1 m2 a -> t4 m1 m2 m3 m4 a infixl 3 Source

(|-*-*|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, MonadTransCover4 t4) => T2__ t4 m1 m3 a -> t4 m1 m2 m3 m4 a infixl 3 Source

(|-**-|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, MonadTransCover4 t4) => T2__ t4 m1 m4 a -> t4 m1 m2 m3 m4 a infixl 3 Source

(|*-*-|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, MonadTransCover4 t4) => T2__ t4 m2 m4 a -> t4 m1 m2 m3 m4 a infixl 3 Source

(|**--|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, MonadTransCover4 t4) => T2__ t4 m3 m4 a -> t4 m1 m2 m3 m4 a infixl 3 Source

(|*--*|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, MonadTransCover4 t4) => T2__ t4 m2 m3 a -> t4 m1 m2 m3 m4 a infixl 3 Source

(|-***|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, MonadTransCover4 t4) => T___ t4 m1 a -> t4 m1 m2 m3 m4 a infixl 3 Source

(|*-**|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, MonadTransCover4 t4) => T___ t4 m2 a -> t4 m1 m2 m3 m4 a infixl 3 Source

(|**-*|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, MonadTransCover4 t4) => T___ t4 m3 a -> t4 m1 m2 m3 m4 a infixl 3 Source

(|***-|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, MonadTransCover4 t4) => T___ t4 m4 a -> t4 m1 m2 m3 m4 a infixl 3 Source

other

trans4 :: (Monad m, Monad (t3 (t2 (t1 m))), Monad (t2 (t1 m)), Monad (t1 m), MonadTrans_ t1, MonadTrans_ t2, MonadTrans_ t3, MonadTrans_ t4) => m (TransDown t1 (TransDown t2 (TransDown t3 (TransDown t4 a)))) -> t4 (t3 (t2 (t1 m))) a Source

untrans4 :: (Monad m, Monad (t3 (t2 (t1 m))), Monad (t2 (t1 m)), Monad (t1 m), MonadTrans_ t1, MonadTrans_ t2, MonadTrans_ t3, MonadTrans_ t4) => t4 (t3 (t2 (t1 m))) a -> m (TransDown t1 (TransDown t2 (TransDown t3 (TransDown t4 a)))) Source

Level-5

lift

class MonadTrans5 t where Source

Methods

liftT5 :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5) => m1 (m2 (m3 (m4 (m5 a)))) -> t m1 m2 m3 m4 m5 a Source

Instances

MonadTrans5 IdentityT5 Source

transdown

class (MonadTrans4 (Trans5Down t5), MonadTrans5 t5) => MonadTrans5Down t5 Source

Associated Types

type Trans5Down t5 :: (* -> *) -> (* -> *) -> (* -> *) -> (* -> *) -> * -> * Source

Instances

MonadTrans5Down IdentityT5 Source

type M____ t5 = M___ (Trans5Down t5) Source

type T____ t5 = T___ (Trans5Down t5) Source

type T2___ t5 = T2__ (Trans5Down t5) Source

type T3___ t5 = Trans4Down (Trans5Down t5) Source

fold

class (MonadTrans (T____ t), MonadTrans5 t) => MonadTransFold5 t where Source

Following property holds.

untransfold5 . transfold5 == id

Methods

transfold5 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), Monad (t4 (t3 (t2 m1))), Monad (t5 (t4 (t3 (t2 m1)))), MonadTrans t2, MonadTrans_ t2, MonadTrans t3, MonadTrans_ t3, MonadTrans t4, MonadTrans_ t4, MonadTrans t5, MonadTrans_ t5) => t m1 (TransDown t2) (TransDown t3) (TransDown t4) (TransDown t5) a -> T____ t (t5 (t4 (t3 (t2 m1)))) a Source

untransfold5 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), Monad (t4 (t3 (t2 m1))), Monad (t5 (t4 (t3 (t2 m1)))), MonadTrans t2, MonadTrans_ t2, MonadTrans t3, MonadTrans_ t3, MonadTrans t4, MonadTrans_ t4, MonadTrans t5, MonadTrans_ t5) => T____ t (t5 (t4 (t3 (t2 m1)))) a -> t m1 (TransDown t2) (TransDown t3) (TransDown t4) (TransDown t5) a Source

Instances

MonadTransFold5 IdentityT5 Source

cover

class MonadTransCover4 (Trans5Down t5) => MonadTransCover5 t5 where Source

Methods

(|----*|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5) => Trans5Down t5 m1 m2 m3 m4 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|---*-|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5) => Trans5Down t5 m1 m2 m3 m5 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|--*--|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5) => Trans5Down t5 m1 m2 m4 m5 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|-*---|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5) => Trans5Down t5 m1 m3 m4 m5 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|*----|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5) => Trans5Down t5 m2 m3 m4 m5 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

Instances

MonadTransCover5 IdentityT5 Source

(|---**|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T3___ t5 m1 m2 m3 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|--*-*|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T3___ t5 m1 m2 m4 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|-*--*|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T3___ t5 m1 m3 m4 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|*---*|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T3___ t5 m2 m3 m4 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|*--*-|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T3___ t5 m2 m3 m5 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|*-*--|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T3___ t5 m2 m4 m5 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|**---|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T3___ t5 m3 m4 m5 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|--***|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T2___ t5 m1 m2 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|-*-**|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T2___ t5 m1 m3 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|*--**|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T2___ t5 m2 m3 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|*-*-*|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T2___ t5 m2 m4 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|**--*|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T2___ t5 m3 m4 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|**-*-|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T2___ t5 m3 m5 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|***--|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T2___ t5 m4 m5 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|-****|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T____ t5 m1 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|*-***|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T____ t5 m2 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|**-**|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T____ t5 m3 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|***-*|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T____ t5 m4 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

(|****-|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5, MonadTransCover5 t5) => T____ t5 m5 a -> t5 m1 m2 m3 m4 m5 a infixl 3 Source

other

trans5 :: (Monad m, Monad (t4 (t3 (t2 (t1 m)))), Monad (t3 (t2 (t1 m))), Monad (t2 (t1 m)), Monad (t1 m), MonadTrans_ t1, MonadTrans_ t2, MonadTrans_ t3, MonadTrans_ t4, MonadTrans_ t5) => m (TransDown t1 (TransDown t2 (TransDown t3 (TransDown t4 (TransDown t5 a))))) -> t5 (t4 (t3 (t2 (t1 m)))) a Source

untrans5 :: (Monad m, Monad (t4 (t3 (t2 (t1 m)))), Monad (t3 (t2 (t1 m))), Monad (t2 (t1 m)), Monad (t1 m), MonadTrans_ t1, MonadTrans_ t2, MonadTrans_ t3, MonadTrans_ t4, MonadTrans_ t5) => t5 (t4 (t3 (t2 (t1 m)))) a -> m (TransDown t1 (TransDown t2 (TransDown t3 (TransDown t4 (TransDown t5 a))))) Source

Level-2 example

Here is a monad transformer example how to implement Ackermann function, improved to stop within a certain limit of time, with ReaderT-IdentityT2-IO-Maybe monad, a level-2 monad-transformation.

import DeepControl.Applicative
import DeepControl.Commutative (commute)
import DeepControl.Monad ((>-))
import DeepControl.Monad.Morph ((|>|))
import DeepControl.Monad.Trans (liftTT2, transfold2, untransfold2)
import DeepControl.Monad.Trans.Identity
import DeepControl.Monad.Trans.Reader
import Control.Monad.Trans.Maybe

import System.Timeout (timeout)

type TimeLimit = Int

ackermannTimeLimit :: TimeLimit -> Int -> Int -> 
                      IO (Maybe Int)                     -- IO-Maybe Monad
ackermannTimeLimit timelimit x y = timeout timelimit (ackermannIO x y)
  where
    ackermannIO :: Int -> Int -> IO Int
    ackermannIO 0 n = (*:) $ n + 1
    ackermannIO m n | m > 0 && n == 0 = ackermannIO (m-1) 1
                    | m > 0 && n > 0  = ackermannIO m (n-1) >>= ackermannIO (m-1)
 
ackermann :: Int -> Int -> 
             ReaderT TimeLimit (IdentityT2 IO Maybe) Int -- ReaderT-IdentityT2-IO-Maybe monad
ackermann x y = do
    timelimit <- ask
    liftTT2 $ ackermannTimeLimit timelimit x y           -- lift IO-Maybe function to ReaderT-IdentityT2-IO-Maybe function

calc_ackermann :: TimeLimit -> Int -> Int -> IO (Maybe Int)
calc_ackermann timelimit x y = ackermann x y >- \r -> runReaderT r timelimit
                                             >- runIdentityT2

-- λ> commute $ calc_ackermann 1000 |$> [0..4] |* 4
-- [Just 5,Just 6,Just 11,Just 125,Nothing]

ackermann' :: Int -> Int -> 
              ReaderT TimeLimit (MaybeT IO) Int                -- ReaderT-MaybeT-IO monad
ackermann' x y = (runIdentityT . transfold2) |>| ackermann x y -- You can get usual ReaderT-MaybeT-IO function from ReaderT-IdentityT2-IO-Maybe function

ackermann'' :: Int -> Int -> 
               ReaderT TimeLimit (IdentityT2 IO Maybe) Int      -- ReaderT-IdentityT2-IO-Maybe monad
ackermann'' x y = (untransfold2 . IdentityT) |>| ackermann' x y -- You can get ReaderT-IdentityT2-IO-Maybe function from usual ReaderT-MaybeT-IO function

Level-2 example2

Here is a monad transformer example showing how to use cover functions.

import DeepControl.Applicative ((|$>))
import DeepControl.Monad (Monad2)
import DeepControl.Monad.Morph ((|>|))
import DeepControl.Monad.Trans (liftT, (|*|), (|-*|), (|*-|))
import DeepControl.Monad.Trans.Writer
import DeepControl.Monad.Trans.Identity
import DeepControl.Monad.Trans.State

tick :: State Int ()
tick = modify (+1)

tock                         ::                   StateT Int IO ()
tock = do
    (|*|) tick               :: (Monad      m) => StateT Int m  ()
    liftT $ putStrLn "Tock!" :: (MonadTrans t) => t          IO ()

-- λ> runStateT tock 0
-- Tock!
-- ((),1)

save    :: StateT Int (Writer [Int]) ()
save = do
    n <- get
    liftT $ tell [n]

program ::               StateT Int (IdentityT2 IO (Writer [Int])) ()
program = replicateM_ 4 $ do
    ((|-*|).liftT) |>| tock
        :: (Monad2 m) => StateT Int (IdentityT2 IO m             ) ()
    ((|*-|).liftT) |>| save
        :: (Monad  m) => StateT Int (IdentityT2 m  (Writer [Int])) ()

-- λ> execWriter |$> runIdentityT2 (runStateT program 0)
-- Tock!
-- Tock!
-- Tock!
-- Tock!
-- [1,2,3,4]