Control.Monad.Task

Task monad transformer can help refactor event and callback heavy programs into monads via co-routines. The idea is loosely based on Combining Events And Threads For Scalable Network Services, by Peng Li and Steve Zdancewic, in PLDI, 2007. (http://www.cis.upenn.edu/~stevez/papers/abstracts.html#LZ07), but with deterministic and co-operative lightweight threads, also known as co-routines, so that the base monad can be anything ranging from IO to state monads, or your favorite monad transformer stack.

Besides, Task monad transformer also provides a simple mechanism to signal and watch for events, which allows complex event processing logic to be expressed as streamlined monadic co-routines.

Task monad transformer is essentially a ContT, or continuation transformer, defined to extract the control flow of monadic programs with co-operative multi-threading. After the CPS transformation, the program trace is then executed with a simple round-robin scheduler.

MonadTask class

class Monad m => MonadTask e m | m -> e where

MonadTask specifies a task monad m over an event type e.

Minimal complete definition

yield, fork, watch, signal, exit

Methods

yield :: m ()

yield temporarily suspends current task to let others run.

fork :: m a -> m ()

fork spawns a task and runs it immediately until it ends or suspends before returning to current task.

watch :: (e -> Maybe a) -> m a

watch suspends the current task to wait for future events, and will resume execution when an event triggers its watching function.

signal :: e -> m ()

signal broadcasts an event to all other tasks that are watching, and give those who wake up the priority to run.

exit :: m ()

exit ends all tasks and returns immediately.

Instances

(Monad m, MonadTask a m) => MonadTask a (MaybeT m)

Methods

yield :: MaybeT m ()

fork :: MaybeT m a -> MaybeT m ()

watch :: (a -> Maybe a) -> MaybeT m a

signal :: a -> MaybeT m ()

exit :: MaybeT m ()

(Monad m, MonadTask a m) => MonadTask a (ListT m)

Methods

yield :: ListT m ()

fork :: ListT m a -> ListT m ()

watch :: (a -> Maybe a) -> ListT m a

signal :: a -> ListT m ()

exit :: ListT m ()

(Monoid w, Monad m, MonadTask a m) => MonadTask a (WriterT w m)

Methods

yield :: WriterT w m ()

fork :: WriterT w m a -> WriterT w m ()

watch :: (a -> Maybe a) -> WriterT w m a

signal :: a -> WriterT w m ()

exit :: WriterT w m ()

(Monoid w, Monad m, MonadTask a m) => MonadTask a (WriterT w m)

Methods

yield :: WriterT w m ()

fork :: WriterT w m a -> WriterT w m ()

watch :: (a -> Maybe a) -> WriterT w m a

signal :: a -> WriterT w m ()

exit :: WriterT w m ()

(Monad m, MonadTask a m) => MonadTask a (IdentityT * m)

Methods

yield :: IdentityT * m ()

fork :: IdentityT * m a -> IdentityT * m ()

watch :: (a -> Maybe a) -> IdentityT * m a

signal :: a -> IdentityT * m ()

exit :: IdentityT * m ()

(Monad m, MonadTask a m) => MonadTask a (ExceptT e m)

Methods

yield :: ExceptT e m ()

fork :: ExceptT e m a -> ExceptT e m ()

watch :: (a -> Maybe a) -> ExceptT e m a

signal :: a -> ExceptT e m ()

exit :: ExceptT e m ()

Monad m => MonadTask e (TaskT e m)

Methods

yield :: TaskT e m ()

fork :: TaskT e m a -> TaskT e m ()

watch :: (e -> Maybe a) -> TaskT e m a

signal :: e -> TaskT e m ()

exit :: TaskT e m ()

(Monad m, MonadTask a m) => MonadTask a (ReaderT * r m)

Methods

yield :: ReaderT * r m ()

fork :: ReaderT * r m a -> ReaderT * r m ()

watch :: (a -> Maybe a) -> ReaderT * r m a

signal :: a -> ReaderT * r m ()

exit :: ReaderT * r m ()

TaskT monad transformer

newtype TaskT e m a

Task monad transformer.

Constructors

TaskT

Fields

• runTaskT :: ContT (Trace m e) m a

Instances

MonadState s m => MonadState s (TaskT e m)

Methods

get :: TaskT e m s

put :: s -> TaskT e m ()

state :: (s -> (a, s)) -> TaskT e m a

MonadReader s m => MonadReader s (TaskT e m)

Methods

ask :: TaskT e m s

local :: (s -> s) -> TaskT e m a -> TaskT e m a

reader :: (s -> a) -> TaskT e m a

Monad m => MonadTask e (TaskT e m)

Methods

yield :: TaskT e m ()

fork :: TaskT e m a -> TaskT e m ()

watch :: (e -> Maybe a) -> TaskT e m a

signal :: e -> TaskT e m ()

exit :: TaskT e m ()

MonadTrans (TaskT e)

Methods

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

Monad m => Monad (TaskT e m)

Methods

(>>=) :: TaskT e m a -> (a -> TaskT e m b) -> TaskT e m b

(>>) :: TaskT e m a -> TaskT e m b -> TaskT e m b

return :: a -> TaskT e m a

fail :: String -> TaskT e m a

Functor (TaskT e m)

Methods

fmap :: (a -> b) -> TaskT e m a -> TaskT e m b

(<$) :: a -> TaskT e m b -> TaskT e m a

Applicative (TaskT e m)

Methods

pure :: a -> TaskT e m a

(<*>) :: TaskT e m (a -> b) -> TaskT e m a -> TaskT e m b

liftA2 :: (a -> b -> c) -> TaskT e m a -> TaskT e m b -> TaskT e m c

(*>) :: TaskT e m a -> TaskT e m b -> TaskT e m b

(<*) :: TaskT e m a -> TaskT e m b -> TaskT e m a

MonadIO m => MonadIO (TaskT e m)

Methods

liftIO :: IO a -> TaskT e m a

Functions

runTask :: Monad m => TaskT e m a -> m ()

runTask runs a task monad until to its completion, i.e., no more active tasks to run, or until it exits.

• runTask = runTrace . taskToTrace

orElse :: (e -> Maybe a) -> (e -> Maybe b) -> e -> Maybe (Either a b)

orElse is a helper function for combining two trigger functions disjuctively, favoring the first one.