Control.Distributed.Process.Extras.Internal.Primitives

Maintainers : Jeff Epstein, Tim Watson Stability : experimental Portability : non-portable (requires concurrency)

This module provides a set of additional primitives that add functionality to the basic Cloud Haskell APIs.

General Purpose Process Addressing

class (Resolvable a, Routable a) => Addressable a

Instances

(Resolvable a, Routable a) => Addressable a

class Routable a where

Provides a unified API for addressing processes.

Minimal complete definition

sendTo, unsafeSendTo

Methods

sendTo :: Serializable m => a -> m -> Process ()

Send a message to the target asynchronously

unsafeSendTo :: NFSerializable m => a -> m -> Process ()

Send some NFData message to the target asynchronously, forcing evaluation (i.e., deepseq) beforehand.

unresolvableMessage :: a -> String

Unresolvable Addressable Message

Instances

Routable String

Resolvable a => Routable a

Routable ProcessId

Routable Recipient

Routable (Message -> Process ())

Routable (NodeId, String)

class Resolvable a where

Class of things that can be resolved to a ProcessId.

Methods

resolve :: a -> Process (Maybe ProcessId)

Resolve the reference to a process id, or Nothing if resolution fails

Instances

Resolvable String

Resolvable ProcessId

Resolvable Recipient

Resolvable LogClient

Resolvable (NodeId, String)

class Linkable a where

Class of things to which a Process can link itself.

Methods

linkTo :: a -> Process ()

Create a link with the supplied object.

class Killable a where

Class of things that can be killed (or instructed to exit).

Methods

killProc :: a -> String -> Process ()

exitProc :: Serializable m => a -> m -> Process ()

Instances

Resolvable r => Killable r

Killable ProcessId

Spawning and Linking

spawnSignalled :: Process a -> (a -> Process ()) -> Process ProcessId

Spawn a new (local) process. This variant takes an initialisation action and a secondary expression from the result of the initialisation to Process (). The spawn operation synchronises on the completion of the before action, such that the calling process is guaranteed to only see the newly spawned ProcessId once the initialisation has successfully completed.

spawnLinkLocal :: Process () -> Process ProcessId

Node local version of spawnLink. Note that this is just the sequential composition of spawn and link. (The Unified semantics that underlies Cloud Haskell does not even support a synchronous link operation)

spawnMonitorLocal :: Process () -> Process (ProcessId, MonitorRef)

Like spawnLinkLocal, but monitors the spawned process.

linkOnFailure :: ProcessId -> Process ()

CH's link primitive, unlike Erlang's, will trigger when the target process dies for any reason. This function has semantics like Erlang's: it will trigger ProcessLinkException only when the target dies abnormally.

Registered Processes

whereisRemote :: NodeId -> String -> Process (Maybe ProcessId)

A synchronous version of whereis, this relies on call to perform the relevant monitoring of the remote node.

whereisOrStart :: String -> Process () -> Process ProcessId

Returns the pid of the process that has been registered under the given name. This refers to a local, per-node registration, not global registration. If that name is unregistered, a process is started. This is a handy way to start per-node named servers.

whereisOrStartRemote :: NodeId -> String -> Closure (Process ()) -> Process (Maybe ProcessId)

A remote equivalent of whereisOrStart. It deals with the node registry on the given node, and the process, if it needs to be started, will run on that node. If the node is inaccessible, Nothing will be returned.

Selective Receive/Matching

matchCond :: Serializable a => (a -> Maybe (Process b)) -> Match b

An alternative to matchIf that allows both predicate and action to be expressed in one parameter.

awaitResponse :: Addressable a => a -> [Match (Either ExitReason b)] -> Process (Either ExitReason b)

Safe (i.e., monitored) waiting on an expected response/message.

General Utilities

times :: Int -> Process () -> Process ()

Apply the supplied expression n times

monitor :: Resolvable a => a -> Process (Maybe MonitorRef)

Monitor any Resolvable object.

awaitExit :: Resolvable a => a -> Process ()

isProcessAlive :: ProcessId -> Process Bool

forever' :: Monad m => m a -> m b

Like forever but sans space leak

deliver :: (Addressable a, Serializable m) => m -> a -> Process ()

Remote Table

__remoteTable :: RemoteTable -> RemoteTable