DeepControl.Monad.Trans

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.

Level-1

trans-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)

Minimal complete definition

lift

Methods

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

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

Instances

MonadTrans ListT

Methods

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

MonadTrans MaybeT

Methods

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

MonadTrans (ErrorT e)

Methods

lift :: Monad m => m a -> ErrorT e m a

MonadTrans (ExceptT e)

Methods

lift :: Monad m => m a -> ExceptT e m a

MonadTrans (StateT s)

Methods

lift :: Monad m => m a -> StateT s m a

MonadTrans (StateT s)

Methods

lift :: Monad m => m a -> StateT s m a

Monoid w => MonadTrans (WriterT w)

Methods

lift :: Monad m => m a -> WriterT w m a

Monoid w => MonadTrans (WriterT w)

Methods

lift :: Monad m => m a -> WriterT w m a

MonadTrans (IdentityT *)

Methods

lift :: Monad m => m a -> IdentityT * m a

MonadTrans (ReaderT * r)

Methods

lift :: Monad m => m a -> ReaderT * r m a

Monoid w => MonadTrans (RWST r w s)

Methods

lift :: Monad m => m a -> RWST r w s m a

Monoid w => MonadTrans (RWST r w s)

Methods

lift :: Monad m => m a -> RWST r w s m a

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

Alias to lift

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

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

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

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

trans-down

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

Associated Types

type TransDown t1 :: * -> *

Instances

MonadTransDown ListT

Associated Types

type TransDown (ListT :: (* -> *) -> * -> *) :: * -> *

MonadTransDown MaybeT

Associated Types

type TransDown (MaybeT :: (* -> *) -> * -> *) :: * -> *

MonadTransDown (ExceptT e)

Associated Types

type TransDown (ExceptT e :: (* -> *) -> * -> *) :: * -> *

MonadTransDown (StateT s)

Associated Types

type TransDown (StateT s :: (* -> *) -> * -> *) :: * -> *

MonadTransDown (ReaderT * r)

Associated Types

type TransDown (ReaderT * r :: (* -> *) -> * -> *) :: * -> *

Monoid w => MonadTransDown (RWST r w s)

Associated Types

type TransDown (RWST r w s :: (* -> *) -> * -> *) :: * -> *

type M t1 = TransDown t1

trans-cover

class MonadTransDown t1 => MonadTransCover t1 where

Minimal complete definition

(|*|)

Methods

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

Instances

MonadTransCover ListT

Methods

(|*|) :: Monad m1 => TransDown ListT a -> ListT m1 a

MonadTransCover MaybeT

Methods

(|*|) :: Monad m1 => TransDown MaybeT a -> MaybeT m1 a

MonadTransCover (ExceptT e)

Methods

(|*|) :: Monad m1 => TransDown (ExceptT e) a -> ExceptT e m1 a

MonadTransCover (StateT s)

Methods

(|*|) :: Monad m1 => TransDown (StateT s) a -> StateT s m1 a

MonadTransCover (ReaderT * s)

Methods

(|*|) :: Monad m1 => TransDown (ReaderT * s) a -> ReaderT * s m1 a

Monoid w => MonadTransCover (RWST r w s)

Methods

(|*|) :: Monad m1 => TransDown (RWST r w s) a -> RWST r w s m1 a

other

class MonadTrans_ t where

Required only for MonadTransFold2 and MonadTransFold3

Minimal complete definition

trans, untrans

Methods

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

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

Instances

MonadTrans_ ListT

Methods

trans :: Monad m => m (TransDown ListT a) -> ListT m a

untrans :: Monad m => ListT m a -> m (TransDown ListT a)

MonadTrans_ MaybeT

Methods

trans :: Monad m => m (TransDown MaybeT a) -> MaybeT m a

untrans :: Monad m => MaybeT m a -> m (TransDown MaybeT a)

MonadTrans_ (ExceptT e)

Methods

trans :: Monad m => m (TransDown (ExceptT e) a) -> ExceptT e m a

untrans :: Monad m => ExceptT e m a -> m (TransDown (ExceptT e) a)

Level-2

trans-lift

class MonadTrans2 t where

Minimal complete definition

liftT2

Methods

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

Instances

MonadTrans2 IdentityT2

Methods

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

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

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

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

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

trans-down

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

Associated Types

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

Instances

MonadTrans2Down IdentityT2

Associated Types

type Trans2Down (IdentityT2 :: (* -> *) -> (* -> *) -> * -> *) :: (* -> *) -> * -> *

type M_ t2 = TransDown (T_ t2)

type T_ t2 = Trans2Down t2

trans-fold

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

Following property holds.

untransfold2 . transfold2 == id

Minimal complete definition

transfold2, untransfold2

Methods

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

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

Instances

MonadTransFold2 IdentityT2

Methods

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

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

trans-cover

class MonadTransCover (Trans2Down t2) => MonadTransCover2 t2 where

Minimal complete definition

(|-*|), (|*-|)

Methods

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

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

Instances

MonadTransCover2 IdentityT2

Methods

(|-*|) :: (Monad m1, Monad2 m2) => Trans2Down IdentityT2 m1 a -> IdentityT2 m1 m2 a

(|*-|) :: (Monad m1, Monad2 m2) => Trans2Down IdentityT2 m2 a -> IdentityT2 m1 m2 a

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

other

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

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

Level-3

trans-lift

class MonadTrans3 t where

Minimal complete definition

liftT3

Methods

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

Instances

MonadTrans3 IdentityT3

Methods

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

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

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

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

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

trans-down

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

Associated Types

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

Instances

MonadTrans3Down IdentityT3

Associated Types

type Trans3Down (IdentityT3 :: (* -> *) -> (* -> *) -> (* -> *) -> * -> *) :: (* -> *) -> (* -> *) -> * -> *

type M__ t3 = M_ (Trans3Down t3)

type T__ t3 = T_ (Trans3Down t3)

trans-fold

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

Following property holds.

untransfold3 . transfold3 == id

Minimal complete definition

transfold3, untransfold3

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

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

Instances

MonadTransFold3 IdentityT3

Methods

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

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

trans-cover

class MonadTransCover2 (Trans3Down t3) => MonadTransCover3 t3 where

Minimal complete definition

(|--*|), (|-*-|), (|*--|)

Methods

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

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

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

Instances

MonadTransCover3 IdentityT3

Methods

(|--*|) :: (Monad m1, Monad2 m2, Monad3 m3) => Trans3Down IdentityT3 m1 m2 a -> IdentityT3 m1 m2 m3 a

(|-*-|) :: (Monad m1, Monad2 m2, Monad3 m3) => Trans3Down IdentityT3 m1 m3 a -> IdentityT3 m1 m2 m3 a

(|*--|) :: (Monad m1, Monad2 m2, Monad3 m3) => Trans3Down IdentityT3 m2 m3 a -> IdentityT3 m1 m2 m3 a

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

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

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

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

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

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

Level-4

trans-lift

class MonadTrans4 t where

Minimal complete definition

liftT4

Methods

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

Instances

MonadTrans4 IdentityT4

Methods

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

trans-down

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

Associated Types

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

Instances

MonadTrans4Down IdentityT4

Associated Types

type Trans4Down (IdentityT4 :: (* -> *) -> (* -> *) -> (* -> *) -> (* -> *) -> * -> *) :: (* -> *) -> (* -> *) -> (* -> *) -> * -> *

type M___ t4 = M__ (Trans4Down t4)

type T___ t4 = T__ (Trans4Down t4)

type T2__ t4 = Trans3Down (Trans4Down t4)

trans-fold

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

Following property holds.

untransfold4 . transfold4 == id

Minimal complete definition

transfold4, untransfold4

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

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

Instances

MonadTransFold4 IdentityT4

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) => IdentityT4 m1 (TransDown t2) (TransDown t3) (TransDown t4) a -> T___ IdentityT4 (t4 (t3 (t2 m1))) a

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___ IdentityT4 (t4 (t3 (t2 m1))) a -> IdentityT4 m1 (TransDown t2) (TransDown t3) (TransDown t4) a

trans-cover

class MonadTransCover3 (Trans4Down t4) => MonadTransCover4 t4 where

Minimal complete definition

(|---*|), (|--*-|), (|-*--|), (|*---|)

Methods

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

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

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

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

Instances

MonadTransCover4 IdentityT4

Methods

(|---*|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4) => Trans4Down IdentityT4 m1 m2 m3 a -> IdentityT4 m1 m2 m3 m4 a

(|--*-|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4) => Trans4Down IdentityT4 m1 m2 m4 a -> IdentityT4 m1 m2 m3 m4 a

(|-*--|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4) => Trans4Down IdentityT4 m1 m3 m4 a -> IdentityT4 m1 m2 m3 m4 a

(|*---|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4) => Trans4Down IdentityT4 m2 m3 m4 a -> IdentityT4 m1 m2 m3 m4 a

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

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

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

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

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

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

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

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

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

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

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

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

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

Level-5

trans-lift

class MonadTrans5 t where

Minimal complete definition

liftT5

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

Instances

MonadTrans5 IdentityT5

Methods

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

trans-down

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

Associated Types

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

Instances

MonadTrans5Down IdentityT5

Associated Types

type Trans5Down (IdentityT5 :: (* -> *) -> (* -> *) -> (* -> *) -> (* -> *) -> (* -> *) -> * -> *) :: (* -> *) -> (* -> *) -> (* -> *) -> (* -> *) -> * -> *

type M____ t5 = M___ (Trans5Down t5)

type T____ t5 = T___ (Trans5Down t5)

type T2___ t5 = T2__ (Trans5Down t5)

type T3___ t5 = Trans4Down (Trans5Down t5)

trans-fold

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

Following property holds.

untransfold5 . transfold5 == id

Minimal complete definition

transfold5, untransfold5

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

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

Instances

MonadTransFold5 IdentityT5

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) => IdentityT5 m1 (TransDown t2) (TransDown t3) (TransDown t4) (TransDown t5) a -> T____ IdentityT5 (t5 (t4 (t3 (t2 m1)))) a

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____ IdentityT5 (t5 (t4 (t3 (t2 m1)))) a -> IdentityT5 m1 (TransDown t2) (TransDown t3) (TransDown t4) (TransDown t5) a

trans-cover

class MonadTransCover4 (Trans5Down t5) => MonadTransCover5 t5 where

Minimal complete definition

(|----*|), (|---*-|), (|--*--|), (|-*---|), (|*----|)

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

(|---*-|) :: (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

(|--*--|) :: (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

(|-*---|) :: (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

(|*----|) :: (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

Instances

MonadTransCover5 IdentityT5

Methods

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

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

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

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

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

(|---**|) :: (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

(|--*-*|) :: (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

(|-*--*|) :: (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

(|*---*|) :: (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

(|*--*-|) :: (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

(|*-*--|) :: (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

(|**---|) :: (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

(|--***|) :: (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

(|-*-**|) :: (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

(|*--**|) :: (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

(|*-*-*|) :: (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

(|**--*|) :: (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

(|**-*-|) :: (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

(|***--|) :: (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

(|-****|) :: (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

(|*-***|) :: (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

(|**-**|) :: (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

(|***-*|) :: (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

(|****-|) :: (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

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

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

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)

Minimal complete definition

liftIO

Methods

liftIO :: IO a -> m a

Lift a computation from the IO monad.

Instances

MonadIO IO

Methods

liftIO :: IO a -> IO a

MonadIO m => MonadIO (ListT m)

Methods

liftIO :: IO a -> ListT m a

MonadIO m => MonadIO (MaybeT m)

Methods

liftIO :: IO a -> MaybeT m a

(Error e, MonadIO m) => MonadIO (ErrorT e m)

Methods

liftIO :: IO a -> ErrorT e m a

MonadIO m => MonadIO (ExceptT e m)

Methods

liftIO :: IO a -> ExceptT e m a

MonadIO m => MonadIO (StateT s m)

Methods

liftIO :: IO a -> StateT s m a

MonadIO m => MonadIO (StateT s m)

Methods

liftIO :: IO a -> StateT s m a

(Monoid w, MonadIO m) => MonadIO (WriterT w m)

Methods

liftIO :: IO a -> WriterT w m a

(Monoid w, MonadIO m) => MonadIO (WriterT w m)

Methods

liftIO :: IO a -> WriterT w m a

MonadIO m => MonadIO (IdentityT * m)

Methods

liftIO :: IO a -> IdentityT * m a

(MonadIO m1, Monad m1, Monad2 m2) => MonadIO (IdentityT2 m1 m2)

Methods

liftIO :: IO a -> IdentityT2 m1 m2 a

MonadIO m => MonadIO (ReaderT * r m)

Methods

liftIO :: IO a -> ReaderT * r m a

(MonadIO m1, Monad m1, Monad2 m2, Monad3 m3) => MonadIO (IdentityT3 m1 m2 m3)

Methods

liftIO :: IO a -> IdentityT3 m1 m2 m3 a

(Monoid w, MonadIO m) => MonadIO (RWST r w s m)

Methods

liftIO :: IO a -> RWST r w s m a

(Monoid w, MonadIO m) => MonadIO (RWST r w s m)

Methods

liftIO :: IO a -> RWST r w s m a

(MonadIO m1, Monad m1, Monad2 m2, Monad3 m3, Monad4 m4) => MonadIO (IdentityT4 m1 m2 m3 m4)

Methods

liftIO :: IO a -> IdentityT4 m1 m2 m3 m4 a

(MonadIO m1, Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5) => MonadIO (IdentityT5 m1 m2 m3 m4 m5)

Methods

liftIO :: IO a -> IdentityT5 m1 m2 m3 m4 m5 a

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 Control.Monad.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 trans-cover functions.

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

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

tock                         ::                   StateT Int IO ()
tock = do
    (|*|) tick               :: (Monad      m) => StateT Int m  ()  -- (|*|) is the level-1 trans-cover function, analogous for (*:)
    liftT $ putStrLn "Tock!" :: (MonadTrans t) => t          IO ()  -- 'liftT' is the level-1 trans-lift function, alias to 'lift'

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

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

program ::               StateT Int (IdentityT2 IO (Writer [Int])) ()  -- StateT-IdentityT2-IO-Writer monad, a level-2 monad-transform
program = replicateM_ 4 $ do
    ((|-*|).liftT) |>| tock                                            -- (|-*|) is a level-2 trans-cover function, analogous for (-*)
        :: (Monad2 m) => StateT Int (IdentityT2 IO m             ) ()
    ((|*-|).liftT) |>| save                                            -- (|*-|) is a level-2 trans-cover function, analogous for (*:)
        :: (Monad  m) => StateT Int (IdentityT2 m  (Writer [Int])) ()

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