Struct Actions 

pub struct Actions<A: Address, Ph, Sends, Birth: BirthMode> {
    pub sends: Sends,
    pub creates: Creations<CreateChild<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.

Actions::interpret resolves every fresh creation in creates before the named sends product. A committed resolution installs and binds the child; a semantic rejection binds nothing but remains an accepted interpretation receipt. This ordering lets a same-action crate::ChildDelivery or typed creation-observation request use the authoritative result rather than Behavior’s intent. Each child-operation interpreter returns Blocked only when its exact binding prerequisite rejected, while independent later items are still attempted. Interpreter corruption retains the factual prefix and every exact remaining value. No later creation may inherit a failed binding. Creation order is vector order, and named send products declare their own stable order. Constructing a value remains pure.

Fields

sends: Sends

creates: Creations<CreateChild<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.

pub async fn interpret<Interpreter, RootEvent, Path>( progress: &mut Option<InterpretationProgress<Self, <Self as ActionSettlements>::InterpretationCustody, <Self as ActionSettlements>::Settlements>>, interpreter: &mut Interpreter, )

where Ph: Send, Sends: InterpretSends<Interpreter, RootEvent, Path>, Birth: InterpretCreations<A, Interpreter, RootEvent, Path>, Self: Send, <Self as ActionSettlements>::Settlements: Send, <Self as ActionSettlements>::InterpretationCustody: Send, Interpreter: Send,

Borrow caller-owned action progress through one statically typed runtime.

Creation items are attempted in vector order before the named send product. Lawful creation rejection or blocking is retained and does not suppress sends; concrete child-operation interpreters decide whether an exact binding prerequisite was satisfied. Interpreter corruption stops traversal and retains every later creation and the complete send product as unattempted. The next-behavior verdict is never reconstructed.

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

pub const fn new( sends: Sends, creates: Creations<CreateChild<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: Creations<CreateChild<A, Birth::Child>>) -> Self

Continue after staging the complete declared creation product.

Trait Implementations

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

where A: Address, Sends: SendSettlements, Birth: CreationSettlements<A>,

type Settlements = ActionSettlement<<Birth as CreationSettlements<A>>::Settlements, <Sends as SendSettlements>::Settlements, Ph>

type SourceCustody = ((Option<SourceProgress<<Birth as CreationSettlements<A>>::Settlements, <Birth as CreationSettlements<A>>::SourceCustody>>, Option<SourceProgress<<Sends as SendSettlements>::Settlements, <Sends as SendSettlements>::SourceCustody>>), Step<Ph, Stopped>)

type InterpretationCustody = ((Option<InterpretationProgress<Creations<CreateChild<A, <Birth as BirthMode>::Child>>, <Birth as CreationSettlements<A>>::InterpretationCustody, <Birth as CreationSettlements<A>>::Settlements>>, Option<InterpretationProgress<Sends, <Sends as SendSettlements>::InterpretationCustody, <Sends as SendSettlements>::Settlements>>), Step<Ph, Stopped>)

fn prepare_interpretation( progress: &mut Option<InterpretationProgress<Self, Self::InterpretationCustody, Self::Settlements>>, )

fn finish_interpretation( progress: &mut Option<InterpretationProgress<Self, Self::InterpretationCustody, Self::Settlements>>, )

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: Address, Ph, Sends, Birth: BirthMode> From<(Sends, Creations<CreateChild<A, <Birth as BirthMode>::Child>>, Step<Ph, Stopped>)> for Actions<A, Ph, Sends, Birth>

fn from( (sends, creates, become_): (Sends, Creations<CreateChild<A, Birth::Child>>, Become<Ph>), ) -> 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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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,