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
use crate::fmt; /// Creates a new iterator where each iteration calls the provided closure /// `F: FnMut() -> Option<T>`. /// /// This allows creating a custom iterator with any behavior /// without using the more verbose syntax of creating a dedicated type /// and implementing the [`Iterator`] trait for it. /// /// Note that the `FromFn` iterator doesn’t make assumptions about the behavior of the closure, /// and therefore conservatively does not implement [`FusedIterator`], /// or override [`Iterator::size_hint()`] from its default `(0, None)`. /// /// The closure can use captures and its environment to track state across iterations. Depending on /// how the iterator is used, this may require specifying the [`move`] keyword on the closure. /// /// [`move`]: ../../std/keyword.move.html /// [`FusedIterator`]: crate::iter::FusedIterator /// /// # Examples /// /// Let’s re-implement the counter iterator from [module-level documentation]: /// /// [module-level documentation]: crate::iter /// /// ``` /// let mut count = 0; /// let counter = std::iter::from_fn(move || { /// // Increment our count. This is why we started at zero. /// count += 1; /// /// // Check to see if we've finished counting or not. /// if count < 6 { /// Some(count) /// } else { /// None /// } /// }); /// assert_eq!(counter.collect::<Vec<_>>(), &[1, 2, 3, 4, 5]); /// ``` #[inline] #[stable(feature = "iter_from_fn", since = "1.34.0")] pub fn from_fn<T, F>(f: F) -> FromFn<F> where F: FnMut() -> Option<T>, { FromFn(f) } /// An iterator where each iteration calls the provided closure `F: FnMut() -> Option<T>`. /// /// This `struct` is created by the [`iter::from_fn()`] function. /// See its documentation for more. /// /// [`iter::from_fn()`]: from_fn #[derive(Clone)] #[stable(feature = "iter_from_fn", since = "1.34.0")] pub struct FromFn<F>(F); #[stable(feature = "iter_from_fn", since = "1.34.0")] impl<T, F> Iterator for FromFn<F> where F: FnMut() -> Option<T>, { type Item = T; #[inline] fn next(&mut self) -> Option<Self::Item> { (self.0)() } } #[stable(feature = "iter_from_fn", since = "1.34.0")] impl<F> fmt::Debug for FromFn<F> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("FromFn").finish() } }