Struct HeterogeneousShutdownSends 

pub struct HeterogeneousShutdownSends<T> { /* private fields */ }

Ordered heterogeneous shutdown requests. Static dispatch occurs per item, preserving phase declaration order across protocol alternatives.

Implementations

impl<T> HeterogeneousShutdownSends<T>

pub fn as_slice(&self) -> &[T]

Borrow the phase-ordered shutdown selections emitted by this turn.

The order is the declaration order of the active phase. Retained selections from later phases are not exposed until that phase starts.

Trait Implementations

impl<T> ClassifySettlement for HeterogeneousShutdownSends<T>

where T: ClassifySettlement,

fn settlement_status(&self) -> SettlementStatus

Inspect every member without consuming or rewriting the settlement.

impl<I, E, Path, T> InterpretSends<I, E, Path> for HeterogeneousShutdownSends<T>

where I: Send, T: InterpretChoice<I, E, Path, ChildHead>, T::InterpretationCustody: Send,

fn interpret( progress: &mut Option<InterpretationProgress<Self, Self::InterpretationCustody, Self::Settlements>>, interpreter: &mut I, ) -> impl Future<Output = ()> + Send

impl<T> LogicalDeliveryProtocols for HeterogeneousShutdownSends<T>

type Protocols = NoBirthProtocols

Ordered, duplicate-preserving logical protocol occurrences.

impl<T> SendEffects for HeterogeneousShutdownSends<T>

fn empty() -> Self

fn append(&mut self, other: Self)

fn combine(self, other: Self) -> Self

fn send<Input, Path>(&mut self, input: Input)

where Self: SendInput<Input, Path>,

Append one request to its statically selected semantic lane.

fn sending<Input, Path>(input: Input) -> Self

where Self: SendInput<Input, Path>,

Build a send product containing one request in its selected lane.

impl<T> SendSettlements for HeterogeneousShutdownSends<T>

where T: ChoiceSettlements<ChildHead>,

type Settlements = HeterogeneousShutdownSends<<T as ChoiceSettlements<ChildHead>>::Settlements>

type SourceCustody = <HeterogeneousShutdownSends<T> as SendSettlements>::Settlements

type InterpretationCustody = Vec<Option<InterpretationProgress<T, <T as ChoiceSettlements<ChildHead>>::InterpretationCustody, <T as ChoiceSettlements<ChildHead>>::Settlements>>>

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

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

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

impl<Host, RootEvent, T> SourceSettlementCustody<Host, RootEvent> for HeterogeneousShutdownSends<T>

where T: Send,

type Custody = HeterogeneousShutdownSends<T>

fn prepare_source(progress: &mut Option<SourceProgress<Self, Self::Custody>>)

fn offer_next_to_source( _: &mut Self::Custody, _: &mut Host, ) -> impl Future<Output = ()> + Send

fn finish_source(progress: &mut Option<SourceProgress<Self, Self::Custody>>)

impl<E, T: Send> SendsFor<E> for HeterogeneousShutdownSends<T>