1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#[derive(Debug, Clone)]
pub struct MapIter<Iter: Iterator, F: FnMut(Iter::Item) -> Result<Iter::Item,E>, E> {
iter: Iter,
failed: Vec<Iter::Item>,
f: F,
}
impl<Iter: Iterator, F: FnMut(Iter::Item) -> Result<Iter::Item,E>, E> MapIter<Iter, F, E> {
fn new(iter: Iter, f: F) -> Self {
MapIter {
iter,
failed: vec![],
f,
}
}
}
pub trait MapRetry: Iterator + Sized {
fn map_retry<F: FnMut(Self::Item) -> Result<Self::Item,E>, E>(self, f: F) -> MapIter<Self, F, E>
where;
}
impl<T: Iterator> MapRetry for T {
fn map_retry<F: FnMut(T::Item) -> Result<Self::Item,E>, E>(self, f: F) -> MapIter<Self, F, E> {
MapIter::new(self, f)
}
}
impl<Iter: Iterator + Clone, F: FnMut(Iter::Item) -> Result<Iter::Item,E>, E> Iterator
for MapIter<Iter, F, E>
where
Iter::Item: Clone,
{
type Item = Result<Iter::Item, E>;
fn next(&mut self) -> Option<Self::Item> {
let mut res;
while {
res = self.iter.next();
res.is_some()
} {
let res = res?;
let m = (self.f)(res.clone());
if m.is_ok() {
return Some(m);
} else {
self.failed.push(res);
}
}
Some((self.f)(self.failed.pop()?))
}
}