Creates a Condition from a function that takes a process state a and an input message b and returns a Bool indicating whether the associated handler should run.

Create a Condition from a function that takes a process state a and returns a Bool indicating whether the associated handler should run.

Creates a Condition from a function that takes an input message m and returns a Bool indicating whether the associated handler should run.

Instructs the process to send a reply and continue running.

Instructs the process to send a reply and evaluate the ProcessAction.

Instructs the process to skip sending a reply and evaluate a ProcessAction

Instructs the process to continue running and receiving messages.

Instructs the process loop to wait for incoming messages until Delay is exceeded. If no messages are handled during this period, the timeout handler will be called. Note that this alters the process timeout permanently such that the given Delay will remain in use until changed.

Instructs the process to hibernate for the given TimeInterval. Note that no messages will be removed from the mailbox until after hibernation has ceased. This is equivalent to calling threadDelay.

Instructs the process to terminate, giving the supplied reason. If a valid shutdownHandler is installed, it will be called with the ExitReason returned from this call, along with the process state.

As stop, but provides an updated state for the shutdown handler.

Sends a reply explicitly to a caller.

replyTo = sendTo

Sends a reply to a SendPort (for use in handleRpcChan et al).

replyChan = sendChan

Continue without giving a reply to the caller - equivalent to continue, but usable in a callback passed to the handleCall family of functions.

Halt process execution during a call handler, without paying any attention to the expected return type.

Version of continue that can be used in handlers that ignore process state.

Version of timeoutAfter that can be used in handlers that ignore process state.

action (\(TimeoutPlease duration) -> timeoutAfter_ duration)

Version of hibernate that can be used in handlers that ignore process state.

action (\(HibernatePlease delay) -> hibernate_ delay)

Version of stop that can be used in handlers that ignore process state.

action (\ClientError -> stop_ ExitNormal)

Constructs a call handler from a function in the Process monad. > handleCall = handleCallIf (const True)

Constructs a call handler from an ordinary function in the Process monad. Given a function f :: (s -> a -> Process (ProcessReply b s)), the expression handleCall f will yield a Dispatcher for inclusion in a Behaviour specification for the GenProcess. Messages are only dispatched to the handler if the supplied condition evaluates to True.

As handleCall but passes the CallRef to the handler function. This can be useful if you wish to reply later to the caller by, e.g., spawning a process to do some work and have it replyTo caller response out of band. In this case the callback can pass the CallRef to the worker (or stash it away itself) and return noReply.

As handleCallFrom but only runs the handler if the supplied Condition evaluates to True.

Creates a handler for a typed channel RPC style interaction. The handler takes a SendPort b to reply to, the initial input and evaluates to a ProcessAction. It is the handler code's responsibility to send the reply to the SendPort.

As handleRpcChan, but only evaluates the handler if the supplied condition is met.

Constructs a cast handler from an ordinary function in the Process monad. > handleCast = handleCastIf (const True)

Constructs a cast handler from an ordinary function in the Process monad. Given a function f :: (s -> a -> Process (ProcessAction s)), the expression handleCall f will yield a Dispatcher for inclusion in a Behaviour specification for the GenProcess.

Creates a generic input handler (i.e., for received messages that are not sent using the cast or call APIs) from an ordinary function in the Process monad.

Handle completely raw input messages.

Constructs a handler for both call and cast messages. handleDispatch = handleDispatchIf (const True)

Constructs a handler for both call and cast messages. Messages are only dispatched to the handler if the supplied condition evaluates to True. Handlers defined in this way have no access to the call context (if one exists) and cannot therefore reply to calls.

Creates an exit handler scoped to the execution of any and all the registered call, cast and info handlers for the process.

Constructs an action handler. Like handleDispatch this can handle both cast and call messages, but you won't know which you're dealing with. This can be useful where certain inputs require a definite action, such as stopping the server, without concern for the state (e.g., when stopping we need only decide to stop, as the terminate handler can deal with state cleanup etc). For example:

action (MyCriticalSignal -> stop_ ExitNormal)

Constructs a call handler from a function in the Process monad. The handler expression returns the reply, and the action will be set to continue.

handleCall_ = handleCallIf_ $ input (const True)

Constructs a call handler from an ordinary function in the Process monad. This variant ignores the state argument present in handleCall and handleCallIf and is therefore useful in a stateless server. Messges are only dispatched to the handler if the supplied condition evaluates to True

See handleCall

A variant of handleCallFrom_ that ignores the state argument.

A variant of handleCallFromIf that ignores the state argument.

A variant of handleRpcChan that ignores the state argument.

A variant of handleRpcChanIf that ignores the state argument.

Version of handleCast that ignores the server state.

Version of handleCastIf that ignores the server state.

Constructs a control channel handler from a function in the Process monad. The handler expression returns no reply, and the control message is treated in the same fashion as a cast.

handleControlChan = handleControlChanIf $ input (const True)

Version of handleControlChan that ignores the server state.