Module process 

The Process computation to represent discontinuous processes.

Modules

ops

Additional operations.

random

Random processes.

Structs

AndThen

The monadic bind for the Process computation.

Ap

The function application for the Process computation.

Await

Await a signal that should be emitted by the specified observable.

AwaitResult

Await a cancellable signal that should be emitted by the specified observable.

Cancel

Cancel the current process.

CancelById

Cancel a process by the specified process identifier.

Delay

Allows delaying the Process computation by the specified function.

EmbedResult

Embeds the result value within the Process computation.

Finally

The finally block for the Process computation.

Hold

The hold block for the Process computation.

Id

Return the corresponding process identifier.

Interrupt

Interrupt a process with the specified identifier if the process is held by computation hold_process.

InterruptionTime

Return the expected interruption time after finishing the hold_process computation, which value may change if the corresponding process is preempted.

IsInterrupted

Test whether the process with the specified identifier was interrupted.

IsPassivated

Test whether the process with the specified identifier was passivated.

Loop

Executes the Process computation in loop.

Map

The functor for the Process computation.

Never

The process that never returns a result.

NewProcessId

A computation that creates a ProcessId value.

Panic

Allows creating the Process computation that panics with the specified message.

Passivate

Passivate the Process computation.

PassivateBefore

Passivate the Process computation before performing some action.

ProcessBox

The Process computation box.

ProcessId

The computation identifier.

ProcessWithPriority

Reactivate

Reactivate the process with the specified identifier.

ReactivateImmediately

Reactivate immediately the process with the specified identifier.

ReactivateManyImmediately

Reactivate immediately the processes with specified identifiers.

Return

Allows creating the Process computation from a pure value.

Run

Run the computation.

Sequence

The sequence of computations.

Sequence_

The sequence of computations with ignored result.

Spawn

Allows spawning another process bound with the current one.

SpawnUsingId

Allows spawning another process bound with the current one.

Timeout

Allows running another process within the specified timeout.

TimeoutUsingId

Allows running another process within the specified timeout by using the given identifier.

Trace

Trace the computation.

Transfer

Like the GoTo statement it transfers the direction of computation.

WhenCancelling

Register a handler that will be invoked in case of cancelling the current process.

Zip

The zip of two Process computations.

Enums

ProcessCancellation

It defines how the parent and child computations should be cancelled.

ProcessEvent

The event that occurs whithin the Process computation.

Traits

IntoProcess

Allows converting to Process computations.

Process

The computation based on continuations.

Functions

cancel_process

Cancel the current process.

delay_process

Delay the Process computation.

embed_result_process

Embeds the result value within the current process, which may cancel the process, for example.

hold_process

Hold the process for the specified time interval.

loop_process

Execute the Process computation in loop.

never_process

A process that never returns a result.

panic_process

Return a Process computation that panics with the specified error message.

passivate_process

Passivate the process.

passivate_process_before

Passivate the process before performing some action.

process_await

Await a signal that should be emitted by the specified observable.

process_await_result

Await a cancellable signal that should be emitted by the specified observable.

process_id

Return the corresponding process identifier.

process_sequence

Create a sequence of computations.

process_sequence_

Create a sequence of computations, where the result is ignored.

process_with_priority

Proceed with the process that would use the specified time point priority.

restore_process_priority

Wrap the computation so that it would restore its priority.

return_process

Return a new Process computation by the specified pure value.

spawn_process

Spawn the child process. In case of cancelling one of the processes, other process will be cancelled too.

spawn_process_using_id

Spawn the child process specifying how the child and parent processes should be cancelled in case of need.

spawn_process_using_id_with

Spawn the child process specifying how the child and parent processes should be cancelled in case of need.

spawn_process_with

Spawn the child process specifying how the child and parent processes should be cancelled in case of need.

timeout_process

Try to run the child process within the specified timeout.

timeout_process_using_id

Try to run the child process within the specified timeout by using the given identifier.

trace_process

Trace the computation.

transfer_process

Like the GoTo statement it transfers the direction of computation.

when_cancelling_process

Register a handler that will be invoked in case of cancelling the current process.