package riot

  1. Overview
  2. Docs


module Timeout : sig ... end
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 -> Random.State.t

Returns 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.

exception Invalid_destination of string
val send_by_name : name:string -> Message.t -> unit

Sends a message to a process registered with name. If name is not a valid destination for a message, this function raises an Invalid_destination name exception.

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

Spawns a new process.

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

Spawns a new process using the current scheduler.

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

exception Name_already_registered of string * Pid.t
val register : string -> Pid.t -> unit

register name pid registers a process by a given name. The name will be uniquely associated to this process and attempting to register the same name twice will result in an exception Name_already_registered being raised.

val unregister : string -> unit

unregister name frees a name and allows it to be re-registered. If the name was not registered before, this operation does nothing.

Links the current process and the process pid together.

val monitor : Pid.t -> unit

monitor pid makes self () a monitor of pid.

When pid terminates, self () will receive a Processes.Messages.Monitor(Process_down(pid)) message.

val processes : unit -> (Pid.t * Process.t) 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.

exception Receive_timeout
exception Syscall_timeout
val receive : selector:(Message.t -> [ `select of 'msg | `skip ]) -> ?after:int64 -> ?ref:unit Ref.t -> unit -> 'msg

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.

### Timed Receive

If a `after was passed, then `receive ~after ()` will wait up to after and raise an `Receive_timeout` exception that can be matched on.

This is useful to prevent deadlock of processes when receiving messages.

### Selective Receive

If a `selector` was passed, the `selector` function will be used to select if a message will be picked or if it will be skipped.

### Receive with Refs

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 receive_any : ?after:int64 -> ?ref:unit Ref.t -> unit -> Message.t

receive_any () behaves like receive but does not require a selector and instead will return any message in the mailbox.

val shutdown : ?status:int -> unit -> unit

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

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

Start the Riot runtime using function main to boot the system

val on_error : [ `Msg of string ] -> int
val run_with_status : ?rnd:Random.State.t -> ?workers:int -> on_error:('error -> int) -> (unit -> (int, 'error) result) -> unit

run_with_status ~on_error main starts the Riot runtime using function main to boot the system and handling errors with on_error.

main should return a result of either an exit code or an error. on_error should handle an error code appropriately, then return a status code.

val start : ?rnd: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.

module Gen_server : sig ... end
module Supervisor : sig ... end
module Dynamic_supervisor : sig ... end
module Telemetry : sig ... end
module Logger : sig ... end
module Fd : sig ... end
module IO : sig ... end
module File : sig ... end
module Net : sig ... end
module SSL : sig ... end
module Timer : sig ... end
module Bytestring : sig ... end
module Queue : sig ... end
module Hashmap : sig ... end

Riot's Hashmap is a process-safe implementation of a hash-table.

module Stream : sig ... end
module Task : sig ... end
module Store : sig ... end
module Crypto : sig ... end
module Runtime : sig ... end

Innovation. Community. Security.