Error Trees

Fail in a spectacular manner with multiple errors, instead only a single one!

```rust // The error type

[derive(Debug)]

struct Error(String);

impl From for ErrorTree { fn from(e: Error) -> Self { Self::leaf(e) } }

// A function that returns an error fn faulty_function() -> Result<(), Error> { Err(Error("error".into())) }

// A function that returns more than one error fn parentfunction() -> Result> { let result1 = faultyfunction().labelerror("first faulty"); let result2 = faultyfunction().label_error("second faulty");

let result: Result<_, ErrorTree<_, _>> = vec![result1, result2]
    .into_iter()
    .partition_result::<Vec<_>, Vec<_>, _, _>()
    .into_result();
result.label_error("parent function")

}

// your main function

[test]

fn mainfunction() { let result = parentfunction();

let flat_results = result.flatten_results();
let flat_errors: Vec<FlatError<&str, Error>> = flat_results.unwrap_err();

assert!(
    matches!(
        &flat_errors[..],
        [
            FlatError {
                path: path1,
                error: Error(_),
            },
            FlatError {
                path: path2,
                error: Error(_),
            },
        ]
        if path1 == &vec!["first faulty", "parent function"]
        && path2 == &vec!["second faulty", "parent function"]
    ),
    "unexpected: {:#?}",
    flat_errors
);

} ```