Enum Node 

pub enum Node<C, E, GroupContext = C, F = Colon, GroupFormat = AsDisplay> {
    Leaf(WithContext<C, E, F>),
    Group(Subgroup<C, E, GroupContext, F, GroupFormat>),
}

A child of a ManyErrors: either a leaf error paired with context, or a named sub-group of further errors.

Each variant renders through its own Format strategy:

• Leaf: a leaf context C paired with error E, formatted by F (default Colon: "{context}: {error}").
• Group: a Subgroup — a label GroupContext paired with the boxed nested ManyErrors. The label is formatted by GroupFormat (default AsDisplay: the label’s own Display); the nested errors’ layout is owned by the aggregate strategy, so GroupFormat is a label-only Format<GroupContext> and never touches them.

The standard-trait impls bound only C/E/GroupContext — never the F/GroupFormat marker params (mirroring WithContext’s PhantomData<fn() -> F>).

Variants

Leaf(WithContext<C, E, F>)

A leaf: one context-tagged error.

Group(Subgroup<C, E, GroupContext, F, GroupFormat>)

A named sub-group: a label paired with a boxed nested ManyErrors.

Implementations

impl<C, E, GroupContext, F, GroupFormat> Node<C, E, GroupContext, F, GroupFormat>

pub fn is_leaf(&self) -> bool

Returns true if this is a Node::Leaf.

pub fn as_leaf(&self) -> Option<&WithContext<C, E, F>>

Returns the leaf’s WithContext pair, or None for a group.

pub fn as_group(&self) -> Option<&Subgroup<C, E, GroupContext, F, GroupFormat>>

Returns the group’s Subgroup, or None for a leaf.

The label is &self.context; the nested errors are &self.errors.

pub fn with_formats<NewF, NewGF>(self) -> Node<C, E, GroupContext, NewF, NewGF>

where NewF: Format<WithContext<C, E, NewF>>, NewGF: Format<GroupContext>,

Switches the leaf and group-label strategies without touching the stored values (a group rebuilds its nested tree recursively).

Trait Implementations

impl<C, E, GroupContext, F, GroupFormat> Clone for Node<C, E, GroupContext, F, GroupFormat>

where C: Clone, E: Clone, GroupContext: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C, E, GroupContext, F, GroupFormat> Debug for Node<C, E, GroupContext, F, GroupFormat>

where C: Debug, E: Debug, GroupContext: Debug,

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

Formats the value using the given formatter.

impl<C, E, GroupContext, F, GroupFormat> Display for Node<C, E, GroupContext, F, GroupFormat>

where E: Error + 'static, F: Format<WithContext<C, E, F>>, GroupFormat: Format<GroupContext>,

Renders the child standalone: a leaf via its own WithContext Display (the pair through F), a group via Subgroup’s Display ("{label} (…shallow summary…)").

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

Formats the value using the given formatter.

impl<C, E, GroupContext, F, GroupFormat> Eq for Node<C, E, GroupContext, F, GroupFormat>

where C: Eq, E: Eq, GroupContext: Eq,

impl<C, E, GroupContext, F, GroupFormat> Error for Node<C, E, GroupContext, F, GroupFormat>

where C: Debug, GroupContext: Debug, E: Error + 'static, F: Format<WithContext<C, E, F>>, GroupFormat: Format<GroupContext>,

fn source(&self) -> Option<&(dyn Error + 'static)>

A leaf delegates to WithContext’s source (which skips the inner error itself — Display already shows it); a group returns None (an aggregate of independent siblings has no single linear cause, matching ManyErrors).

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl<C, E, GC, F, GF> Extend<Node<C, E, GC, F, GF>> for ManyErrors<C, E, GC, F, GF>

Appends arbitrary children — leaves and groups.

fn extend<I: IntoIterator<Item = Node<C, E, GC, F, GF>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<C, E, GroupContext, F, GroupFormat> From<(C, E)> for Node<C, E, GroupContext, F, GroupFormat>

fn from((context, error): (C, E)) -> Self

Converts to this type from the input type.

impl<C, E, GroupContext, F, GroupFormat> From<Subgroup<C, E, GroupContext, F, GroupFormat>> for Node<C, E, GroupContext, F, GroupFormat>

fn from(group: Subgroup<C, E, GroupContext, F, GroupFormat>) -> Self

Converts to this type from the input type.

impl<C, E, GroupContext, F, GroupFormat> From<WithContext<C, E, F>> for Node<C, E, GroupContext, F, GroupFormat>

fn from(w: WithContext<C, E, F>) -> Self

Converts to this type from the input type.

impl<C, E, GC, F, GF> FromIterator<Node<C, E, GC, F, GF>> for ManyErrors<C, E, GC, F, GF>

Builds an aggregate from arbitrary children — leaves and groups — so a whole tree can be collected iteratively (unlike the leaf-only WithContext/(C, E) impls).

fn from_iter<I: IntoIterator<Item = Node<C, E, GC, F, GF>>>(iter: I) -> Self

Creates a value from an iterator.

impl<C, E, GroupContext, F, GroupFormat> Hash for Node<C, E, GroupContext, F, GroupFormat>

where C: Hash, E: Hash, GroupContext: Hash,

fn hash<__H: Hasher>(&self, __state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<C, E, GroupContext, F, GroupFormat> PartialEq for Node<C, E, GroupContext, F, GroupFormat>

where C: PartialEq, E: PartialEq, GroupContext: 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.