Struct Post 

pub struct Post { /* private fields */ }

Nothing here reaches the heap, because while a task runs the heap is its caller rather than something it can borrow. Sends and spawns accumulate as requests the heap drains when the turn ends.

Trait Implementations

impl Mail for Post

fn receive(&mut self) -> Option<Val>

Reaching here is what “responsive” means, whether or not there was anything to read: a task in a tight loop over a full mailbox is working rather than diverging, so blocking would be the wrong test.

fn monitor(&mut self, target: &Val) -> Result<Val, Val>

A watch goes wherever a message would, but what comes back is weaker off this heap. A dead link does not mean the far task died, only that nothing more can be learned, so it reports noconnection rather than an exit value: the caller must stop waiting either way, and must not be told a result nobody observed. A host peer that ends reports noproc and no value, an adapter having nothing it could be said to have evaluated.

fn limit(&mut self, target: &Val, turns: i64) -> Result<Val, Val>

Counted in turns rather than steps because the step budget is a fairness knob and this is not: a task on an expensive semantics gets less done per turn, but turns-to-answer is what its caller can reason about.

fn spawn(&mut self, thunk: Val) -> Result<Val, Val>

fn send(&mut self, to: &Val, msg: Val) -> Result<Val, Val>