DeepControl.Monad.Morph

This module enables you to program in Monad-Morphic style for more deeper level than the usual Control.Monad.Morph module expresses. You would realize exactly what more deeper level means by reading the example codes, which are attached on the page bottom.

Documentation

module Control.Monad.Morph

SinkT

class MonadTrans s => SinkT s where

Methods

sinkT :: (Monad m, MMonad t, MonadTrans_ x t, Traversable x) => s (t m) a -> t (s m) a

Instances

SinkT ListT

SinkT MaybeT

SinkT IdentityT

SinkT (ExceptT e)

Monoid w => SinkT (WriterT w)

sinkT2 :: (Monad m, Monad (s (t2 m)), Monad (t2 m), MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2, SinkT s, MMonad t1, MMonad t2) => s (t1 (t2 m)) a -> t1 (t2 (s m)) a

sinkT3 :: (Monad m, Monad (s (t2 (t3 m))), Monad (s (t3 m)), Monad (t2 (t3 m)), Monad (t3 m), MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2, MonadTrans_ x3 t3, Traversable x3, SinkT s, MMonad t1, MMonad t2, MMonad t3) => s (t1 (t2 (t3 m))) a -> t1 (t2 (t3 (s m))) a

sinkT4 :: (Monad m, Monad (s (t2 (t3 (t4 m)))), Monad (s (t3 (t4 m))), Monad (s (t4 m)), Monad (t2 (t3 (t4 m))), Monad (t3 (t4 m)), Monad (t4 m), MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2, MonadTrans_ x3 t3, Traversable x3, MonadTrans_ x4 t4, Traversable x4, MMonad t1, MMonad t2, MMonad t3, MMonad t4, SinkT s) => s (t1 (t2 (t3 (t4 m)))) a -> t1 (t2 (t3 (t4 (s m)))) a

Level-1

trans-map

(|>|) :: (Monad m, MFunctor t) => (forall a. m a -> n a) -> t m b -> t n b infixl 4

Alias to hoist.

(|<|) :: (Monad m, MFunctor t) => t m b -> (forall a. m a -> n a) -> t n b infixl 4

Equivalent to (|>|) with the arguments flipped.

trans-cover

(|*|) :: (Monad m, MonadTrans t) => m a -> t m a infixl 5

Alias to lift

Level-2

trans-bind

(|>>=) :: (Monad n, Monad m, Monad (t2 n), Monad (t2 (t2 n)), MonadTrans_ x t1, Traversable x, MMonad t1, MMonad t2, SinkT t2) => t1 (t2 m) b -> (forall a. m a -> t1 (t2 n) a) -> t1 (t2 n) b infixr 3

The level-2 trans-bind function, analogous to (>>=)

trans-map

(|>>|) :: (Monad m, Monad (t2 m), MFunctor t1, MFunctor t2) => (forall a. m a -> n a) -> t1 (t2 m) b -> t1 (t2 n) b infixl 4

(|<<|) :: (Monad m, Monad (t2 m), MFunctor t1, MFunctor t2) => t1 (t2 m) b -> (forall a. m a -> n a) -> t1 (t2 n) b infixl 4

trans-cover

(|**|) :: (Monad m, MonadTrans t1, MonadTrans t2, Monad (t2 m)) => m a -> t1 (t2 m) a infixl 5

(|-*|) :: (Monad m, MonadTrans t1, MonadTrans t2, MFunctor t1) => t1 m a -> t1 (t2 m) a infixl 5

Level-3

trans-bind

(|>>>=) :: (Monad n, Monad (t3 n), Monad m, Monad (t3 m), Monad (t2 (t3 n)), Monad (t2 (t3 (t3 n))), Monad (t3 (t3 n)), Monad (t3 (t2 (t3 n))), Monad (t2 (t2 (t3 n))), MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2, SinkT t2, SinkT t3, MMonad t1, MMonad t2, MMonad t3) => t1 (t2 (t3 m)) b -> (forall a. m a -> t1 (t2 (t3 n)) a) -> t1 (t2 (t3 n)) b infixr 3

trans-map

(|>>>|) :: (Monad m, Monad (t3 m), Monad (t2 (t3 m)), MFunctor t1, MFunctor t2, MFunctor t3) => (forall a. m a -> n a) -> t1 (t2 (t3 m)) b -> t1 (t2 (t3 n)) b infixl 4

(|<<<|) :: (Monad m, Monad (t3 m), Monad (t2 (t3 m)), MFunctor t1, MFunctor t2, MFunctor t3) => t1 (t2 (t3 m)) b -> (forall a. m a -> n a) -> t1 (t2 (t3 n)) b infixl 4

trans-cover

(|***|) :: (Monad m, Monad (t2 (t3 m)), Monad (t3 m), MonadTrans t1, MonadTrans t2, MonadTrans t3) => m a -> t1 (t2 (t3 m)) a infixl 5

(|--*|) :: (Monad m, Monad (t2 m), MonadTrans t1, MonadTrans t2, MonadTrans t3, MFunctor t1, MFunctor t2) => t1 (t2 m) a -> t1 (t2 (t3 m)) a infixl 5

(|-**|) :: (Monad m, Monad (t2 (t3 m)), Monad (t3 m), MonadTrans t1, MonadTrans t2, MonadTrans t3, MFunctor t1) => t1 m a -> t1 (t2 (t3 m)) a infixl 5

(|*-*|) :: (Monad m, Monad (t3 m), Monad (t2 (t3 m)), MonadTrans t1, MonadTrans t2, MonadTrans t3, MFunctor t2) => t2 m a -> t1 (t2 (t3 m)) a infixl 5

Level-4

trans-bind

(|>>>>=) :: (Monad n, Monad (t4 n), Monad (t4 m), Monad m, Monad (t2 (t3 (t4 n))), Monad (t2 (t3 (t4 (t4 n)))), Monad (t2 (t2 (t3 (t4 n)))), Monad (t3 (t4 n)), Monad (t3 (t4 (t4 n))), Monad (t4 (t4 n)), Monad (t4 (t2 (t3 (t4 n)))), Monad (t2 (t3 (t3 (t4 n)))), Monad (t4 (t3 (t4 n))), Monad (t2 (t4 n)), Monad (t3 (t2 (t3 (t4 n)))), Monad (t3 (t3 (t4 n))), Monad (t3 (t4 m)), MonadTrans_ x1 t1, Traversable x1, MonadTrans_ x2 t2, Traversable x2, MonadTrans_ x3 t3, Traversable x3, SinkT t2, SinkT t3, SinkT t4, MMonad t1, MMonad t2, MMonad t3, MMonad t4) => t1 (t2 (t3 (t4 m))) b -> (forall a. m a -> t1 (t2 (t3 (t4 n))) a) -> t1 (t2 (t3 (t4 n))) b infixr 4

trans-map

(|>>>>|) :: (Monad m, Monad (t4 m), Monad (t3 (t4 m)), Monad (t2 (t3 (t4 m))), MFunctor t1, MFunctor t2, MFunctor t3, MFunctor t4) => (forall a. m a -> n a) -> t1 (t2 (t3 (t4 m))) b -> t1 (t2 (t3 (t4 n))) b infixl 4

(|<<<<|) :: (Monad m, Monad (t4 m), Monad (t3 (t4 m)), Monad (t2 (t3 (t4 m))), MFunctor t1, MFunctor t2, MFunctor t3, MFunctor t4) => t1 (t2 (t3 (t4 m))) b -> (forall a. m a -> n a) -> t1 (t2 (t3 (t4 n))) b infixl 4

trans-cover

(|****|) :: (Monad m, Monad (t2 (t3 (t4 m))), Monad (t3 (t4 m)), Monad (t4 m), MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) => m a -> t1 (t2 (t3 (t4 m))) a infixl 5

(|---*|) :: (Monad m, Monad (t2 (t3 m)), Monad (t3 m), MFunctor t1, MFunctor t2, MFunctor t3, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) => t1 (t2 (t3 m)) a -> t1 (t2 (t3 (t4 m))) a infixl 5

(|--**|) :: (Monad m, Monad (t2 m), Monad (t4 m), MFunctor t1, MFunctor t2, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) => t1 (t2 m) a -> t1 (t2 (t3 (t4 m))) a infixl 5

(|-*-*|) :: (Monad m, Monad (t3 m), Monad (t3 (t4 m)), Monad (t4 m), MFunctor t1, MFunctor t3, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) => t1 (t3 m) a -> t1 (t2 (t3 (t4 m))) a infixl 5

(|*--*|) :: (Monad m, Monad (t3 m), Monad (t2 (t3 (t4 m))), Monad (t2 (t3 m)), MFunctor t2, MFunctor t3, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) => t2 (t3 m) a -> t1 (t2 (t3 (t4 m))) a

(|-***|) :: (Monad m, Monad (t3 (t4 m)), Monad (t4 m), MFunctor t1, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) => t1 m a -> t1 (t2 (t3 (t4 m))) a infixl 5

(|*-**|) :: (Monad m, Monad (t2 (t3 (t4 m))), Monad (t3 (t4 m)), Monad (t4 m), MFunctor t2, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) => t2 m a -> t1 (t2 (t3 (t4 m))) a infixl 5

(|**-*|) :: (Monad m, Monad (t2 (t3 (t4 m))), Monad (t3 (t4 m)), MFunctor t3, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4) => t3 m a -> t1 (t2 (t3 (t4 m))) a infixl 5

Level-5

trans-map

(|>>>>>|) :: (Monad m, Monad (t5 m), Monad (t4 (t5 m)), Monad (t3 (t4 (t5 m))), Monad (t2 (t3 (t4 (t5 m)))), MFunctor t1, MFunctor t2, MFunctor t3, MFunctor t4, MFunctor t5) => (forall a. m a -> n a) -> t1 (t2 (t3 (t4 (t5 m)))) b -> t1 (t2 (t3 (t4 (t5 n)))) b infixl 4

(|<<<<<|) :: (Monad m, Monad (t5 m), Monad (t4 (t5 m)), Monad (t3 (t4 (t5 m))), Monad (t2 (t3 (t4 (t5 m)))), MFunctor t1, MFunctor t2, MFunctor t3, MFunctor t4, MFunctor t5) => t1 (t2 (t3 (t4 (t5 m)))) b -> (forall a. m a -> n a) -> t1 (t2 (t3 (t4 (t5 n)))) b infixl 4

trans-cover

(|*****|) :: (Monad m, Monad (t2 (t3 (t4 (t5 m)))), Monad (t3 (t4 (t5 m))), Monad (t4 (t5 m)), Monad (t5 m), MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => m a -> t1 (t2 (t3 (t4 (t5 m)))) a infixl 5

(|----*|) :: (Monad m, Monad (t2 (t3 (t4 m))), Monad (t3 (t4 m)), Monad (t4 m), MFunctor t1, MFunctor t2, MFunctor t3, MFunctor t4, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => t1 (t2 (t3 (t4 m))) a -> t1 (t2 (t3 (t4 (t5 m)))) a infixl 5

(|---**|) :: (Monad m, Monad (t2 (t3 m)), Monad (t3 m), Monad (t5 m), MFunctor t1, MFunctor t2, MFunctor t3, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => t1 (t2 (t3 m)) a -> t1 (t2 (t3 (t4 (t5 m)))) a infixl 5

(|--*-*|) :: (Monad m, Monad (t2 (t4 m)), Monad (t4 m), Monad (t4 (t5 m)), Monad (t5 m), MFunctor t1, MFunctor t2, MFunctor t4, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => t1 (t2 (t4 m)) a -> t1 (t2 (t3 (t4 (t5 m)))) a infixl 5

(|-*--*|) :: (Monad m, Monad (t3 (t4 m)), Monad (t4 m), Monad (t3 (t4 (t5 m))), MFunctor t1, MFunctor t3, MFunctor t4, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => t1 (t3 (t4 m)) a -> t1 (t2 (t3 (t4 (t5 m)))) a infixl 5

(|*---*|) :: (Monad m, Monad (t3 (t4 m)), Monad (t4 m), Monad (t2 (t3 (t4 (t5 m)))), MFunctor t2, MFunctor t3, MFunctor t4, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => t2 (t3 (t4 m)) a -> t1 (t2 (t3 (t4 (t5 m)))) a infixl 5

(|--***|) :: (Monad m, Monad (t2 m), Monad (t4 (t5 m)), Monad (t5 m), MFunctor t1, MFunctor t2, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => t1 (t2 m) a -> t1 (t2 (t3 (t4 (t5 m)))) a infixl 5

(|-*-**|) :: (Monad m, Monad (t3 m), Monad (t3 (t4 (t5 m))), Monad (t4 (t5 m)), Monad (t5 m), MFunctor t1, MFunctor t3, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => t1 (t3 m) a -> t1 (t2 (t3 (t4 (t5 m)))) a infixl 5

(|*--**|) :: (Monad m, Monad (t3 m), Monad (t2 (t3 (t4 (t5 m)))), Monad (t5 m), MFunctor t2, MFunctor t3, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => t2 (t3 m) a -> t1 (t2 (t3 (t4 (t5 m)))) a infixl 5

(|*-*-*|) :: (Monad m, Monad (t4 m), Monad (t2 (t3 (t4 (t5 m)))), Monad (t4 (t5 m)), Monad (t5 m), MFunctor t2, MFunctor t4, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => t2 (t4 m) a -> t1 (t2 (t3 (t4 (t5 m)))) a infixl 5

(|-**-*|) :: (Monad m, Monad (t4 m), Monad (t3 (t4 (t5 m))), Monad (t4 (t5 m)), Monad (t5 m), MFunctor t1, MFunctor t4, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => t1 (t4 m) a -> t1 (t2 (t3 (t4 (t5 m)))) a infixl 5

(|**--*|) :: (Monad m, Monad (t4 m), Monad (t2 (t3 (t4 (t5 m)))), Monad (t3 (t4 (t5 m))), Monad (t3 (t4 m)), MFunctor t3, MFunctor t4, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => t3 (t4 m) a -> t1 (t2 (t3 (t4 (t5 m)))) a infixl 5

(|-****|) :: (Monad m, Monad (t3 (t4 (t5 m))), Monad (t4 (t5 m)), Monad (t5 m), MFunctor t1, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => t1 m a -> t1 (t2 (t3 (t4 (t5 m)))) a infixl 5

(|*-***|) :: (Monad m, Monad (t2 (t3 (t4 (t5 m)))), Monad (t4 (t5 m)), Monad (t5 m), MFunctor t2, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => t2 m a -> t1 (t2 (t3 (t4 (t5 m)))) a infixl 5

(|**-**|) :: (Monad m, Monad (t2 (t3 (t4 (t5 m)))), Monad (t3 (t4 (t5 m))), Monad (t4 (t5 m)), Monad (t5 m), MFunctor t3, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => t3 m a -> t1 (t2 (t3 (t4 (t5 m)))) a infixl 5

(|***-*|) :: (Monad m, Monad (t2 (t3 (t4 (t5 m)))), Monad (t3 (t4 (t5 m))), Monad (t4 (t5 m)), MFunctor t4, MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadTrans t5) => t4 m a -> t1 (t2 (t3 (t4 (t5 m)))) a infixl 5

Level-2 example: trans-map

Here is a monad morph example how to use trans-map functions.

import DeepControl.Monad.Morph
import DeepControl.Monad.Trans.State
import DeepControl.Monad.Trans.Writer

-- i.e. :: StateT Int Identity ()
tick    :: State Int ()
tick = modify (+1)

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

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

-- i.e. :: StateT Int (WriterT [Int] Identity) ()
save    :: StateT Int (Writer  [Int]) ()
save = do
    n <- get
    lift $ tell [n]

program ::                   StateT Int (WriterT [Int] IO) ()
program = replicateM_ 4 $ do
    lift |>| tock
        :: (MonadTrans t) => StateT Int (t             IO) ()
    generalize |>>| save                                         -- (|>>|) is the level-2 trans-map function, analogous to (|$>>)
        :: (Monad      m) => StateT Int (WriterT [Int] m ) ()

-- λ> execWriterT (runStateT program 0)
-- Tock!
-- Tock!
-- Tock!
-- Tock!
-- [1,2,3,4]

Level-2 example: trans-cover and trans-bind

Here is a monad morph example how to use trans-cover and trans-bind functions.

import DeepControl.Monad ((>-))
import DeepControl.Monad.Morph ((|>=), (|>>=), (|*|), (|-*|))
import DeepControl.Monad.Trans.Except

import Control.Exception (IOException, try)
import Control.Monad.Trans.Maybe

-----------------------------------------------
-- Level-1 

catchIOError :: IO a -> 
                ExceptT IOException IO a   -- ExceptT-IO monad
catchIOError io = ExceptT $ (try io)

viewFile :: IO ()                          -- IO monad
viewFile = do
    str <- readFile "test.txt"        
    putStr str

program :: ExceptT IOException IO ()       -- ExceptT-IO monad
program = (|*|) viewFile |>= catchIOError  -- (|*|) is the level-1 trans-cover function, alias to 'lift', analogous to (.*)
                                           -- (|>=) is the level-1 trans-bind function, analogous to (>>=)

calc_program :: IO (Either IOException ())
calc_program = runExceptT $ program        

-- > calc_program
-- Left test.txt: openFile: does not exist (No such file or directory)

-----------------------------------------------
-- Level-2

viewFile2 :: String -> 
             MaybeT IO ()                        -- MaybeT-IO monad
viewFile2 filename = do
    guard (filename /= "")
    str <- (|*|) $ readFile "test.txt"        
    (|*|) $ putStr str

program2 :: String -> 
            (ExceptT IOException (MaybeT IO)) () -- ExceptT-MaybeT-IO monad
program2 filename = 
    (|*|) (viewFile2 filename) |>>= \x ->        -- (|>>=) is the level-2 trans-bind function, analogous to (>>=)
    (|-*|) $ catchIOError x                      -- (|-*|) is a level-2 trans-cover function, analogous to (-*)

calc_program2 :: String -> IO (Maybe (Either IOException ())) 
calc_program2 filename = runMaybeT . runExceptT $ program2 filename

-- > calc_program "test.txt"
-- Just (Left test.txt: openFile: does not exist (No such file or directory))
-- > calc_program ""
-- Nothing