Struct Child 

pub struct Child<'a> { /* private fields */ }

A planned child phase, owned by the code that called Pulse::split.

A Child is a Pulse: pass &child wherever &dyn Pulse is expected, or call check, step and split on it directly. Finish it once, after its work has joined. A tracker records Outcome::Abandoned for a child that is dropped unfinished, including on unwinding. It is two words wide. Completion consumes the owner, so it cannot be repeated:

use how_far::{Child, Outcome};
let child = Child::inert();
child.finish(Outcome::Succeeded).unwrap();
child.finish(Outcome::Succeeded).unwrap();

Implementations

impl Child<'_>

pub fn paced(&self, every: u64) -> Paced<'_>

Checkpoints that reach this child’s pulse once every every units; see Paced.

impl<'a> Child<'a>

pub fn complete_inferred(self, outcome: Outcome)

Resolve an unused phase from its enclosing result, retaining inference evidence.

pub fn plan( &self, execution: Execution, parts: &[PhaseSpec<'_>], ) -> Vec<Child<'_>>

Plan nested observations without introducing a new work error.

pub fn new(pulse: impl ChildPulse + 'a) -> Self

Wrap one child returned from a Pulse::split implementation.

pub const fn inert() -> Self

A child like those NoPulse hands out: it never stops, discards reports, and finishing it does nothing. Its work cannot be stopped through it and nobody sees its progress, so return it from Pulse::split only for parts that nobody needs to observe or stop.

pub fn finish(self, outcome: Outcome) -> Result<(), PlanError>

Publish this child’s outcome. Its parent can finish only after every child has finished.

Fails without recording outcome if the child’s own children are still running; the consumed child is then dropped, so a tracker records it as abandoned. Finished children’s outcomes need not match: a successful child may retain a failed attempt it recovered from.

Trait Implementations

impl Complete for Child<'_>

fn complete_as(self, outcome: Outcome)

Record an explicitly chosen outcome, resolving unfinished observations. Join workers before calling this. Started but uncompleted children are abandoned; untouched children are skipped on success, not run on error.

fn complete<T, E>(self, result: Result<T, E>) -> Result<T, E>

where E: AsStopReason,

Classify the error with AsStopReason, record completion, and return the original result.

fn complete_classified<T, E>( self, result: Result<T, E>, is_stop: impl FnOnce(&E) -> bool, ) -> Result<T, E>

Complete with an explicit classifier, for a foreign error type that Rust’s orphan rules keep from implementing AsStopReason.

fn complete_with<T, E>( self, body: impl FnOnce(&mut Self) -> Result<T, E>, ) -> Result<T, E>

where E: AsStopReason,

Run a multi-step body with this owner, then complete the owner with the body’s result and return that result unchanged.

fn complete_with_classified<T, E>( self, is_stop: impl FnOnce(&E) -> bool, body: impl FnOnce(&mut Self) -> Result<T, E>, ) -> Result<T, E>

complete_with with an explicit classifier, for a foreign error type that cannot implement AsStopReason, such as an error wrapped with its source location.

impl Debug for Child<'_>

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

Formats the value using the given formatter.

impl Pulse for Child<'_>

fn record_issue(&self, error: PlanError)

Record a reporting-protocol problem for optional diagnostics. This never changes cancellation or the operation’s return value. Ordinary sinks may ignore it; diagnostic wrappers retain bounded evidence.

fn split( &self, execution: Execution, parts: &[PhaseSpec<'_>], ) -> Result<Vec<Child<'_>>, PlanError>

Split this phase into weighted children, in declared order.

fn start(&self) -> Result<(), PlanError>

Mark this phase running, without counting or ending planning. Implementations without lifecycle observations may ignore this.

fn set_total(&self, total: Total) -> Result<(), PlanError>

Revise a leaf’s denominator without changing completed units or weights. Unsupported implementations return an error instead of losing the update.

fn share(&self) -> Result<SharedPulse, PlanError>

Share all pulse capabilities with owned work, but never completion rights.

impl Report for Child<'_>

fn advance(&self, completed: u64)

Add completed finished units.

fn may_report(&self) -> bool

Whether reports have any effect.

impl Stop for Child<'_>

fn check(&self) -> Result<(), StopReason>

Check if the operation should stop.

fn may_stop(&self) -> bool

Returns true if this stop can ever signal a stop.

fn should_stop(&self) -> bool

Returns true if the operation should stop.