CODEWITHSUNDEEP
error-handlingrustiteratorrust-result
msrd0
msrd0

Reputation: 8390

Idiomatic way to collect all errors from an iterator

Let's say I have a attrs: Vec<Attribute> of some function attributes and a function fn map_attribute(attr: &Attribute) -> Result<TokenStream, Error> that maps the attributes to some code.

I know that I could write something like this:

attrs.into_iter()
     .map(map_attribute)
     .collect::<Result<Vec<_>, _>()?

However, this is not what I want. What I want is spit out all errors at once, not stop with the first Error. Currently I do something like this:

let mut codes : Vec<TokenStream> = Vec::new();
let mut errors: Vec<Error>       = Vec::new();

for attr in attrs {
    match map_attribute(attr) {
        Ok(code) => codes.push(code),
        Err(err) => errors.push(err)
    }
}

let mut error_iter = errors.into_iter();
if let Some(first) = error_iter.nth(0) {
    return Err(iter.fold(first, |mut e0, e1| { e0.combine(e1); e0 }));
}

This second version does what I want, but is considerably more verbose than the first version. Is there a better / more idiomatic way to acchieve this, if possible without creating my own iterator?

Upvotes: 4

Views: 1490

Answers (2)

msrd0
msrd0

Reputation: 8390

I ended up writing my own extension for Iterator, which allows me to stop collecting codes when I encounter my first error. This is in my use case probably a bit more efficient than the answer by mcarton, since I only need the first partition bucket if the second one is empty. Also, I need to fold the errors anyways if I want to combine them into a single error.

pub trait CollectToResult
{
    type Item;

    fn collect_to_result(self) -> Result<Vec<Self::Item>, Error>;
}

impl<Item, I> CollectToResult for I
where
    I : Iterator<Item = Result<Item, Error>>
{
    type Item = Item;

    fn collect_to_result(self) -> Result<Vec<Item>, Error>
    {
        self.fold(<Result<Vec<Item>, Error>>::Ok(Vec::new()), |res, code| {
            match (code, res) {
                (Ok(code), Ok(mut codes)) => { codes.push(code); Ok(codes) },
                (Ok(_), Err(errors)) => Err(errors),
                (Err(err), Ok(_)) => Err(err),
                (Err(err), Err(mut errors)) => { errors.combine(err); Err(errors) }
            }
        })
    }
}

Upvotes: 0

mcarton
mcarton

Reputation: 30061

The standard library does not have a convenient one-liner for this as far as I know, however the excellent itertools library does:

use itertools::Itertools; // 0.9.0

fn main() {
    let foo = vec![Ok(42), Err(":("), Ok(321), Err("oh noes")];

    let (codes, errors): (Vec<_>, Vec<_>)
        = foo.into_iter().partition_map(From::from);

    println!("codes={:?}", codes);
    println!("errors={:?}", errors);
}

(Permalink to the playground)

Upvotes: 1

Related Questions