Control.Concurrent.Actor

This module implements Erlang-style actors (what Erlang calls processes). It does not implement network distribution (yet?). Here is an example:

act1 :: Actor
act1 = do
    me <- self
    liftIO $ print act1 started
    forever $ receive
      [ Case $ ((n, a) :: (Int, Address)) ->
            if n > 10000
                then do
                    liftIO . throwIO $ NonTermination 
                else do
                    liftIO . putStrLn $ act1 got  ++ (show n) ++  from  ++ (show a)
                    send a (n+1, me)
      , Case $ (e :: RemoteException) -> 
            liftIO . print $ act1 received a remote exception
      , Default $ liftIO . print $ act1: received a malformed message
      ]

act2 :: Address -> Actor
act2 addr = do
    monitor addr
    -- setFlag TrapRemoteExceptions
    me <- self
    send addr (0 :: Int, me)
    forever $ receive 
      [ Case $ ((n, a) :: (Int, Address)) -> do
                    liftIO . putStrLn $ act2 got  ++ (show n) ++  from  ++ (show a)
                    send a (n+1, me)
      , Case $ (e :: RemoteException) -> 
            liftIO . print $ act2 received a remote exception:  ++ (show e)
      ]

act3 :: Address -> Actor
act3 addr = do
    monitor addr
    setFlag TrapRemoteExceptions
    forever $ receive
      [ Case $ (e :: RemoteException) -> 
            liftIO . print $ act3 received a remote exception:  ++ (show e)
      ]

main = do
    addr1 <- spawn act1
    addr2 <- spawn (act2 addr1)
    spawn (act3 addr2)
    threadDelay 20000000

Types

data Address

The address of an actor, used to send messages

Instances

Eq Address

Ord Address

Show Address

Typeable Address

data Handler

Constructors

forall m . Typeable m => Case (m -> ActorM ())

Default (ActorM ())

type ActorM = ReaderT Context IO

The actor monad, just a reader monad on top of IO.

type Actor = ActorM ()

The type of an actor. It is just a monadic action in the ActorM monad, returning ()

data RemoteException

Instances

Show RemoteException

Typeable RemoteException

Exception RemoteException

data ActorExitNormal

Exception raised by an actor on exit

Instances

Show ActorExitNormal

Typeable ActorExitNormal

Exception ActorExitNormal

data Flag

Constructors

TrapRemoteExceptions

Instances

Enum Flag

Eq Flag

Actor actions

send :: Typeable m => Address -> m -> ActorM ()

Sends a message from inside the ActorM monad

(◁) :: Typeable m => Address -> m -> ActorM ()

Infix form of send

(▷) :: Typeable m => m -> Address -> ActorM ()

Infix form of send with the arguments flipped

self :: ActorM Address

Used to obtain an actor's own address inside the actor

receive :: [Handler] -> ActorM ()

Try to handle a message using a list of handlers. The first handler matching the type of the message is used.

receiveWithTimeout :: Int -> [Handler] -> ActorM () -> ActorM ()

Same as receive, but times out after a specified amount of time and runs a default action

spawn :: Actor -> IO Address

Spawn a new actor with default flags

monitor :: Address -> ActorM ()

Monitors the actor at the specified address. If an exception is raised in the monitored actor's thread, it is wrapped in an ActorException and forwarded to the monitoring actor. If the monitored actor terminates, an ActorException is raised in the monitoring Actor

link :: Address -> ActorM ()

Like monitor, but bi-directional

setFlag :: Flag -> ActorM ()

Sets the specified flag in the actor's environment

clearFlag :: Flag -> ActorM ()

Clears the specified flag in the actor's environment

toggleFlag :: Flag -> ActorM ()

Toggles the specified flag in the actor's environment

testFlag :: Flag -> ActorM Bool

Checks if the specified flag is set in the actor's environment