7 use super::{Iterator, DoubleEndedIterator, ExactSizeIterator, FusedIterator, TrustedLen};
14 pub use self::chain::Chain;
15 #[stable(feature = "rust1", since = "1.0.0")]
16 pub use self::flatten::{FlatMap, Flatten};
17 pub use self::zip::Zip;
18 pub(crate) use self::zip::TrustedRandomAccess;
20 /// A double-ended iterator with the direction inverted.
22 /// This `struct` is created by the [`rev`] method on [`Iterator`]. See its
23 /// documentation for more.
25 /// [`rev`]: trait.Iterator.html#method.rev
26 /// [`Iterator`]: trait.Iterator.html
27 #[derive(Clone, Debug)]
28 #[must_use = "iterators are lazy and do nothing unless consumed"]
29 #[stable(feature = "rust1", since = "1.0.0")]
34 pub(super) fn new(iter: T) -> Rev<T> {
39 #[stable(feature = "rust1", since = "1.0.0")]
40 impl<I> Iterator for Rev<I> where I: DoubleEndedIterator {
41 type Item = <I as Iterator>::Item;
44 fn next(&mut self) -> Option<<I as Iterator>::Item> { self.iter.next_back() }
46 fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
49 fn nth(&mut self, n: usize) -> Option<<I as Iterator>::Item> { self.iter.nth_back(n) }
51 fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
52 Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>
54 self.iter.try_rfold(init, f)
57 fn fold<Acc, F>(self, init: Acc, f: F) -> Acc
58 where F: FnMut(Acc, Self::Item) -> Acc,
60 self.iter.rfold(init, f)
64 fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
65 where P: FnMut(&Self::Item) -> bool
67 self.iter.rfind(predicate)
71 fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
72 P: FnMut(Self::Item) -> bool
74 self.iter.position(predicate)
78 #[stable(feature = "rust1", since = "1.0.0")]
79 impl<I> DoubleEndedIterator for Rev<I> where I: DoubleEndedIterator {
81 fn next_back(&mut self) -> Option<<I as Iterator>::Item> { self.iter.next() }
84 fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item> { self.iter.nth(n) }
86 fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
87 Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>
89 self.iter.try_fold(init, f)
92 fn rfold<Acc, F>(self, init: Acc, f: F) -> Acc
93 where F: FnMut(Acc, Self::Item) -> Acc,
95 self.iter.fold(init, f)
98 fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
99 where P: FnMut(&Self::Item) -> bool
101 self.iter.find(predicate)
105 #[stable(feature = "rust1", since = "1.0.0")]
106 impl<I> ExactSizeIterator for Rev<I>
107 where I: ExactSizeIterator + DoubleEndedIterator
109 fn len(&self) -> usize {
113 fn is_empty(&self) -> bool {
118 #[stable(feature = "fused", since = "1.26.0")]
119 impl<I> FusedIterator for Rev<I>
120 where I: FusedIterator + DoubleEndedIterator {}
122 #[unstable(feature = "trusted_len", issue = "37572")]
123 unsafe impl<I> TrustedLen for Rev<I>
124 where I: TrustedLen + DoubleEndedIterator {}
126 /// An iterator that copies the elements of an underlying iterator.
128 /// This `struct` is created by the [`copied`] method on [`Iterator`]. See its
129 /// documentation for more.
131 /// [`copied`]: trait.Iterator.html#method.copied
132 /// [`Iterator`]: trait.Iterator.html
133 #[stable(feature = "iter_copied", since = "1.36.0")]
134 #[must_use = "iterators are lazy and do nothing unless consumed"]
135 #[derive(Clone, Debug)]
136 pub struct Copied<I> {
141 pub(super) fn new(it: I) -> Copied<I> {
146 #[stable(feature = "iter_copied", since = "1.36.0")]
147 impl<'a, I, T: 'a> Iterator for Copied<I>
148 where I: Iterator<Item=&'a T>, T: Copy
152 fn next(&mut self) -> Option<T> {
153 self.it.next().copied()
156 fn size_hint(&self) -> (usize, Option<usize>) {
160 fn try_fold<B, F, R>(&mut self, init: B, mut f: F) -> R where
161 Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>
163 self.it.try_fold(init, move |acc, &elt| f(acc, elt))
166 fn fold<Acc, F>(self, init: Acc, mut f: F) -> Acc
167 where F: FnMut(Acc, Self::Item) -> Acc,
169 self.it.fold(init, move |acc, &elt| f(acc, elt))
173 #[stable(feature = "iter_copied", since = "1.36.0")]
174 impl<'a, I, T: 'a> DoubleEndedIterator for Copied<I>
175 where I: DoubleEndedIterator<Item=&'a T>, T: Copy
177 fn next_back(&mut self) -> Option<T> {
178 self.it.next_back().copied()
181 fn try_rfold<B, F, R>(&mut self, init: B, mut f: F) -> R where
182 Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>
184 self.it.try_rfold(init, move |acc, &elt| f(acc, elt))
187 fn rfold<Acc, F>(self, init: Acc, mut f: F) -> Acc
188 where F: FnMut(Acc, Self::Item) -> Acc,
190 self.it.rfold(init, move |acc, &elt| f(acc, elt))
194 #[stable(feature = "iter_copied", since = "1.36.0")]
195 impl<'a, I, T: 'a> ExactSizeIterator for Copied<I>
196 where I: ExactSizeIterator<Item=&'a T>, T: Copy
198 fn len(&self) -> usize {
202 fn is_empty(&self) -> bool {
207 #[stable(feature = "iter_copied", since = "1.36.0")]
208 impl<'a, I, T: 'a> FusedIterator for Copied<I>
209 where I: FusedIterator<Item=&'a T>, T: Copy
213 unsafe impl<'a, I, T: 'a> TrustedRandomAccess for Copied<I>
214 where I: TrustedRandomAccess<Item=&'a T>, T: Copy
216 unsafe fn get_unchecked(&mut self, i: usize) -> Self::Item {
217 *self.it.get_unchecked(i)
221 fn may_have_side_effect() -> bool {
222 I::may_have_side_effect()
226 #[stable(feature = "iter_copied", since = "1.36.0")]
227 unsafe impl<'a, I, T: 'a> TrustedLen for Copied<I>
228 where I: TrustedLen<Item=&'a T>,
232 /// An iterator that clones the elements of an underlying iterator.
234 /// This `struct` is created by the [`cloned`] method on [`Iterator`]. See its
235 /// documentation for more.
237 /// [`cloned`]: trait.Iterator.html#method.cloned
238 /// [`Iterator`]: trait.Iterator.html
239 #[stable(feature = "iter_cloned", since = "1.1.0")]
240 #[must_use = "iterators are lazy and do nothing unless consumed"]
241 #[derive(Clone, Debug)]
242 pub struct Cloned<I> {
246 pub(super) fn new(it: I) -> Cloned<I> {
251 #[stable(feature = "iter_cloned", since = "1.1.0")]
252 impl<'a, I, T: 'a> Iterator for Cloned<I>
253 where I: Iterator<Item=&'a T>, T: Clone
257 fn next(&mut self) -> Option<T> {
258 self.it.next().cloned()
261 fn size_hint(&self) -> (usize, Option<usize>) {
265 fn try_fold<B, F, R>(&mut self, init: B, mut f: F) -> R where
266 Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>
268 self.it.try_fold(init, move |acc, elt| f(acc, elt.clone()))
271 fn fold<Acc, F>(self, init: Acc, mut f: F) -> Acc
272 where F: FnMut(Acc, Self::Item) -> Acc,
274 self.it.fold(init, move |acc, elt| f(acc, elt.clone()))
278 #[stable(feature = "iter_cloned", since = "1.1.0")]
279 impl<'a, I, T: 'a> DoubleEndedIterator for Cloned<I>
280 where I: DoubleEndedIterator<Item=&'a T>, T: Clone
282 fn next_back(&mut self) -> Option<T> {
283 self.it.next_back().cloned()
286 fn try_rfold<B, F, R>(&mut self, init: B, mut f: F) -> R where
287 Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>
289 self.it.try_rfold(init, move |acc, elt| f(acc, elt.clone()))
292 fn rfold<Acc, F>(self, init: Acc, mut f: F) -> Acc
293 where F: FnMut(Acc, Self::Item) -> Acc,
295 self.it.rfold(init, move |acc, elt| f(acc, elt.clone()))
299 #[stable(feature = "iter_cloned", since = "1.1.0")]
300 impl<'a, I, T: 'a> ExactSizeIterator for Cloned<I>
301 where I: ExactSizeIterator<Item=&'a T>, T: Clone
303 fn len(&self) -> usize {
307 fn is_empty(&self) -> bool {
312 #[stable(feature = "fused", since = "1.26.0")]
313 impl<'a, I, T: 'a> FusedIterator for Cloned<I>
314 where I: FusedIterator<Item=&'a T>, T: Clone
318 unsafe impl<'a, I, T: 'a> TrustedRandomAccess for Cloned<I>
319 where I: TrustedRandomAccess<Item=&'a T>, T: Clone
321 default unsafe fn get_unchecked(&mut self, i: usize) -> Self::Item {
322 self.it.get_unchecked(i).clone()
326 default fn may_have_side_effect() -> bool { true }
330 unsafe impl<'a, I, T: 'a> TrustedRandomAccess for Cloned<I>
331 where I: TrustedRandomAccess<Item=&'a T>, T: Copy
333 unsafe fn get_unchecked(&mut self, i: usize) -> Self::Item {
334 *self.it.get_unchecked(i)
338 fn may_have_side_effect() -> bool {
339 I::may_have_side_effect()
343 #[unstable(feature = "trusted_len", issue = "37572")]
344 unsafe impl<'a, I, T: 'a> TrustedLen for Cloned<I>
345 where I: TrustedLen<Item=&'a T>,
349 /// An iterator that repeats endlessly.
351 /// This `struct` is created by the [`cycle`] method on [`Iterator`]. See its
352 /// documentation for more.
354 /// [`cycle`]: trait.Iterator.html#method.cycle
355 /// [`Iterator`]: trait.Iterator.html
356 #[derive(Clone, Debug)]
357 #[must_use = "iterators are lazy and do nothing unless consumed"]
358 #[stable(feature = "rust1", since = "1.0.0")]
359 pub struct Cycle<I> {
363 impl<I: Clone> Cycle<I> {
364 pub(super) fn new(iter: I) -> Cycle<I> {
365 Cycle { orig: iter.clone(), iter }
369 #[stable(feature = "rust1", since = "1.0.0")]
370 impl<I> Iterator for Cycle<I> where I: Clone + Iterator {
371 type Item = <I as Iterator>::Item;
374 fn next(&mut self) -> Option<<I as Iterator>::Item> {
375 match self.iter.next() {
376 None => { self.iter = self.orig.clone(); self.iter.next() }
382 fn size_hint(&self) -> (usize, Option<usize>) {
383 // the cycle iterator is either empty or infinite
384 match self.orig.size_hint() {
385 sz @ (0, Some(0)) => sz,
387 _ => (usize::MAX, None)
392 #[stable(feature = "fused", since = "1.26.0")]
393 impl<I> FusedIterator for Cycle<I> where I: Clone + Iterator {}
395 /// An iterator for stepping iterators by a custom amount.
397 /// This `struct` is created by the [`step_by`] method on [`Iterator`]. See
398 /// its documentation for more.
400 /// [`step_by`]: trait.Iterator.html#method.step_by
401 /// [`Iterator`]: trait.Iterator.html
402 #[must_use = "iterators are lazy and do nothing unless consumed"]
403 #[stable(feature = "iterator_step_by", since = "1.28.0")]
404 #[derive(Clone, Debug)]
405 pub struct StepBy<I> {
411 pub(super) fn new(iter: I, step: usize) -> StepBy<I> {
413 StepBy { iter, step: step - 1, first_take: true }
417 #[stable(feature = "iterator_step_by", since = "1.28.0")]
418 impl<I> Iterator for StepBy<I> where I: Iterator {
422 fn next(&mut self) -> Option<Self::Item> {
424 self.first_take = false;
427 self.iter.nth(self.step)
432 fn size_hint(&self) -> (usize, Option<usize>) {
433 let inner_hint = self.iter.size_hint();
436 let f = |n| if n == 0 { 0 } else { 1 + (n-1)/(self.step+1) };
437 (f(inner_hint.0), inner_hint.1.map(f))
439 let f = |n| n / (self.step+1);
440 (f(inner_hint.0), inner_hint.1.map(f))
445 fn nth(&mut self, mut n: usize) -> Option<Self::Item> {
447 self.first_take = false;
448 let first = self.iter.next();
454 // n and self.step are indices, we need to add 1 to get the amount of elements
455 // When calling `.nth`, we need to subtract 1 again to convert back to an index
456 // step + 1 can't overflow because `.step_by` sets `self.step` to `step - 1`
457 let mut step = self.step + 1;
458 // n + 1 could overflow
459 // thus, if n is usize::MAX, instead of adding one, we call .nth(step)
461 self.iter.nth(step - 1);
468 let mul = n.checked_mul(step);
469 if unsafe { intrinsics::likely(mul.is_some()) } {
470 return self.iter.nth(mul.unwrap() - 1);
472 let div_n = usize::MAX / n;
473 let div_step = usize::MAX / step;
474 let nth_n = div_n * n;
475 let nth_step = div_step * step;
476 let nth = if nth_n > nth_step {
483 self.iter.nth(nth - 1);
488 // StepBy can only make the iterator shorter, so the len will still fit.
489 #[stable(feature = "iterator_step_by", since = "1.28.0")]
490 impl<I> ExactSizeIterator for StepBy<I> where I: ExactSizeIterator {}
492 /// An iterator that maps the values of `iter` with `f`.
494 /// This `struct` is created by the [`map`] method on [`Iterator`]. See its
495 /// documentation for more.
497 /// [`map`]: trait.Iterator.html#method.map
498 /// [`Iterator`]: trait.Iterator.html
500 /// # Notes about side effects
502 /// The [`map`] iterator implements [`DoubleEndedIterator`], meaning that
503 /// you can also [`map`] backwards:
506 /// let v: Vec<i32> = vec![1, 2, 3].into_iter().map(|x| x + 1).rev().collect();
508 /// assert_eq!(v, [4, 3, 2]);
511 /// [`DoubleEndedIterator`]: trait.DoubleEndedIterator.html
513 /// But if your closure has state, iterating backwards may act in a way you do
514 /// not expect. Let's go through an example. First, in the forward direction:
519 /// for pair in vec!['a', 'b', 'c'].into_iter()
520 /// .map(|letter| { c += 1; (letter, c) }) {
521 /// println!("{:?}", pair);
525 /// This will print "('a', 1), ('b', 2), ('c', 3)".
527 /// Now consider this twist where we add a call to `rev`. This version will
528 /// print `('c', 1), ('b', 2), ('a', 3)`. Note that the letters are reversed,
529 /// but the values of the counter still go in order. This is because `map()` is
530 /// still being called lazily on each item, but we are popping items off the
531 /// back of the vector now, instead of shifting them from the front.
536 /// for pair in vec!['a', 'b', 'c'].into_iter()
537 /// .map(|letter| { c += 1; (letter, c) })
539 /// println!("{:?}", pair);
542 #[must_use = "iterators are lazy and do nothing unless consumed"]
543 #[stable(feature = "rust1", since = "1.0.0")]
545 pub struct Map<I, F> {
549 impl<I, F> Map<I, F> {
550 pub(super) fn new(iter: I, f: F) -> Map<I, F> {
555 #[stable(feature = "core_impl_debug", since = "1.9.0")]
556 impl<I: fmt::Debug, F> fmt::Debug for Map<I, F> {
557 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
558 f.debug_struct("Map")
559 .field("iter", &self.iter)
564 #[stable(feature = "rust1", since = "1.0.0")]
565 impl<B, I: Iterator, F> Iterator for Map<I, F> where F: FnMut(I::Item) -> B {
569 fn next(&mut self) -> Option<B> {
570 self.iter.next().map(&mut self.f)
574 fn size_hint(&self) -> (usize, Option<usize>) {
575 self.iter.size_hint()
578 fn try_fold<Acc, G, R>(&mut self, init: Acc, mut g: G) -> R where
579 Self: Sized, G: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
582 self.iter.try_fold(init, move |acc, elt| g(acc, f(elt)))
585 fn fold<Acc, G>(self, init: Acc, mut g: G) -> Acc
586 where G: FnMut(Acc, Self::Item) -> Acc,
589 self.iter.fold(init, move |acc, elt| g(acc, f(elt)))
593 #[stable(feature = "rust1", since = "1.0.0")]
594 impl<B, I: DoubleEndedIterator, F> DoubleEndedIterator for Map<I, F> where
595 F: FnMut(I::Item) -> B,
598 fn next_back(&mut self) -> Option<B> {
599 self.iter.next_back().map(&mut self.f)
602 fn try_rfold<Acc, G, R>(&mut self, init: Acc, mut g: G) -> R where
603 Self: Sized, G: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
606 self.iter.try_rfold(init, move |acc, elt| g(acc, f(elt)))
609 fn rfold<Acc, G>(self, init: Acc, mut g: G) -> Acc
610 where G: FnMut(Acc, Self::Item) -> Acc,
613 self.iter.rfold(init, move |acc, elt| g(acc, f(elt)))
617 #[stable(feature = "rust1", since = "1.0.0")]
618 impl<B, I: ExactSizeIterator, F> ExactSizeIterator for Map<I, F>
619 where F: FnMut(I::Item) -> B
621 fn len(&self) -> usize {
625 fn is_empty(&self) -> bool {
630 #[stable(feature = "fused", since = "1.26.0")]
631 impl<B, I: FusedIterator, F> FusedIterator for Map<I, F>
632 where F: FnMut(I::Item) -> B {}
634 #[unstable(feature = "trusted_len", issue = "37572")]
635 unsafe impl<B, I, F> TrustedLen for Map<I, F>
637 F: FnMut(I::Item) -> B {}
640 unsafe impl<B, I, F> TrustedRandomAccess for Map<I, F>
641 where I: TrustedRandomAccess,
642 F: FnMut(I::Item) -> B,
644 unsafe fn get_unchecked(&mut self, i: usize) -> Self::Item {
645 (self.f)(self.iter.get_unchecked(i))
648 fn may_have_side_effect() -> bool { true }
651 /// An iterator that filters the elements of `iter` with `predicate`.
653 /// This `struct` is created by the [`filter`] method on [`Iterator`]. See its
654 /// documentation for more.
656 /// [`filter`]: trait.Iterator.html#method.filter
657 /// [`Iterator`]: trait.Iterator.html
658 #[must_use = "iterators are lazy and do nothing unless consumed"]
659 #[stable(feature = "rust1", since = "1.0.0")]
661 pub struct Filter<I, P> {
665 impl<I, P> Filter<I, P> {
666 pub(super) fn new(iter: I, predicate: P) -> Filter<I, P> {
667 Filter { iter, predicate }
671 #[stable(feature = "core_impl_debug", since = "1.9.0")]
672 impl<I: fmt::Debug, P> fmt::Debug for Filter<I, P> {
673 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
674 f.debug_struct("Filter")
675 .field("iter", &self.iter)
680 #[stable(feature = "rust1", since = "1.0.0")]
681 impl<I: Iterator, P> Iterator for Filter<I, P> where P: FnMut(&I::Item) -> bool {
685 fn next(&mut self) -> Option<I::Item> {
686 self.try_for_each(Err).err()
690 fn size_hint(&self) -> (usize, Option<usize>) {
691 let (_, upper) = self.iter.size_hint();
692 (0, upper) // can't know a lower bound, due to the predicate
695 // this special case allows the compiler to make `.filter(_).count()`
696 // branchless. Barring perfect branch prediction (which is unattainable in
697 // the general case), this will be much faster in >90% of cases (containing
698 // virtually all real workloads) and only a tiny bit slower in the rest.
700 // Having this specialization thus allows us to write `.filter(p).count()`
701 // where we would otherwise write `.map(|x| p(x) as usize).sum()`, which is
702 // less readable and also less backwards-compatible to Rust before 1.10.
704 // Using the branchless version will also simplify the LLVM byte code, thus
705 // leaving more budget for LLVM optimizations.
707 fn count(self) -> usize {
708 let mut predicate = self.predicate;
709 self.iter.map(|x| predicate(&x) as usize).sum()
713 fn try_fold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where
714 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
716 let predicate = &mut self.predicate;
717 self.iter.try_fold(init, move |acc, item| if predicate(&item) {
725 fn fold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc
726 where Fold: FnMut(Acc, Self::Item) -> Acc,
728 let mut predicate = self.predicate;
729 self.iter.fold(init, move |acc, item| if predicate(&item) {
737 #[stable(feature = "rust1", since = "1.0.0")]
738 impl<I: DoubleEndedIterator, P> DoubleEndedIterator for Filter<I, P>
739 where P: FnMut(&I::Item) -> bool,
742 fn next_back(&mut self) -> Option<I::Item> {
743 self.try_rfold((), |_, x| Err(x)).err()
747 fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where
748 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
750 let predicate = &mut self.predicate;
751 self.iter.try_rfold(init, move |acc, item| if predicate(&item) {
759 fn rfold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc
760 where Fold: FnMut(Acc, Self::Item) -> Acc,
762 let mut predicate = self.predicate;
763 self.iter.rfold(init, move |acc, item| if predicate(&item) {
771 #[stable(feature = "fused", since = "1.26.0")]
772 impl<I: FusedIterator, P> FusedIterator for Filter<I, P>
773 where P: FnMut(&I::Item) -> bool {}
775 /// An iterator that uses `f` to both filter and map elements from `iter`.
777 /// This `struct` is created by the [`filter_map`] method on [`Iterator`]. See its
778 /// documentation for more.
780 /// [`filter_map`]: trait.Iterator.html#method.filter_map
781 /// [`Iterator`]: trait.Iterator.html
782 #[must_use = "iterators are lazy and do nothing unless consumed"]
783 #[stable(feature = "rust1", since = "1.0.0")]
785 pub struct FilterMap<I, F> {
789 impl<I, F> FilterMap<I, F> {
790 pub(super) fn new(iter: I, f: F) -> FilterMap<I, F> {
791 FilterMap { iter, f }
795 #[stable(feature = "core_impl_debug", since = "1.9.0")]
796 impl<I: fmt::Debug, F> fmt::Debug for FilterMap<I, F> {
797 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
798 f.debug_struct("FilterMap")
799 .field("iter", &self.iter)
804 #[stable(feature = "rust1", since = "1.0.0")]
805 impl<B, I: Iterator, F> Iterator for FilterMap<I, F>
806 where F: FnMut(I::Item) -> Option<B>,
811 fn next(&mut self) -> Option<B> {
812 self.try_for_each(Err).err()
816 fn size_hint(&self) -> (usize, Option<usize>) {
817 let (_, upper) = self.iter.size_hint();
818 (0, upper) // can't know a lower bound, due to the predicate
822 fn try_fold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where
823 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
826 self.iter.try_fold(init, move |acc, item| match f(item) {
827 Some(x) => fold(acc, x),
828 None => Try::from_ok(acc),
833 fn fold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc
834 where Fold: FnMut(Acc, Self::Item) -> Acc,
837 self.iter.fold(init, move |acc, item| match f(item) {
838 Some(x) => fold(acc, x),
844 #[stable(feature = "rust1", since = "1.0.0")]
845 impl<B, I: DoubleEndedIterator, F> DoubleEndedIterator for FilterMap<I, F>
846 where F: FnMut(I::Item) -> Option<B>,
849 fn next_back(&mut self) -> Option<B> {
850 self.try_rfold((), |_, x| Err(x)).err()
854 fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where
855 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
858 self.iter.try_rfold(init, move |acc, item| match f(item) {
859 Some(x) => fold(acc, x),
860 None => Try::from_ok(acc),
865 fn rfold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc
866 where Fold: FnMut(Acc, Self::Item) -> Acc,
869 self.iter.rfold(init, move |acc, item| match f(item) {
870 Some(x) => fold(acc, x),
876 #[stable(feature = "fused", since = "1.26.0")]
877 impl<B, I: FusedIterator, F> FusedIterator for FilterMap<I, F>
878 where F: FnMut(I::Item) -> Option<B> {}
880 /// An iterator that yields the current count and the element during iteration.
882 /// This `struct` is created by the [`enumerate`] method on [`Iterator`]. See its
883 /// documentation for more.
885 /// [`enumerate`]: trait.Iterator.html#method.enumerate
886 /// [`Iterator`]: trait.Iterator.html
887 #[derive(Clone, Debug)]
888 #[must_use = "iterators are lazy and do nothing unless consumed"]
889 #[stable(feature = "rust1", since = "1.0.0")]
890 pub struct Enumerate<I> {
894 impl<I> Enumerate<I> {
895 pub(super) fn new(iter: I) -> Enumerate<I> {
896 Enumerate { iter, count: 0 }
900 #[stable(feature = "rust1", since = "1.0.0")]
901 impl<I> Iterator for Enumerate<I> where I: Iterator {
902 type Item = (usize, <I as Iterator>::Item);
904 /// # Overflow Behavior
906 /// The method does no guarding against overflows, so enumerating more than
907 /// `usize::MAX` elements either produces the wrong result or panics. If
908 /// debug assertions are enabled, a panic is guaranteed.
912 /// Might panic if the index of the element overflows a `usize`.
914 #[rustc_inherit_overflow_checks]
915 fn next(&mut self) -> Option<(usize, <I as Iterator>::Item)> {
916 self.iter.next().map(|a| {
917 let ret = (self.count, a);
918 // Possible undefined overflow.
925 fn size_hint(&self) -> (usize, Option<usize>) {
926 self.iter.size_hint()
930 #[rustc_inherit_overflow_checks]
931 fn nth(&mut self, n: usize) -> Option<(usize, I::Item)> {
932 self.iter.nth(n).map(|a| {
933 let i = self.count + n;
940 fn count(self) -> usize {
945 #[rustc_inherit_overflow_checks]
946 fn try_fold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where
947 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
949 let count = &mut self.count;
950 self.iter.try_fold(init, move |acc, item| {
951 let acc = fold(acc, (*count, item));
958 #[rustc_inherit_overflow_checks]
959 fn fold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc
960 where Fold: FnMut(Acc, Self::Item) -> Acc,
962 let mut count = self.count;
963 self.iter.fold(init, move |acc, item| {
964 let acc = fold(acc, (count, item));
971 #[stable(feature = "rust1", since = "1.0.0")]
972 impl<I> DoubleEndedIterator for Enumerate<I> where
973 I: ExactSizeIterator + DoubleEndedIterator
976 fn next_back(&mut self) -> Option<(usize, <I as Iterator>::Item)> {
977 self.iter.next_back().map(|a| {
978 let len = self.iter.len();
979 // Can safely add, `ExactSizeIterator` promises that the number of
980 // elements fits into a `usize`.
981 (self.count + len, a)
986 fn nth_back(&mut self, n: usize) -> Option<(usize, <I as Iterator>::Item)> {
987 self.iter.nth_back(n).map(|a| {
988 let len = self.iter.len();
989 // Can safely add, `ExactSizeIterator` promises that the number of
990 // elements fits into a `usize`.
991 (self.count + len, a)
996 fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where
997 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
999 // Can safely add and subtract the count, as `ExactSizeIterator` promises
1000 // that the number of elements fits into a `usize`.
1001 let mut count = self.count + self.iter.len();
1002 self.iter.try_rfold(init, move |acc, item| {
1004 fold(acc, (count, item))
1009 fn rfold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc
1010 where Fold: FnMut(Acc, Self::Item) -> Acc,
1012 // Can safely add and subtract the count, as `ExactSizeIterator` promises
1013 // that the number of elements fits into a `usize`.
1014 let mut count = self.count + self.iter.len();
1015 self.iter.rfold(init, move |acc, item| {
1017 fold(acc, (count, item))
1022 #[stable(feature = "rust1", since = "1.0.0")]
1023 impl<I> ExactSizeIterator for Enumerate<I> where I: ExactSizeIterator {
1024 fn len(&self) -> usize {
1028 fn is_empty(&self) -> bool {
1029 self.iter.is_empty()
1034 unsafe impl<I> TrustedRandomAccess for Enumerate<I>
1035 where I: TrustedRandomAccess
1037 unsafe fn get_unchecked(&mut self, i: usize) -> (usize, I::Item) {
1038 (self.count + i, self.iter.get_unchecked(i))
1041 fn may_have_side_effect() -> bool {
1042 I::may_have_side_effect()
1046 #[stable(feature = "fused", since = "1.26.0")]
1047 impl<I> FusedIterator for Enumerate<I> where I: FusedIterator {}
1049 #[unstable(feature = "trusted_len", issue = "37572")]
1050 unsafe impl<I> TrustedLen for Enumerate<I>
1051 where I: TrustedLen,
1055 /// An iterator with a `peek()` that returns an optional reference to the next
1058 /// This `struct` is created by the [`peekable`] method on [`Iterator`]. See its
1059 /// documentation for more.
1061 /// [`peekable`]: trait.Iterator.html#method.peekable
1062 /// [`Iterator`]: trait.Iterator.html
1063 #[derive(Clone, Debug)]
1064 #[must_use = "iterators are lazy and do nothing unless consumed"]
1065 #[stable(feature = "rust1", since = "1.0.0")]
1066 pub struct Peekable<I: Iterator> {
1068 /// Remember a peeked value, even if it was None.
1069 peeked: Option<Option<I::Item>>,
1071 impl<I: Iterator> Peekable<I> {
1072 pub(super) fn new(iter: I) -> Peekable<I> {
1073 Peekable { iter, peeked: None }
1077 // Peekable must remember if a None has been seen in the `.peek()` method.
1078 // It ensures that `.peek(); .peek();` or `.peek(); .next();` only advances the
1079 // underlying iterator at most once. This does not by itself make the iterator
1081 #[stable(feature = "rust1", since = "1.0.0")]
1082 impl<I: Iterator> Iterator for Peekable<I> {
1083 type Item = I::Item;
1086 fn next(&mut self) -> Option<I::Item> {
1087 match self.peeked.take() {
1089 None => self.iter.next(),
1094 #[rustc_inherit_overflow_checks]
1095 fn count(mut self) -> usize {
1096 match self.peeked.take() {
1098 Some(Some(_)) => 1 + self.iter.count(),
1099 None => self.iter.count(),
1104 fn nth(&mut self, n: usize) -> Option<I::Item> {
1105 match self.peeked.take() {
1107 Some(v @ Some(_)) if n == 0 => v,
1108 Some(Some(_)) => self.iter.nth(n - 1),
1109 None => self.iter.nth(n),
1114 fn last(mut self) -> Option<I::Item> {
1115 let peek_opt = match self.peeked.take() {
1116 Some(None) => return None,
1120 self.iter.last().or(peek_opt)
1124 fn size_hint(&self) -> (usize, Option<usize>) {
1125 let peek_len = match self.peeked {
1126 Some(None) => return (0, Some(0)),
1130 let (lo, hi) = self.iter.size_hint();
1131 let lo = lo.saturating_add(peek_len);
1132 let hi = hi.and_then(|x| x.checked_add(peek_len));
1137 fn try_fold<B, F, R>(&mut self, init: B, mut f: F) -> R where
1138 Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>
1140 let acc = match self.peeked.take() {
1141 Some(None) => return Try::from_ok(init),
1142 Some(Some(v)) => f(init, v)?,
1145 self.iter.try_fold(acc, f)
1149 fn fold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc
1150 where Fold: FnMut(Acc, Self::Item) -> Acc,
1152 let acc = match self.peeked {
1153 Some(None) => return init,
1154 Some(Some(v)) => fold(init, v),
1157 self.iter.fold(acc, fold)
1161 #[stable(feature = "rust1", since = "1.0.0")]
1162 impl<I: ExactSizeIterator> ExactSizeIterator for Peekable<I> {}
1164 #[stable(feature = "fused", since = "1.26.0")]
1165 impl<I: FusedIterator> FusedIterator for Peekable<I> {}
1167 impl<I: Iterator> Peekable<I> {
1168 /// Returns a reference to the next() value without advancing the iterator.
1170 /// Like [`next`], if there is a value, it is wrapped in a `Some(T)`.
1171 /// But if the iteration is over, `None` is returned.
1173 /// [`next`]: trait.Iterator.html#tymethod.next
1175 /// Because `peek()` returns a reference, and many iterators iterate over
1176 /// references, there can be a possibly confusing situation where the
1177 /// return value is a double reference. You can see this effect in the
1185 /// let xs = [1, 2, 3];
1187 /// let mut iter = xs.iter().peekable();
1189 /// // peek() lets us see into the future
1190 /// assert_eq!(iter.peek(), Some(&&1));
1191 /// assert_eq!(iter.next(), Some(&1));
1193 /// assert_eq!(iter.next(), Some(&2));
1195 /// // The iterator does not advance even if we `peek` multiple times
1196 /// assert_eq!(iter.peek(), Some(&&3));
1197 /// assert_eq!(iter.peek(), Some(&&3));
1199 /// assert_eq!(iter.next(), Some(&3));
1201 /// // After the iterator is finished, so is `peek()`
1202 /// assert_eq!(iter.peek(), None);
1203 /// assert_eq!(iter.next(), None);
1206 #[stable(feature = "rust1", since = "1.0.0")]
1207 pub fn peek(&mut self) -> Option<&I::Item> {
1208 let iter = &mut self.iter;
1209 self.peeked.get_or_insert_with(|| iter.next()).as_ref()
1213 /// An iterator that rejects elements while `predicate` returns `true`.
1215 /// This `struct` is created by the [`skip_while`] method on [`Iterator`]. See its
1216 /// documentation for more.
1218 /// [`skip_while`]: trait.Iterator.html#method.skip_while
1219 /// [`Iterator`]: trait.Iterator.html
1220 #[must_use = "iterators are lazy and do nothing unless consumed"]
1221 #[stable(feature = "rust1", since = "1.0.0")]
1223 pub struct SkipWhile<I, P> {
1228 impl<I, P> SkipWhile<I, P> {
1229 pub(super) fn new(iter: I, predicate: P) -> SkipWhile<I, P> {
1230 SkipWhile { iter, flag: false, predicate }
1234 #[stable(feature = "core_impl_debug", since = "1.9.0")]
1235 impl<I: fmt::Debug, P> fmt::Debug for SkipWhile<I, P> {
1236 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1237 f.debug_struct("SkipWhile")
1238 .field("iter", &self.iter)
1239 .field("flag", &self.flag)
1244 #[stable(feature = "rust1", since = "1.0.0")]
1245 impl<I: Iterator, P> Iterator for SkipWhile<I, P>
1246 where P: FnMut(&I::Item) -> bool
1248 type Item = I::Item;
1251 fn next(&mut self) -> Option<I::Item> {
1252 let flag = &mut self.flag;
1253 let pred = &mut self.predicate;
1254 self.iter.find(move |x| {
1255 if *flag || !pred(x) {
1265 fn size_hint(&self) -> (usize, Option<usize>) {
1266 let (_, upper) = self.iter.size_hint();
1267 (0, upper) // can't know a lower bound, due to the predicate
1271 fn try_fold<Acc, Fold, R>(&mut self, mut init: Acc, mut fold: Fold) -> R where
1272 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
1276 Some(v) => init = fold(init, v)?,
1277 None => return Try::from_ok(init),
1280 self.iter.try_fold(init, fold)
1284 fn fold<Acc, Fold>(mut self, mut init: Acc, mut fold: Fold) -> Acc
1285 where Fold: FnMut(Acc, Self::Item) -> Acc,
1289 Some(v) => init = fold(init, v),
1290 None => return init,
1293 self.iter.fold(init, fold)
1297 #[stable(feature = "fused", since = "1.26.0")]
1298 impl<I, P> FusedIterator for SkipWhile<I, P>
1299 where I: FusedIterator, P: FnMut(&I::Item) -> bool {}
1301 /// An iterator that only accepts elements while `predicate` returns `true`.
1303 /// This `struct` is created by the [`take_while`] method on [`Iterator`]. See its
1304 /// documentation for more.
1306 /// [`take_while`]: trait.Iterator.html#method.take_while
1307 /// [`Iterator`]: trait.Iterator.html
1308 #[must_use = "iterators are lazy and do nothing unless consumed"]
1309 #[stable(feature = "rust1", since = "1.0.0")]
1311 pub struct TakeWhile<I, P> {
1316 impl<I, P> TakeWhile<I, P> {
1317 pub(super) fn new(iter: I, predicate: P) -> TakeWhile<I, P> {
1318 TakeWhile { iter, flag: false, predicate }
1322 #[stable(feature = "core_impl_debug", since = "1.9.0")]
1323 impl<I: fmt::Debug, P> fmt::Debug for TakeWhile<I, P> {
1324 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1325 f.debug_struct("TakeWhile")
1326 .field("iter", &self.iter)
1327 .field("flag", &self.flag)
1332 #[stable(feature = "rust1", since = "1.0.0")]
1333 impl<I: Iterator, P> Iterator for TakeWhile<I, P>
1334 where P: FnMut(&I::Item) -> bool
1336 type Item = I::Item;
1339 fn next(&mut self) -> Option<I::Item> {
1343 self.iter.next().and_then(|x| {
1344 if (self.predicate)(&x) {
1355 fn size_hint(&self) -> (usize, Option<usize>) {
1359 let (_, upper) = self.iter.size_hint();
1360 (0, upper) // can't know a lower bound, due to the predicate
1365 fn try_fold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where
1366 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
1371 let flag = &mut self.flag;
1372 let p = &mut self.predicate;
1373 self.iter.try_fold(init, move |acc, x|{
1375 LoopState::from_try(fold(acc, x))
1378 LoopState::Break(Try::from_ok(acc))
1385 #[stable(feature = "fused", since = "1.26.0")]
1386 impl<I, P> FusedIterator for TakeWhile<I, P>
1387 where I: FusedIterator, P: FnMut(&I::Item) -> bool {}
1389 /// An iterator that skips over `n` elements of `iter`.
1391 /// This `struct` is created by the [`skip`] method on [`Iterator`]. See its
1392 /// documentation for more.
1394 /// [`skip`]: trait.Iterator.html#method.skip
1395 /// [`Iterator`]: trait.Iterator.html
1396 #[derive(Clone, Debug)]
1397 #[must_use = "iterators are lazy and do nothing unless consumed"]
1398 #[stable(feature = "rust1", since = "1.0.0")]
1399 pub struct Skip<I> {
1404 pub(super) fn new(iter: I, n: usize) -> Skip<I> {
1409 #[stable(feature = "rust1", since = "1.0.0")]
1410 impl<I> Iterator for Skip<I> where I: Iterator {
1411 type Item = <I as Iterator>::Item;
1414 fn next(&mut self) -> Option<I::Item> {
1420 self.iter.nth(old_n)
1425 fn nth(&mut self, n: usize) -> Option<I::Item> {
1426 // Can't just add n + self.n due to overflow.
1430 let to_skip = self.n;
1433 if self.iter.nth(to_skip-1).is_none() {
1441 fn count(self) -> usize {
1442 self.iter.count().saturating_sub(self.n)
1446 fn last(mut self) -> Option<I::Item> {
1450 let next = self.next();
1452 // recurse. n should be 0.
1453 self.last().or(next)
1461 fn size_hint(&self) -> (usize, Option<usize>) {
1462 let (lower, upper) = self.iter.size_hint();
1464 let lower = lower.saturating_sub(self.n);
1465 let upper = upper.map(|x| x.saturating_sub(self.n));
1471 fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
1472 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
1478 if self.iter.nth(n - 1).is_none() {
1479 return Try::from_ok(init);
1482 self.iter.try_fold(init, fold)
1486 fn fold<Acc, Fold>(mut self, init: Acc, fold: Fold) -> Acc
1487 where Fold: FnMut(Acc, Self::Item) -> Acc,
1491 if self.iter.nth(self.n - 1).is_none() {
1495 self.iter.fold(init, fold)
1499 #[stable(feature = "rust1", since = "1.0.0")]
1500 impl<I> ExactSizeIterator for Skip<I> where I: ExactSizeIterator {}
1502 #[stable(feature = "double_ended_skip_iterator", since = "1.9.0")]
1503 impl<I> DoubleEndedIterator for Skip<I> where I: DoubleEndedIterator + ExactSizeIterator {
1504 fn next_back(&mut self) -> Option<Self::Item> {
1506 self.iter.next_back()
1513 fn nth_back(&mut self, n: usize) -> Option<I::Item> {
1514 let len = self.len();
1516 self.iter.nth_back(n)
1519 // consume the original iterator
1520 self.iter.nth_back(len-1);
1526 fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where
1527 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
1529 let mut n = self.len();
1533 self.iter.try_rfold(init, move |acc, x| {
1535 let r = fold(acc, x);
1536 if n == 0 { LoopState::Break(r) }
1537 else { LoopState::from_try(r) }
1543 #[stable(feature = "fused", since = "1.26.0")]
1544 impl<I> FusedIterator for Skip<I> where I: FusedIterator {}
1546 /// An iterator that only iterates over the first `n` iterations of `iter`.
1548 /// This `struct` is created by the [`take`] method on [`Iterator`]. See its
1549 /// documentation for more.
1551 /// [`take`]: trait.Iterator.html#method.take
1552 /// [`Iterator`]: trait.Iterator.html
1553 #[derive(Clone, Debug)]
1554 #[must_use = "iterators are lazy and do nothing unless consumed"]
1555 #[stable(feature = "rust1", since = "1.0.0")]
1556 pub struct Take<I> {
1561 pub(super) fn new(iter: I, n: usize) -> Take<I> {
1566 #[stable(feature = "rust1", since = "1.0.0")]
1567 impl<I> Iterator for Take<I> where I: Iterator{
1568 type Item = <I as Iterator>::Item;
1571 fn next(&mut self) -> Option<<I as Iterator>::Item> {
1581 fn nth(&mut self, n: usize) -> Option<I::Item> {
1587 self.iter.nth(self.n - 1);
1595 fn size_hint(&self) -> (usize, Option<usize>) {
1597 return (0, Some(0));
1600 let (lower, upper) = self.iter.size_hint();
1602 let lower = cmp::min(lower, self.n);
1604 let upper = match upper {
1605 Some(x) if x < self.n => Some(x),
1613 fn try_fold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where
1614 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
1619 let n = &mut self.n;
1620 self.iter.try_fold(init, move |acc, x| {
1622 let r = fold(acc, x);
1623 if *n == 0 { LoopState::Break(r) }
1624 else { LoopState::from_try(r) }
1630 #[stable(feature = "rust1", since = "1.0.0")]
1631 impl<I> ExactSizeIterator for Take<I> where I: ExactSizeIterator {}
1633 #[stable(feature = "fused", since = "1.26.0")]
1634 impl<I> FusedIterator for Take<I> where I: FusedIterator {}
1636 #[unstable(feature = "trusted_len", issue = "37572")]
1637 unsafe impl<I: TrustedLen> TrustedLen for Take<I> {}
1639 /// An iterator to maintain state while iterating another iterator.
1641 /// This `struct` is created by the [`scan`] method on [`Iterator`]. See its
1642 /// documentation for more.
1644 /// [`scan`]: trait.Iterator.html#method.scan
1645 /// [`Iterator`]: trait.Iterator.html
1646 #[must_use = "iterators are lazy and do nothing unless consumed"]
1647 #[stable(feature = "rust1", since = "1.0.0")]
1649 pub struct Scan<I, St, F> {
1654 impl<I, St, F> Scan<I, St, F> {
1655 pub(super) fn new(iter: I, state: St, f: F) -> Scan<I, St, F> {
1656 Scan { iter, state, f }
1660 #[stable(feature = "core_impl_debug", since = "1.9.0")]
1661 impl<I: fmt::Debug, St: fmt::Debug, F> fmt::Debug for Scan<I, St, F> {
1662 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1663 f.debug_struct("Scan")
1664 .field("iter", &self.iter)
1665 .field("state", &self.state)
1670 #[stable(feature = "rust1", since = "1.0.0")]
1671 impl<B, I, St, F> Iterator for Scan<I, St, F> where
1673 F: FnMut(&mut St, I::Item) -> Option<B>,
1678 fn next(&mut self) -> Option<B> {
1679 self.iter.next().and_then(|a| (self.f)(&mut self.state, a))
1683 fn size_hint(&self) -> (usize, Option<usize>) {
1684 let (_, upper) = self.iter.size_hint();
1685 (0, upper) // can't know a lower bound, due to the scan function
1689 fn try_fold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where
1690 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
1692 let state = &mut self.state;
1693 let f = &mut self.f;
1694 self.iter.try_fold(init, move |acc, x| {
1696 None => LoopState::Break(Try::from_ok(acc)),
1697 Some(x) => LoopState::from_try(fold(acc, x)),
1703 /// An iterator that yields `None` forever after the underlying iterator
1704 /// yields `None` once.
1706 /// This `struct` is created by the [`fuse`] method on [`Iterator`]. See its
1707 /// documentation for more.
1709 /// [`fuse`]: trait.Iterator.html#method.fuse
1710 /// [`Iterator`]: trait.Iterator.html
1711 #[derive(Clone, Debug)]
1712 #[must_use = "iterators are lazy and do nothing unless consumed"]
1713 #[stable(feature = "rust1", since = "1.0.0")]
1714 pub struct Fuse<I> {
1719 pub(super) fn new(iter: I) -> Fuse<I> {
1720 Fuse { iter, done: false }
1724 #[stable(feature = "fused", since = "1.26.0")]
1725 impl<I> FusedIterator for Fuse<I> where I: Iterator {}
1727 #[stable(feature = "rust1", since = "1.0.0")]
1728 impl<I> Iterator for Fuse<I> where I: Iterator {
1729 type Item = <I as Iterator>::Item;
1732 default fn next(&mut self) -> Option<<I as Iterator>::Item> {
1736 let next = self.iter.next();
1737 self.done = next.is_none();
1743 default fn nth(&mut self, n: usize) -> Option<I::Item> {
1747 let nth = self.iter.nth(n);
1748 self.done = nth.is_none();
1754 default fn last(self) -> Option<I::Item> {
1763 default fn count(self) -> usize {
1772 default fn size_hint(&self) -> (usize, Option<usize>) {
1776 self.iter.size_hint()
1781 default fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
1782 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
1787 let acc = self.iter.try_fold(init, fold)?;
1794 default fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
1795 where Fold: FnMut(Acc, Self::Item) -> Acc,
1800 self.iter.fold(init, fold)
1805 #[stable(feature = "rust1", since = "1.0.0")]
1806 impl<I> DoubleEndedIterator for Fuse<I> where I: DoubleEndedIterator {
1808 default fn next_back(&mut self) -> Option<<I as Iterator>::Item> {
1812 let next = self.iter.next_back();
1813 self.done = next.is_none();
1819 default fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item> {
1823 let nth = self.iter.nth_back(n);
1824 self.done = nth.is_none();
1830 default fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
1831 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
1836 let acc = self.iter.try_rfold(init, fold)?;
1843 default fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
1844 where Fold: FnMut(Acc, Self::Item) -> Acc,
1849 self.iter.rfold(init, fold)
1854 unsafe impl<I> TrustedRandomAccess for Fuse<I>
1855 where I: TrustedRandomAccess,
1857 unsafe fn get_unchecked(&mut self, i: usize) -> I::Item {
1858 self.iter.get_unchecked(i)
1861 fn may_have_side_effect() -> bool {
1862 I::may_have_side_effect()
1866 #[stable(feature = "fused", since = "1.26.0")]
1867 impl<I> Iterator for Fuse<I> where I: FusedIterator {
1869 fn next(&mut self) -> Option<<I as Iterator>::Item> {
1874 fn nth(&mut self, n: usize) -> Option<I::Item> {
1879 fn last(self) -> Option<I::Item> {
1884 fn count(self) -> usize {
1889 fn size_hint(&self) -> (usize, Option<usize>) {
1890 self.iter.size_hint()
1894 fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
1895 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
1897 self.iter.try_fold(init, fold)
1901 fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
1902 where Fold: FnMut(Acc, Self::Item) -> Acc,
1904 self.iter.fold(init, fold)
1908 #[stable(feature = "fused", since = "1.26.0")]
1909 impl<I> DoubleEndedIterator for Fuse<I>
1910 where I: DoubleEndedIterator + FusedIterator
1913 fn next_back(&mut self) -> Option<<I as Iterator>::Item> {
1914 self.iter.next_back()
1918 fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item> {
1919 self.iter.nth_back(n)
1923 fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
1924 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
1926 self.iter.try_rfold(init, fold)
1930 fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
1931 where Fold: FnMut(Acc, Self::Item) -> Acc,
1933 self.iter.rfold(init, fold)
1938 #[stable(feature = "rust1", since = "1.0.0")]
1939 impl<I> ExactSizeIterator for Fuse<I> where I: ExactSizeIterator {
1940 fn len(&self) -> usize {
1944 fn is_empty(&self) -> bool {
1945 self.iter.is_empty()
1949 /// An iterator that calls a function with a reference to each element before
1952 /// This `struct` is created by the [`inspect`] method on [`Iterator`]. See its
1953 /// documentation for more.
1955 /// [`inspect`]: trait.Iterator.html#method.inspect
1956 /// [`Iterator`]: trait.Iterator.html
1957 #[must_use = "iterators are lazy and do nothing unless consumed"]
1958 #[stable(feature = "rust1", since = "1.0.0")]
1960 pub struct Inspect<I, F> {
1964 impl<I, F> Inspect<I, F> {
1965 pub(super) fn new(iter: I, f: F) -> Inspect<I, F> {
1970 #[stable(feature = "core_impl_debug", since = "1.9.0")]
1971 impl<I: fmt::Debug, F> fmt::Debug for Inspect<I, F> {
1972 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1973 f.debug_struct("Inspect")
1974 .field("iter", &self.iter)
1979 impl<I: Iterator, F> Inspect<I, F> where F: FnMut(&I::Item) {
1981 fn do_inspect(&mut self, elt: Option<I::Item>) -> Option<I::Item> {
1982 if let Some(ref a) = elt {
1990 #[stable(feature = "rust1", since = "1.0.0")]
1991 impl<I: Iterator, F> Iterator for Inspect<I, F> where F: FnMut(&I::Item) {
1992 type Item = I::Item;
1995 fn next(&mut self) -> Option<I::Item> {
1996 let next = self.iter.next();
1997 self.do_inspect(next)
2001 fn size_hint(&self) -> (usize, Option<usize>) {
2002 self.iter.size_hint()
2006 fn try_fold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where
2007 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
2009 let f = &mut self.f;
2010 self.iter.try_fold(init, move |acc, item| { f(&item); fold(acc, item) })
2014 fn fold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc
2015 where Fold: FnMut(Acc, Self::Item) -> Acc,
2018 self.iter.fold(init, move |acc, item| { f(&item); fold(acc, item) })
2022 #[stable(feature = "rust1", since = "1.0.0")]
2023 impl<I: DoubleEndedIterator, F> DoubleEndedIterator for Inspect<I, F>
2024 where F: FnMut(&I::Item),
2027 fn next_back(&mut self) -> Option<I::Item> {
2028 let next = self.iter.next_back();
2029 self.do_inspect(next)
2033 fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where
2034 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
2036 let f = &mut self.f;
2037 self.iter.try_rfold(init, move |acc, item| { f(&item); fold(acc, item) })
2041 fn rfold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc
2042 where Fold: FnMut(Acc, Self::Item) -> Acc,
2045 self.iter.rfold(init, move |acc, item| { f(&item); fold(acc, item) })
2049 #[stable(feature = "rust1", since = "1.0.0")]
2050 impl<I: ExactSizeIterator, F> ExactSizeIterator for Inspect<I, F>
2051 where F: FnMut(&I::Item)
2053 fn len(&self) -> usize {
2057 fn is_empty(&self) -> bool {
2058 self.iter.is_empty()
2062 #[stable(feature = "fused", since = "1.26.0")]
2063 impl<I: FusedIterator, F> FusedIterator for Inspect<I, F>
2064 where F: FnMut(&I::Item) {}