library/core/src/iter/adapters/scan.rs

   1 use crate::fmt;
   2 use crate::iter::{adapters::SourceIter, InPlaceIterable};
   3 use crate::ops::{ControlFlow, Try};
   4
   5 /// An iterator to maintain state while iterating another iterator.
   6 ///
   7 /// This `struct` is created by the [`scan`] method on [`Iterator`]. See its
   8 /// documentation for more.
   9 ///
  10 /// [`scan`]: Iterator::scan
  11 /// [`Iterator`]: trait.Iterator.html
  12 #[must_use = "iterators are lazy and do nothing unless consumed"]
  13 #[stable(feature = "rust1", since = "1.0.0")]
  14 #[derive(Clone)]
  15 pub struct Scan<I, St, F> {
  16     iter: I,
  17     f: F,
  18     state: St,
  19 }
  20
  21 impl<I, St, F> Scan<I, St, F> {
  22     pub(in crate::iter) fn new(iter: I, state: St, f: F) -> Scan<I, St, F> {
  23         Scan { iter, state, f }
  24     }
  25 }
  26
  27 #[stable(feature = "core_impl_debug", since = "1.9.0")]
  28 impl<I: fmt::Debug, St: fmt::Debug, F> fmt::Debug for Scan<I, St, F> {
  29     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  30         f.debug_struct("Scan").field("iter", &self.iter).field("state", &self.state).finish()
  31     }
  32 }
  33
  34 #[stable(feature = "rust1", since = "1.0.0")]
  35 impl<B, I, St, F> Iterator for Scan<I, St, F>
  36 where
  37     I: Iterator,
  38     F: FnMut(&mut St, I::Item) -> Option<B>,
  39 {
  40     type Item = B;
  41
  42     #[inline]
  43     fn next(&mut self) -> Option<B> {
  44         let a = self.iter.next()?;
  45         (self.f)(&mut self.state, a)
  46     }
  47
  48     #[inline]
  49     fn size_hint(&self) -> (usize, Option<usize>) {
  50         let (_, upper) = self.iter.size_hint();
  51         (0, upper) // can't know a lower bound, due to the scan function
  52     }
  53
  54     #[inline]
  55     fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
  56     where
  57         Self: Sized,
  58         Fold: FnMut(Acc, Self::Item) -> R,
  59         R: Try<Output = Acc>,
  60     {
  61         fn scan<'a, T, St, B, Acc, R: Try<Output = Acc>>(
  62             state: &'a mut St,
  63             f: &'a mut impl FnMut(&mut St, T) -> Option<B>,
  64             mut fold: impl FnMut(Acc, B) -> R + 'a,
  65         ) -> impl FnMut(Acc, T) -> ControlFlow<R, Acc> + 'a {
  66             move |acc, x| match f(state, x) {
  67                 None => ControlFlow::Break(try { acc }),
  68                 Some(x) => ControlFlow::from_try(fold(acc, x)),
  69             }
  70         }
  71
  72         let state = &mut self.state;
  73         let f = &mut self.f;
  74         self.iter.try_fold(init, scan(state, f, fold)).into_try()
  75     }
  76
  77     #[inline]
  78     fn fold<Acc, Fold>(mut self, init: Acc, fold: Fold) -> Acc
  79     where
  80         Self: Sized,
  81         Fold: FnMut(Acc, Self::Item) -> Acc,
  82     {
  83         #[inline]
  84         fn ok<B, T>(mut f: impl FnMut(B, T) -> B) -> impl FnMut(B, T) -> Result<B, !> {
  85             move |acc, x| Ok(f(acc, x))
  86         }
  87
  88         self.try_fold(init, ok(fold)).unwrap()
  89     }
  90 }
  91
  92 #[unstable(issue = "none", feature = "inplace_iteration")]
  93 unsafe impl<St, F, B, S: Iterator, I: Iterator> SourceIter for Scan<I, St, F>
  94 where
  95     I: SourceIter<Source = S>,
  96     F: FnMut(&mut St, I::Item) -> Option<B>,
  97 {
  98     type Source = S;
  99
 100     #[inline]
 101     unsafe fn as_inner(&mut self) -> &mut S {
 102         // SAFETY: unsafe function forwarding to unsafe function with the same requirements
 103         unsafe { SourceIter::as_inner(&mut self.iter) }
 104     }
 105 }
 106
 107 #[unstable(issue = "none", feature = "inplace_iteration")]
 108 unsafe impl<St, F, B, I: InPlaceIterable> InPlaceIterable for Scan<I, St, F> where
 109     F: FnMut(&mut St, I::Item) -> Option<B>
 110 {
 111 }