package riot

  1. Overview
  2. Docs

Riot

module Ref : sig ... end
module Pid : sig ... end
module Message : sig ... end
module Process : sig ... end
val random : unit -> 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.

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

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) Seq.t
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:Random.State.t -> ?workers:int -> (unit -> unit) -> unit

Start the Riot runtime using function main to boot the system

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
type ('a, 'b) logger_format = (('a, Format.formatter, unit, 'b) format4 -> 'a) -> 'b
module type Logger = sig ... end
module Logger : sig ... end
module Net : sig ... end
module Timer : sig ... end
module Queue : sig ... end
OCaml

Innovation. Community. Security.