Trait BirthNodeAppend 

pub trait BirthNodeAppend<Tail>: BirthNode + Sized
where
    Tail: BirthNode,
{
    type Output: BirthNode;

    // Required methods
    fn append_prefix(self) -> Self::Output;
    fn append_tail(tail: Tail) -> Self::Output;

    // Provided method
    fn append_creations<A: Address>(
        prefix: Creations<CreateChild<A, Self>>,
        tail: Creations<CreateChild<A, Tail>>,
    ) -> Creations<CreateChild<A, Self::Output>> { ... }
}

Append one closed direct-child algebra after another.

Self remains the structural prefix, so every child occurrence already valid in that prefix retains both its child type and its position. Tail begins only after the prefix’s final position. The two injection functions change only the closed sum containing a child; append_creations additionally preserves every creation’s ID, kind, and batch order while placing all prefix creations before all appended creations.

This is a static composition of Bombay’s existing staged-creation capability, not another actor effect and not an allocation operation. The interpreter remains solely responsible for establishing and binding the child.

A generic topology owner can therefore retain an inner behavior’s exact creation effects and append children whose concrete types were inferred from value construction:

type Combined = <behavior::Never as behavior::BirthNodeAppend<behavior::Never>>::Output;
let _: core::marker::PhantomData<Combined> = core::marker::PhantomData;

Required Associated Types

type Output: BirthNode

Closed child algebra containing the complete prefix followed by the complete appended tail.

Required Methods

fn append_prefix(self) -> Self::Output

Inject one child from the existing prefix without changing its structural occurrence.

fn append_tail(tail: Tail) -> Self::Output

Inject one child from the appended tail after every prefix occurrence.

Provided Methods

fn append_creations<A: Address>( prefix: Creations<CreateChild<A, Self>>, tail: Creations<CreateChild<A, Tail>>, ) -> Creations<CreateChild<A, Self::Output>>

Preserve and concatenate two ordered creation batches.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<Child, Tail> BirthNodeAppend<Tail> for Child

where Child: Behavior, Tail: NonEmptyBirthNode,

type Output = ChildChoice<Child, Tail>

impl<Head, Rest, Tail> BirthNodeAppend<Tail> for ChildChoice<Head, Rest>

where Head: Behavior, Rest: BirthNode + BirthNodeAppend<Tail>, Tail: NonEmptyBirthNode, Rest::Output: BirthNode,

type Output = ChildChoice<Head, <Rest as BirthNodeAppend<Tail>>::Output>

impl<Node> BirthNodeAppend<Never> for Node

where Node: NonEmptyBirthNode,

type Output = Node

impl<Tail> BirthNodeAppend<Tail> for Never

where Tail: BirthNode,

type Output = Tail