Enum ErrorTree

pub enum ErrorTree<L, E> {
    Leaf(E),
    Edge(L, Box<ErrorTree<L, E>>),
    Vec(Vec<ErrorTree<L, E>>),
}

The error Tree structure.

• L is the Label type.
• E is the inner Error type. It can be an error enum (from the thiserror package).

Variants

Leaf(E)

Stores your single error type.

Edge(L, Box<ErrorTree<L, E>>)

Adds a label to the subtree.

Vec(Vec<ErrorTree<L, E>>)

Groups multiple subtrees at the same level.

Implementations

impl<L, E> ErrorTree<L, E>

pub fn leaf(error: E) -> Self

Creates a Leaf tree from an error.

struct Error(String);
let error_tree = ErrorTree::<&'static str, _>::leaf(Error("error".into()));

impl<L, E> ErrorTree<L, E>

where L: Clone,

pub fn flatten_tree(self) -> Vec<FlatError<L, E>>

Flattens the error tree in a Vec of FlatErrors.

#[derive(Debug)]
struct Error(String);

let error_1 = ErrorTree::leaf(Error("error1".into())).with_label("label1");
let error_2 = ErrorTree::leaf(Error("error2".into())).with_label("label2");

let errors = vec![error_1, error_2];

let tree: ErrorTree<&'static str, Error> = errors.into();
let tree = tree.with_label("parent_label");

let flat_errors = tree.flatten_tree();

assert!(
    matches!(
        &flat_errors[..],
        [
            FlatError {
                path: path1,
                error: Error(error1),
            },
            FlatError {
                path: path2,
                error: Error(error2),
            },
        ]
        if path1 == &vec!["label1", "parent_label"]
        && path2 == &vec!["label2", "parent_label"]
        && error1 == "error1"
        && error2 == "error2"
    ),
    "unexpected: {:#?}",
    flat_errors
);

Trait Implementations

impl<L: Debug, E: Debug> Debug for ErrorTree<L, E>

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

Formats the value using the given formatter.

impl<L, E> From<Vec<E>> for ErrorTree<L, E>

where E: IntoErrorTree<L, E>, ErrorTree<L, E>: From<E>,

fn from(errors: Vec<E>) -> Self

Converts to this type from the input type.

impl<L, E> From<Vec<ErrorTree<L, E>>> for ErrorTree<L, E>

fn from(subtrees: Vec<ErrorTree<L, E>>) -> Self

Converts to this type from the input type.

impl<L, E> IntoErrorTree<L, E> for ErrorTree<L, E>

fn with_label(self, label: L) -> ErrorTree<L, E>

Adds a label to an error tree.