riot 0.0.3 · OCaml Package

Riot

module Ref : sig ... end

module Pid : sig ... end

module Message : sig ... end

module Process : sig ... end

module Application : sig ... end

A Riot `Application` can be used to encapsulate functionality that must share the same lifecycle. For example, the `Riot.Logger` is an Application.

val random : unit -> Stdlib.Random.State.t

Returnts the current random state from a scheduler.

val yield : unit -> unit

Suspends execution of the current process and returns control to the scheduler

val sleep : float -> unit

sleep t Suspends execution of the current process for at least `t` seconds. `t` is a float so it supports subsecond values: `0.001` is 1 millisecond.

val self : unit -> Pid.t

Returns the process identifier (pid) for the current process

val process_flag : Process.process_flag -> unit

val exit : Pid.t -> Process.exit_reason -> unit

Sends an exit signal to the process pid, to exit with reason exit_reason

val send : Pid.t -> Message.t -> unit

Sends a message to process with this pid.

val spawn : (unit -> unit) -> Pid.t

Spawns a new process.

val spawn_link : (unit -> unit) -> Pid.t

Spawns a new process and links it to the current process before returning.

exception Link_no_process of Pid.t

val link : Pid.t -> unit

Links the current process and the process pid together.

val monitor : Pid.t -> Pid.t -> unit

Makes pid1 a monitor of pid2. When pid2 terminates, pid1 will receive a message.

val processes : unit -> (Pid.t * Process.t) Stdlib.Seq.t

`processes ()` will list all the processes currently alive.

val is_process_alive : Pid.t -> bool

Returns true if the process pid is still alive.

val wait_pids : Pid.t list -> unit

Await all processes in the list to termimante.

val receive : ?ref:unit Ref.t -> unit -> Message.t

receive () will return the first message in the process mailbox.

This function will suspend a process that has an empty mailbox, and the process will remain asleep until a message is delivered to it.

### Selective Receive

If a `ref` was passed, then `receive ref ()` will skip all messages created before the creation of this `Ref.t` value, and will only return newer messages.

This is useful to skip the queue, but not remove any of the messages before it. Those messages will be delivered in-order in future calls to `receive ()`.

val shutdown : unit -> unit

Gracefully shuts down the runtime. Any non-yielding process will block this.

val run : ?rnd:Stdlib.Random.State.t -> ?workers:int -> (unit -> unit) -> unit

Start the Riot runtime using function main to boot the system

val start : 
  ?rnd:Stdlib.Random.State.t ->
  ?workers:int ->
  apps:(module Application.Intf) list ->
  unit ->
  unit

Start the Riot runtime with a series of applications.

Each application will be started in the same order as specified, and if any application fails to start up, the system will be shutdown.

Once the applications are started, they will all be monitored until they are all terminated. Only then will the runtime shutdown.

val trace_send : (Pid.t -> Process.t -> Message.t -> unit) -> unit

val trace_proc_run : (int -> Process.t -> unit) -> unit

module Gen_server : sig ... end

module Supervisor : sig ... end

module Telemetry : sig ... end

module Logger : sig ... end

module Net : sig ... end

module Timer : sig ... end

module Queue : sig ... end

package riot

Riot