Control.Concurrent.Process

This module provides a *very* basic support for processes with message queues. It was built using channels and MVars.

Types

data ReceiverT r m a

The ReceiverT generic type.

r

the type of things the process will receive

m

the monad in which it will run

a

the classic monad parameter

Instances

MonadReader r m => MonadReader r (ReceiverT r m)

MonadState s m => MonadState s (ReceiverT r m)

MonadError e m => MonadError e (ReceiverT r m)

(Monoid w, MonadWriter w m) => MonadWriter w (ReceiverT w m)

MonadTrans (ReceiverT r)

Monad m => Monad (ReceiverT r m)

MonadCatchIO m => MonadCatchIO (ReceiverT r m)

MonadIO m => MonadIO (ReceiverT r m)

data Handle r

A Process handle. It's returned on process creation and should be used | afterwards to send messages to it

type Process r = ReceiverT r IO

Process are receivers that run in the IO Monad

Functions

Process creation / destruction

makeProcess :: (m t -> IO s) -> ReceiverT r m t -> Process r s

makeProcess builds a process from a code that generates an IO action. Usage: process <- makeProcess evalFunction receiver

runHere

Arguments

:: MonadIO m

=> Process r t

The process to be run

-> m t

It's returned as an action

runHere executes process code in the current environment. Usage: result <- runHere process

spawn

Arguments

:: MonadIO m

=> Process r k

The process to be run

-> m (Handle r)

The handle for that process

spawn starts a process and returns its handle. Usage: handle <- spawn process

kill

Arguments

:: MonadIO m

=> Handle a

The handle of process to kill

-> m ()

kill lets you *brutally* terminate a running process. Usage: kill processHandle

Message passing

self :: Monad m => ReceiverT r m (Handle r)

self returns the handle of the current process. Usage: handle <- self

sendTo

Arguments

:: MonadIO m

=> Handle a

The receiver process handle

-> a

The message to send

-> m ()

sendTo lets you send a message to a running process. Usage: sendTo processHandle message

recv :: MonadIO m => ReceiverT r m r

recv lets you receive a message in a running process (it's a blocking receive). Usage: message <- recv

sendRecv

Arguments

:: MonadIO m

=> Handle a

The receiver process handle

-> a

The message to send

-> ReceiverT r m r

The process where this action is run will wait until it receives something

sendRecv is just a syntactic sugar for: sendTo h a >> recv