Struct System 

pub struct System {
    pub undeliverable: Vec<(Pid, Value)>,
    /* private fields */
}

The host state a blue process tree runs against.

Mailboxes live here rather than on the crate::Supervisor on purpose: the supervisor owns the processes and hands &mut H to Vm::step, so a supervisor-owned mailbox map would be borrowed twice at once.

Fields

undeliverable: Vec<(Pid, Value)>

Sends to a pid with no mailbox. Kept rather than dropped so a misdirected message is diagnosable instead of invisible.

Implementations

impl System

pub fn new() -> Self

pub fn register(&mut self, pid: Pid)

Give pid a mailbox. Called by the supervisor on spawn.

pub fn current(&self) -> Pid

pub fn send(&mut self, to: Pid, msg: Value)

Enqueue a deep copy of msg.

Value is Arc-based, so pushing it as-is would share structure between two processes and quietly reintroduce exactly the coupling that separate interpreters removed. Copying at the boundary is what makes “processes share nothing” true rather than nearly true.

pub fn has_mail(&self, pid: Pid) -> bool

pub fn mail_count(&self, pid: Pid) -> usize

pub fn clear(&mut self, pid: Pid)

Empty a mailbox. A restarted process starts with a clean one: the messages that were in flight when it crashed were addressed to the incarnation that died, and replaying them into the fresh one is how a poison message takes down a process forever.

pub fn any_mail(&self) -> bool

Is any mailbox non-empty? Used to tell a live wait from a deadlock.

Trait Implementations

impl Debug for System

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for System

fn default() -> Self

Returns the “default value” for a type.

impl Readiness for System

fn is_ready(&self, pid: Pid) -> bool

May this parked process now make progress?

fn any_pending(&self) -> bool

Is there any pending work at all? When every process is parked and this is false, nothing will ever change: that is a deadlock, and spinning on it forever is the failure mode this question exists to prevent.

fn set_current(&mut self, pid: Pid)

The scheduler is about to give pid a slice. A host whose primitives are process-relative — receive, self — needs this to answer them. Default: nothing.

fn on_restart(&mut self, pid: Pid)

pid is about to restart, so its per-process host state should be discarded. Default: nothing.