iterator_ext/
try_flatten_results.rs

1use crate::common::*;
2
3#[derive(Debug)]
4pub struct TryFlattenResults<I, J> {
5    pub(super) iter: Option<I>,
6    pub(super) sub_iter: Option<J>,
7}
8
9impl<I, J, T, U, E> Iterator for TryFlattenResults<I, J>
10where
11    I: Iterator<Item = Result<T, E>>,
12    J: Iterator<Item = Result<U, E>>,
13    T: IntoIterator<Item = Result<U, E>, IntoIter = J>,
14{
15    type Item = Result<U, E>;
16
17    fn next(&mut self) -> Option<Self::Item> {
18        let mut iter = match self.iter.take() {
19            Some(iter) => iter,
20            None => return None,
21        };
22
23        let mut sub_iter = match self.sub_iter.take() {
24            Some(sub_iter) => sub_iter,
25            None => {
26                let item = match iter.next() {
27                    Some(Ok(item)) => item,
28                    Some(Err(err)) => {
29                        return Some(Err(err));
30                    }
31                    None => {
32                        return None;
33                    }
34                };
35                item.into_iter()
36            }
37        };
38
39        loop {
40            match sub_iter.next() {
41                Some(Ok(item)) => {
42                    self.iter = Some(iter);
43                    self.sub_iter = Some(sub_iter);
44                    return Some(Ok(item));
45                }
46                Some(Err(err)) => {
47                    return Some(Err(err));
48                }
49                None => {
50                    let item = match iter.next() {
51                        Some(Ok(item)) => item,
52                        Some(Err(err)) => {
53                            return Some(Err(err));
54                        }
55                        None => {
56                            return None;
57                        }
58                    };
59                    sub_iter = item.into_iter();
60                }
61            }
62        }
63    }
64}