/rust/registry/src/index.crates.io-6f17d22bba15001f/either-1.13.0/src/iterator.rs

Source (jump to first uncovered line)
use super::{for_both, Either, Left, Right};
use core::iter;

macro_rules! wrap_either {
    ($value:expr => $( $tail:tt )*) => {
        match $value {
            Left(inner) => inner.map(Left) $($tail)*,
            Right(inner) => inner.map(Right) $($tail)*,
        }
    };
}

/// Iterator that maps left or right iterators to corresponding `Either`-wrapped items.
///
/// This struct is created by the [`Either::factor_into_iter`],
/// [`factor_iter`][Either::factor_iter],
/// and [`factor_iter_mut`][Either::factor_iter_mut] methods.
#[derive(Clone, Debug)]
pub struct IterEither<L, R> {
    inner: Either<L, R>,
}

impl<L, R> IterEither<L, R> {
    pub(crate) fn new(inner: Either<L, R>) -> Self {
        IterEither { inner }
    }
}

impl<L, R, A> Extend<A> for Either<L, R>
where
    L: Extend<A>,
    R: Extend<A>,
{
    fn extend<T>(&mut self, iter: T)
    where
        T: IntoIterator<Item = A>,
    {
        for_both!(*self, ref mut inner => inner.extend(iter))
    }
}

/// `Either<L, R>` is an iterator if both `L` and `R` are iterators.
impl<L, R> Iterator for Either<L, R>
where
    L: Iterator,
    R: Iterator<Item = L::Item>,
{
    type Item = L::Item;

    fn next(&mut self) -> Option<Self::Item> {
        for_both!(*self, ref mut inner => inner.next())
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        for_both!(*self, ref inner => inner.size_hint())
    }

    fn fold<Acc, G>(self, init: Acc, f: G) -> Acc
    where
        G: FnMut(Acc, Self::Item) -> Acc,
    {
        for_both!(self, inner => inner.fold(init, f))
    }

    fn for_each<F>(self, f: F)
    where
        F: FnMut(Self::Item),
    {
        for_both!(self, inner => inner.for_each(f))
    }

    fn count(self) -> usize {
        for_both!(self, inner => inner.count())
    }

    fn last(self) -> Option<Self::Item> {
        for_both!(self, inner => inner.last())
    }

    fn nth(&mut self, n: usize) -> Option<Self::Item> {
        for_both!(*self, ref mut inner => inner.nth(n))
    }

    fn collect<B>(self) -> B
    where
        B: iter::FromIterator<Self::Item>,
    {
        for_both!(self, inner => inner.collect())
    }

    fn partition<B, F>(self, f: F) -> (B, B)
    where
        B: Default + Extend<Self::Item>,
        F: FnMut(&Self::Item) -> bool,
    {
        for_both!(self, inner => inner.partition(f))
    }

    fn all<F>(&mut self, f: F) -> bool
    where
        F: FnMut(Self::Item) -> bool,
    {
        for_both!(*self, ref mut inner => inner.all(f))
    }

    fn any<F>(&mut self, f: F) -> bool
    where
        F: FnMut(Self::Item) -> bool,
    {
        for_both!(*self, ref mut inner => inner.any(f))
    }

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
        P: FnMut(&Self::Item) -> bool,
    {
        for_both!(*self, ref mut inner => inner.find(predicate))
    }

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
        F: FnMut(Self::Item) -> Option<B>,
    {
        for_both!(*self, ref mut inner => inner.find_map(f))
    }

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
        P: FnMut(Self::Item) -> bool,
    {
        for_both!(*self, ref mut inner => inner.position(predicate))
    }
}

impl<L, R> DoubleEndedIterator for Either<L, R>
where
    L: DoubleEndedIterator,
    R: DoubleEndedIterator<Item = L::Item>,
{
    fn next_back(&mut self) -> Option<Self::Item> {
        for_both!(*self, ref mut inner => inner.next_back())
    }

    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
        for_both!(*self, ref mut inner => inner.nth_back(n))
    }

    fn rfold<Acc, G>(self, init: Acc, f: G) -> Acc
    where
        G: FnMut(Acc, Self::Item) -> Acc,
    {
        for_both!(self, inner => inner.rfold(init, f))
    }

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
        P: FnMut(&Self::Item) -> bool,
    {
        for_both!(*self, ref mut inner => inner.rfind(predicate))
    }
}

impl<L, R> ExactSizeIterator for Either<L, R>
where
    L: ExactSizeIterator,
    R: ExactSizeIterator<Item = L::Item>,
{
    fn len(&self) -> usize {
        for_both!(*self, ref inner => inner.len())
    }
}

impl<L, R> iter::FusedIterator for Either<L, R>
where
    L: iter::FusedIterator,
    R: iter::FusedIterator<Item = L::Item>,
{
}

impl<L, R> Iterator for IterEither<L, R>
where
    L: Iterator,
    R: Iterator,
{
    type Item = Either<L::Item, R::Item>;

    fn next(&mut self) -> Option<Self::Item> {
        Some(map_either!(self.inner, ref mut inner => inner.next()?))
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        for_both!(self.inner, ref inner => inner.size_hint())
    }

    fn fold<Acc, G>(self, init: Acc, f: G) -> Acc
    where
        G: FnMut(Acc, Self::Item) -> Acc,
    {
        wrap_either!(self.inner => .fold(init, f))
    }

    fn for_each<F>(self, f: F)
    where
        F: FnMut(Self::Item),
    {
        wrap_either!(self.inner => .for_each(f))
    }

    fn count(self) -> usize {
        for_both!(self.inner, inner => inner.count())
    }

    fn last(self) -> Option<Self::Item> {
        Some(map_either!(self.inner, inner => inner.last()?))
    }

    fn nth(&mut self, n: usize) -> Option<Self::Item> {
        Some(map_either!(self.inner, ref mut inner => inner.nth(n)?))
    }

    fn collect<B>(self) -> B
    where
        B: iter::FromIterator<Self::Item>,
    {
        wrap_either!(self.inner => .collect())
    }

    fn partition<B, F>(self, f: F) -> (B, B)
    where
        B: Default + Extend<Self::Item>,
        F: FnMut(&Self::Item) -> bool,
    {
        wrap_either!(self.inner => .partition(f))
    }

    fn all<F>(&mut self, f: F) -> bool
    where
        F: FnMut(Self::Item) -> bool,
    {
        wrap_either!(&mut self.inner => .all(f))
    }

    fn any<F>(&mut self, f: F) -> bool
    where
        F: FnMut(Self::Item) -> bool,
    {
        wrap_either!(&mut self.inner => .any(f))
    }

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
        P: FnMut(&Self::Item) -> bool,
    {
        wrap_either!(&mut self.inner => .find(predicate))
    }

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
        F: FnMut(Self::Item) -> Option<B>,
    {
        wrap_either!(&mut self.inner => .find_map(f))
    }

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
        P: FnMut(Self::Item) -> bool,
    {
        wrap_either!(&mut self.inner => .position(predicate))
    }
}

impl<L, R> DoubleEndedIterator for IterEither<L, R>
where
    L: DoubleEndedIterator,
    R: DoubleEndedIterator,
{
    fn next_back(&mut self) -> Option<Self::Item> {
        Some(map_either!(self.inner, ref mut inner => inner.next_back()?))
    }

    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
        Some(map_either!(self.inner, ref mut inner => inner.nth_back(n)?))
    }

    fn rfold<Acc, G>(self, init: Acc, f: G) -> Acc
    where
        G: FnMut(Acc, Self::Item) -> Acc,
    {
        wrap_either!(self.inner => .rfold(init, f))
    }

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
        P: FnMut(&Self::Item) -> bool,
    {
        wrap_either!(&mut self.inner => .rfind(predicate))
    }
}

impl<L, R> ExactSizeIterator for IterEither<L, R>
where
    L: ExactSizeIterator,
    R: ExactSizeIterator,
{
    fn len(&self) -> usize {
        for_both!(self.inner, ref inner => inner.len())
    }
}

impl<L, R> iter::FusedIterator for IterEither<L, R>
where
    L: iter::FusedIterator,
    R: iter::FusedIterator,
{
}

Coverage Report

Created: 2025-08-26 06:41

Line	Count	Source (jump to first uncovered line)
1		use super::{for_both, Either, Left, Right};
2		use core::iter;
3
4		macro_rules! wrap_either {
5		($value:expr => $( $tail:tt )*) => {
6		match $value {
7		Left(inner) => inner.map(Left) $($tail)*,
8		Right(inner) => inner.map(Right) $($tail)*,
9		}
10		};
11		}
12
13		/// Iterator that maps left or right iterators to corresponding `Either`-wrapped items.
14		///
15		/// This struct is created by the [`Either::factor_into_iter`],
16		/// [`factor_iter`][Either::factor_iter],
17		/// and [`factor_iter_mut`][Either::factor_iter_mut] methods.
18		#[derive(Clone, Debug)]
19		pub struct IterEither<L, R> {
20		inner: Either<L, R>,
21		}
22
23		impl<L, R> IterEither<L, R> {
24		pub(crate) fn new(inner: Either<L, R>) -> Self {
25		IterEither { inner }
26		}
27		}
28
29		impl<L, R, A> Extend<A> for Either<L, R>
30		where
31		L: Extend<A>,
32		R: Extend<A>,
33		{
34		fn extend<T>(&mut self, iter: T)
35		where
36		T: IntoIterator<Item = A>,
37		{
38		for_both!(*self, ref mut inner => inner.extend(iter))
39		}
40		}
41
42		/// `Either<L, R>` is an iterator if both `L` and `R` are iterators.
43		impl<L, R> Iterator for Either<L, R>
44		where
45		L: Iterator,
46		R: Iterator<Item = L::Item>,
47		{
48		type Item = L::Item;
49
50	0	fn next(&mut self) -> Option<Self::Item> {
51	0	for_both!(*self, ref mut inner => inner.next())
52	0	}
53
54		fn size_hint(&self) -> (usize, Option<usize>) {
55		for_both!(*self, ref inner => inner.size_hint())
56		}
57
58		fn fold<Acc, G>(self, init: Acc, f: G) -> Acc
59		where
60		G: FnMut(Acc, Self::Item) -> Acc,
61		{
62		for_both!(self, inner => inner.fold(init, f))
63		}
64
65		fn for_each<F>(self, f: F)
66		where
67		F: FnMut(Self::Item),
68		{
69		for_both!(self, inner => inner.for_each(f))
70		}
71
72		fn count(self) -> usize {
73		for_both!(self, inner => inner.count())
74		}
75
76		fn last(self) -> Option<Self::Item> {
77		for_both!(self, inner => inner.last())
78		}
79
80		fn nth(&mut self, n: usize) -> Option<Self::Item> {
81		for_both!(*self, ref mut inner => inner.nth(n))
82		}
83
84		fn collect<B>(self) -> B
85		where
86		B: iter::FromIterator<Self::Item>,
87		{
88		for_both!(self, inner => inner.collect())
89		}
90
91		fn partition<B, F>(self, f: F) -> (B, B)
92		where
93		B: Default + Extend<Self::Item>,
94		F: FnMut(&Self::Item) -> bool,
95		{
96		for_both!(self, inner => inner.partition(f))
97		}
98
99		fn all<F>(&mut self, f: F) -> bool
100		where
101		F: FnMut(Self::Item) -> bool,
102		{
103		for_both!(*self, ref mut inner => inner.all(f))
104		}
105
106		fn any<F>(&mut self, f: F) -> bool
107		where
108		F: FnMut(Self::Item) -> bool,
109		{
110		for_both!(*self, ref mut inner => inner.any(f))
111		}
112
113		fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
114		where
115		P: FnMut(&Self::Item) -> bool,
116		{
117		for_both!(*self, ref mut inner => inner.find(predicate))
118		}
119
120		fn find_map<B, F>(&mut self, f: F) -> Option<B>
121		where
122		F: FnMut(Self::Item) -> Option<B>,
123		{
124		for_both!(*self, ref mut inner => inner.find_map(f))
125		}
126
127		fn position<P>(&mut self, predicate: P) -> Option<usize>
128		where
129		P: FnMut(Self::Item) -> bool,
130		{
131		for_both!(*self, ref mut inner => inner.position(predicate))
132		}
133		}
134
135		impl<L, R> DoubleEndedIterator for Either<L, R>
136		where
137		L: DoubleEndedIterator,
138		R: DoubleEndedIterator<Item = L::Item>,
139		{
140		fn next_back(&mut self) -> Option<Self::Item> {
141		for_both!(*self, ref mut inner => inner.next_back())
142		}
143
144		fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
145		for_both!(*self, ref mut inner => inner.nth_back(n))
146		}
147
148		fn rfold<Acc, G>(self, init: Acc, f: G) -> Acc
149		where
150		G: FnMut(Acc, Self::Item) -> Acc,
151		{
152		for_both!(self, inner => inner.rfold(init, f))
153		}
154
155		fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
156		where
157		P: FnMut(&Self::Item) -> bool,
158		{
159		for_both!(*self, ref mut inner => inner.rfind(predicate))
160		}
161		}
162
163		impl<L, R> ExactSizeIterator for Either<L, R>
164		where
165		L: ExactSizeIterator,
166		R: ExactSizeIterator<Item = L::Item>,
167		{
168		fn len(&self) -> usize {
169		for_both!(*self, ref inner => inner.len())
170		}
171		}
172
173		impl<L, R> iter::FusedIterator for Either<L, R>
174		where
175		L: iter::FusedIterator,
176		R: iter::FusedIterator<Item = L::Item>,
177		{
178		}
179
180		impl<L, R> Iterator for IterEither<L, R>
181		where
182		L: Iterator,
183		R: Iterator,
184		{
185		type Item = Either<L::Item, R::Item>;
186
187		fn next(&mut self) -> Option<Self::Item> {
188		Some(map_either!(self.inner, ref mut inner => inner.next()?))
189		}
190
191		fn size_hint(&self) -> (usize, Option<usize>) {
192		for_both!(self.inner, ref inner => inner.size_hint())
193		}
194
195		fn fold<Acc, G>(self, init: Acc, f: G) -> Acc
196		where
197		G: FnMut(Acc, Self::Item) -> Acc,
198		{
199		wrap_either!(self.inner => .fold(init, f))
200		}
201
202		fn for_each<F>(self, f: F)
203		where
204		F: FnMut(Self::Item),
205		{
206		wrap_either!(self.inner => .for_each(f))
207		}
208
209		fn count(self) -> usize {
210		for_both!(self.inner, inner => inner.count())
211		}
212
213		fn last(self) -> Option<Self::Item> {
214		Some(map_either!(self.inner, inner => inner.last()?))
215		}
216
217		fn nth(&mut self, n: usize) -> Option<Self::Item> {
218		Some(map_either!(self.inner, ref mut inner => inner.nth(n)?))
219		}
220
221		fn collect<B>(self) -> B
222		where
223		B: iter::FromIterator<Self::Item>,
224		{
225		wrap_either!(self.inner => .collect())
226		}
227
228		fn partition<B, F>(self, f: F) -> (B, B)
229		where
230		B: Default + Extend<Self::Item>,
231		F: FnMut(&Self::Item) -> bool,
232		{
233		wrap_either!(self.inner => .partition(f))
234		}
235
236		fn all<F>(&mut self, f: F) -> bool
237		where
238		F: FnMut(Self::Item) -> bool,
239		{
240		wrap_either!(&mut self.inner => .all(f))
241		}
242
243		fn any<F>(&mut self, f: F) -> bool
244		where
245		F: FnMut(Self::Item) -> bool,
246		{
247		wrap_either!(&mut self.inner => .any(f))
248		}
249
250		fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
251		where
252		P: FnMut(&Self::Item) -> bool,
253		{
254		wrap_either!(&mut self.inner => .find(predicate))
255		}
256
257		fn find_map<B, F>(&mut self, f: F) -> Option<B>
258		where
259		F: FnMut(Self::Item) -> Option<B>,
260		{
261		wrap_either!(&mut self.inner => .find_map(f))
262		}
263
264		fn position<P>(&mut self, predicate: P) -> Option<usize>
265		where
266		P: FnMut(Self::Item) -> bool,
267		{
268		wrap_either!(&mut self.inner => .position(predicate))
269		}
270		}
271
272		impl<L, R> DoubleEndedIterator for IterEither<L, R>
273		where
274		L: DoubleEndedIterator,
275		R: DoubleEndedIterator,
276		{
277		fn next_back(&mut self) -> Option<Self::Item> {
278		Some(map_either!(self.inner, ref mut inner => inner.next_back()?))
279		}
280
281		fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
282		Some(map_either!(self.inner, ref mut inner => inner.nth_back(n)?))
283		}
284
285		fn rfold<Acc, G>(self, init: Acc, f: G) -> Acc
286		where
287		G: FnMut(Acc, Self::Item) -> Acc,
288		{
289		wrap_either!(self.inner => .rfold(init, f))
290		}
291
292		fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
293		where
294		P: FnMut(&Self::Item) -> bool,
295		{
296		wrap_either!(&mut self.inner => .rfind(predicate))
297		}
298		}
299
300		impl<L, R> ExactSizeIterator for IterEither<L, R>
301		where
302		L: ExactSizeIterator,
303		R: ExactSizeIterator,
304		{
305		fn len(&self) -> usize {
306		for_both!(self.inner, ref inner => inner.len())
307		}
308		}
309
310		impl<L, R> iter::FusedIterator for IterEither<L, R>
311		where
312		L: iter::FusedIterator,
313		R: iter::FusedIterator,
314		{
315		}