Struct Actions 

pub struct Actions<A: Address, Ph, Sends, Birth: BirthMode> {
    pub sends: Sends,
    pub creates: Vec<Create<A, Birth::Child>>,
    pub become_: Become<Ph>,
}

Bombay’s typed realization of the actor transition effects: communications, fresh actor creation, and next behavior or termination.

An interpreter resolves every fresh creation in creates before interpreting any ordinary delivery or crate::InterpreterRequests request in sends from this value. A successful resolution installs and binds the child; a rejected resolution binds nothing. This ordering lets a same-action typed creation-observation request return the committed result rather than the behavior’s intent. When creation is rejected, a same-action child-observation request for its nonce is consumed without installing an observation or emitting a child-stopped fact, while the creation-observation request reports the rejection. A later creation cannot inherit that consumed observation. Creation order is vector order, and each concrete named send lane retains its own order; this contract does not impose an order between independent lanes. Constructing a value remains pure.

Fields

sends: Sends

creates: Vec<Create<A, Birth::Child>>

become_: Become<Ph>

Implementations

impl<A: Address, Ph, Sends, Birth: BirthMode> Actions<A, Ph, Sends, Birth>

pub fn map_sends<Mapped>( self, map: impl FnOnce(Sends) -> Mapped, ) -> Actions<A, Ph, Mapped, Birth>

Transform only the send effects, preserving creation order and the next-behavior verdict exactly.

pub fn map_become<NextPh>( self, map: impl FnOnce(Become<Ph>) -> Become<NextPh>, ) -> Actions<A, NextPh, Sends, Birth>

Transform only the next-behavior verdict, preserving sends and creation order exactly.

pub fn with_send<Input, Path>(self, input: Input) -> Self

where Sends: SendInput<Input, Path>,

Append one communication to its statically selected send lane.

This is a pure transformation of the send leg. It preserves creation order and the exact continue, phase-change, or termination verdict. Path is compile-time lane evidence; no runtime lookup is performed.

impl<A: Address, Ph, Sends: SendEffects, Birth: BirthMode> Actions<A, Ph, Sends, Birth>

pub const fn new( sends: Sends, creates: Vec<Create<A, Birth::Child>>, become_: Become<Ph>, ) -> Self

pub fn just(become_: Become<Ph>) -> Self

pub fn cont() -> Self

pub fn stop() -> Self

pub fn goto(phase: Ph) -> Self

pub fn send(sends: Sends) -> Self

Continue after emitting the complete declared send product.

pub fn create(creates: Vec<Create<A, Birth::Child>>) -> Self

Continue after staging the complete declared creation product.

Trait Implementations

impl<A, Ph, Sends, Birth, Input, Path> AppendSend<Input, Path> for Actions<A, Ph, Sends, Birth>

where A: Address, Birth: BirthMode, Sends: SendInput<Input, Path>,

fn append_send(self, input: Input) -> Self

Append input exactly once and preserve creations and the next verdict.

impl<A, Ph, Sends, Birth> Debug for Actions<A, Ph, Sends, Birth>

where A: Address + Debug, A::Nonce: Debug, Ph: Debug, Sends: Debug, Birth: BirthMode, Birth::Child: Debug,

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

Formats the value using the given formatter.

impl<A, Ph, Sends, Birth> Eq for Actions<A, Ph, Sends, Birth>

where A: Address + Eq, A::Nonce: Eq, Ph: Eq, Sends: Eq, Birth: BirthMode, Birth::Child: Eq,

impl<A: Address, Ph, Sends, Birth: BirthMode> From<(Sends, Vec<Create<A, <Birth as BirthMode>::Child>>, Step<Ph, Stopped>)> for Actions<A, Ph, Sends, Birth>

fn from( (sends, creates, become_): (Sends, Vec<Create<A, Birth::Child>>, Become<Ph>), ) -> Self

Converts to this type from the input type.

impl<S, A: Address> From<Effect<S, A>> for Actions<A, Never, Vec<S>, NoBirths>

fn from(effect: Effect<S, A>) -> Self

Converts to this type from the input type.

impl<A, Ph, Sends, Birth> PartialEq for Actions<A, Ph, Sends, Birth>

where A: Address + PartialEq, A::Nonce: PartialEq, Ph: PartialEq, Sends: PartialEq, Birth: BirthMode, Birth::Child: PartialEq,

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.