itertools/
process_results_impl.rs1#[cfg(doc)]
2use crate::Itertools;
3
4#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
10#[derive(Debug)]
11pub struct ProcessResults<'a, I, E: 'a> {
12 error: &'a mut Result<(), E>,
13 iter: I,
14}
15
16impl<'a, I, T, E> Iterator for ProcessResults<'a, I, E>
17where
18 I: Iterator<Item = Result<T, E>>,
19{
20 type Item = T;
21
22 fn next(&mut self) -> Option<Self::Item> {
23 match self.iter.next() {
24 Some(Ok(x)) => Some(x),
25 Some(Err(e)) => {
26 *self.error = Err(e);
27 None
28 }
29 None => None,
30 }
31 }
32
33 fn size_hint(&self) -> (usize, Option<usize>) {
34 (0, self.iter.size_hint().1)
35 }
36
37 fn fold<B, F>(mut self, init: B, mut f: F) -> B
38 where
39 Self: Sized,
40 F: FnMut(B, Self::Item) -> B,
41 {
42 let error = self.error;
43 self.iter
44 .try_fold(init, |acc, opt| match opt {
45 Ok(x) => Ok(f(acc, x)),
46 Err(e) => {
47 *error = Err(e);
48 Err(acc)
49 }
50 })
51 .unwrap_or_else(|e| e)
52 }
53}
54
55pub fn process_results<I, F, T, E, R>(iterable: I, processor: F) -> Result<R, E>
60where
61 I: IntoIterator<Item = Result<T, E>>,
62 F: FnOnce(ProcessResults<I::IntoIter, E>) -> R,
63{
64 let iter = iterable.into_iter();
65 let mut error = Ok(());
66
67 let result = processor(ProcessResults {
68 error: &mut error,
69 iter,
70 });
71
72 error.map(|_| result)
73}