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

Addressable ProcessId

class Routable a where

Class of things that you can route/send serializable message to

Methods

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

Send a message to the target asynchronously

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

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

Instances

Routable String

Methods

sendTo :: (Serializable m, Resolvable String) => String -> m -> Process ()

unsafeSendTo :: (NFSerializable m, Resolvable String) => String -> m -> Process ()

Routable ProcessId

Methods

sendTo :: (Serializable m, Resolvable ProcessId) => ProcessId -> m -> Process ()

unsafeSendTo :: (NFSerializable m, Resolvable ProcessId) => ProcessId -> m -> Process ()

Routable Recipient

Methods

sendTo :: (Serializable m, Resolvable Recipient) => Recipient -> m -> Process ()

unsafeSendTo :: (NFSerializable m, Resolvable Recipient) => Recipient -> m -> Process ()

Routable LogClient

Methods

sendTo :: (Serializable m, Resolvable LogClient) => LogClient -> m -> Process ()

unsafeSendTo :: (NFSerializable m, Resolvable LogClient) => LogClient -> m -> Process ()

Routable LogChan

Methods

sendTo :: (Serializable m, Resolvable LogChan) => LogChan -> m -> Process ()

unsafeSendTo :: (NFSerializable m, Resolvable LogChan) => LogChan -> m -> Process ()

Routable (Message -> Process ())

Methods

sendTo :: (Serializable m, Resolvable (Message -> Process ())) => (Message -> Process ()) -> m -> Process ()

unsafeSendTo :: (NFSerializable m, Resolvable (Message -> Process ())) => (Message -> Process ()) -> m -> Process ()

Routable (NodeId, String)

Methods

sendTo :: (Serializable m, Resolvable (NodeId, String)) => (NodeId, String) -> m -> Process ()

unsafeSendTo :: (NFSerializable m, Resolvable (NodeId, String)) => (NodeId, String) -> m -> Process ()

class Resolvable a where

Class of things that can be resolved to a ProcessId.

Minimal complete definition

resolve

Methods

resolve :: a -> Process (Maybe ProcessId)

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

unresolvableMessage :: Resolvable a => a -> String

Unresolvable Addressable Message

Instances

Resolvable String

Methods

resolve :: String -> Process (Maybe ProcessId)

unresolvableMessage :: String -> String

Resolvable ProcessId

Methods

resolve :: ProcessId -> Process (Maybe ProcessId)

unresolvableMessage :: ProcessId -> String

Resolvable Recipient

Methods

resolve :: Recipient -> Process (Maybe ProcessId)

unresolvableMessage :: Recipient -> String

Resolvable LogClient

Methods

resolve :: LogClient -> Process (Maybe ProcessId)

unresolvableMessage :: LogClient -> String

Resolvable (NodeId, String)

Methods

resolve :: (NodeId, String) -> Process (Maybe ProcessId)

unresolvableMessage :: (NodeId, String) -> String

class Linkable a where

Class of things to which a Process can link itself.

Methods

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

Create a link with the supplied object.

class Killable p where

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

Methods

killProc :: Resolvable p => p -> String -> Process ()

Kill (instruct to exit) generic process, using kill primitive.

exitProc :: (Resolvable p, Serializable m) => p -> m -> Process ()

Kill (instruct to exit) generic process, using exit primitive.

Instances

Resolvable p => Killable p

Methods

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

exitProc :: (Resolvable p, Serializable m) => p -> m -> Process ()

class Monitored a r m | a r -> m where

Minimal complete definition

mkMonitor, checkMonitor

Methods

mkMonitor :: a -> Process r

checkMonitor :: a -> r -> m -> Process Bool

Instances

Resolvable a => Monitored a MonitorRef ProcessMonitorNotification

Methods

mkMonitor :: a -> Process MonitorRef

checkMonitor :: a -> MonitorRef -> ProcessMonitorNotification -> Process Bool

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 monitors the remote node and returns Nothing if the node goes down (since a remote node failing or being non-contactible has the same effect as a process not being registered from the caller's point of view).

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 ()

Deprecated: use replicateM_ instead

Apply the supplied expression n times

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

Monitor any Resolvable object.

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

Wait until Resolvable object will exit. Return immediately if object can't be resolved.

isProcessAlive :: ProcessId -> Process Bool

Check if specified process is alive. Information may be outdated.

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

Like forever but sans space leak

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

Send message to Addressable object.

Remote Table

__remoteTable :: RemoteTable -> RemoteTable