Process abstractions of type Process a b can be created with function process. Process abstractions define remote functions similar to lambda abstractions, which define local functions.

Creates a process abstraction Process a b from a function a -> b.

Remote function invocation, evaluating a function application remotely without communicating the input argument

Instantiates a process abstraction on a remote machine, sends the input of type a and returns the process output of type b.

Instantiates a process defined by the given function on a remote machine, sends the input of type a and returns the process output of type b.

Instantiates a list of process abstractions on remote machines with corresponding inputs of type a and returns the processes outputs, each of type b. The i-th process is supplied with the i-th input generating the i-th output. The number of processes (= length of output list) is determined by the length of the shorter input list (thus one list may be infinite).

Instantiates processes defined by the given list of functions on remote machines with corresponding inputs of type a and returns the processes outputs, each of type b. The i-th process is supplied with the i-th input generating the i-th output. The number of processes (= length of output list) is determined by the length of the shorter input list (thus one list may be infinite).

Same as spawn , but with an additional [Int] argument that specifies where to instantiate the processes.

Same as spawnF , but with an additional [Int] argument that specifies where to instantiate the processes.

Instantiates a process on a remote machine, sends the input of type a and returns the process output of type b in the parallel action monad, thus it can be combined to a larger parallel action.

Instantiates a process defined by the given function on a remote machine, sends the input of type a and returns the process output of type b in the parallel action monad, thus it can be combined to a larger parallel action.

Instantiation with explicit placement (see instantiate).

Instantiation with explicit placement (see instantiate).

Trans class: overloads communication for streams and tuples. You need to declare normal-form evaluation in an instance declaration of NFData. Use the default implementation for write and createComm for instances of Trans.

Number of (logical) machines in the system

Local machine number (ranges from 1 to noPe)

Places where to instantiate lists of processes

Converts local data into corresponding remote data.

Converts local data into corresponding remote data. The result is in the parallel action monad and can be combined to a larger parallel action.

This establishes a direct connection to the process which released the data in the first place. Notice that a remote value may only be fetched exactly once!

This establishes a direct connection to the process which released the data in the first place. The result is in the parallel action monad and can be combined to a larger parallel action. Notice that you have to fetch a remote value exactly once!

Transforms a list of local data into a corresponding remote data list.

Transforms a list of remote data into a corresponding local data list. map fetch would wait for each list element until fetching the next one. Function fetchAll blocks only on partial defined list structure, not on content.

Function liftRD is used to lift functions acting on normal data to function performing the same computation on Remote Data.

see liftRD

see liftRD

see liftRD

A channel name ChanName a is a handle for a reply channel. The channel can be created with the function new and you can connect to such a channel with the function parfill.

A channel can be created with the function new (this is an unsafe side effect!). It takes a function whose first parameter is the channel name ChanName a and whose second parameter is the value of type a that will be received lazily in the future. The ChanName and the value of type a can be used in the body of the parameter function to create the output of type b. The output of the parameter function will be forwarded to the output of new .

Example: new (channame val -> (channame,val)) returns the tuple (channame, value) .

You can connect to a reply channel with function parfill (this is an unsafe side effect!). The first parameter is the name of the channel, the second parameter is the value to be send. The third parameter will be the functions result after the concurrent sending operation is initiated. The sending operation will be triggered as soon as the result of type b is demanded. Take care not to make the result of parfill depend on the sent value, as this will create a deadlock.

Non-deterministically merges a list of lists (usually input streams) into a single list. The order of the output list is determined by the availability of the inner lists constructors. (Function merge is defined using a list merge function nmergeIO_E) (similar to nmergeIO from Concurrent Haskell, but in a custom version).

same as merge