riot 0.0.2 · OCaml Package

Riot

module Ref : sig ... end

module Pid : sig ... end

module Message : sig ... end

module Process : sig ... end

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

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 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, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'a) ->
  'b

module type Logger = sig ... end

module Logger : sig ... end

module Net : sig ... end

module Timer : sig ... end

module Queue : sig ... end

package riot

Riot