Add core::iter::adapters::PeekMap and core::iter::Peekable::peek_map

Author: MiguelX413

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

@@ -18,6 +18,7 @@ mod intersperse;
 mod map;
 mod map_while;
 mod map_windows;
+mod peek_map;
 mod peekable;
 mod rev;
 mod scan;
@@ -31,8 +32,9 @@ mod zip;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::{
     chain::Chain, cycle::Cycle, enumerate::Enumerate, filter::Filter, filter_map::FilterMap,
-    flatten::FlatMap, fuse::Fuse, inspect::Inspect, map::Map, peekable::Peekable, rev::Rev,
-    scan::Scan, skip::Skip, skip_while::SkipWhile, take::Take, take_while::TakeWhile, zip::Zip,
+    flatten::FlatMap, fuse::Fuse, inspect::Inspect, map::Map, peak_map::PeakMap,
+    peekable::Peekable, rev::Rev, scan::Scan, skip::Skip, skip_while::SkipWhile, take::Take,
+    take_while::TakeWhile, zip::Zip,
 };
 
 #[unstable(feature = "iter_array_chunks", reason = "recently added", issue = "100450")]

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

@@ -0,0 +1,106 @@
+use crate::fmt;
+use crate::iter::adapters::{
+    zip::try_get_unchecked, SourceIter, TrustedRandomAccess, TrustedRandomAccessNoCoerce,
+};
+use crate::iter::{
+    FusedIterator, InPlaceIterable, Peekable, TrustedFused, TrustedLen, UncheckedIterator,
+};
+use crate::num::NonZeroUsize;
+use crate::ops::Try;
+
+/// An iterator that maps the values of `iter` with `f`.
+#[must_use = "iterators are lazy and do nothing unless consumed"]
+#[stable(feature = "rust1", since = "1.0.0")]
+pub struct PeekMap<I, F> {
+    // Used for `SplitWhitespace` and `SplitAsciiWhitespace` `as_str` methods
+    pub(crate) peekable: Peakable<I>,
+    f: F,
+}
+
+impl<I, F> PeekMap<I, F> {
+    pub(in crate::iter) fn new(peekable: Peakable<I>, f: F) -> PeekMap<I, F> {
+        PeekMap { peekable, f }
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<B, I: Iterator, F> Iterator for PeekMap<I, F>
+where
+    F: FnMut(I::Item, Option<&I::Item>) -> B,
+{
+    type Item = B;
+
+    #[inline]
+    fn next(&mut self) -> Option<B> {
+        self.peekable.next().map(|f| (f, self.peekable.peek())).map(&mut self.f)
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.peekable.size_hint()
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<B, I: ExactSizeIterator, F> ExactSizeIterator for PeekMap<I, F>
+where
+    F: FnMut(I::Item, Option<&I::Item>) -> B,
+{
+    fn len(&self) -> usize {
+        self.peekable.len()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.peekable.is_empty()
+    }
+}
+
+#[stable(feature = "fused", since = "1.26.0")]
+impl<B, I: FusedIterator, F> FusedIterator for PeekMap<I, F> where
+    F: FnMut(I::Item, Option<&I::Item>) -> B
+{
+}
+
+#[unstable(issue = "none", feature = "trusted_fused")]
+unsafe impl<I: TrustedFused, F> TrustedFused for PeekMap<I, F> {}
+
+#[unstable(feature = "trusted_len", issue = "37572")]
+unsafe impl<B, I, F> TrustedLen for PeekMap<I, F>
+where
+    I: TrustedLen,
+    F: FnMut(I::Item, Option<&I::Item>) -> B,
+{
+}
+
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<I, F> TrustedRandomAccess for PeekMap<I, F> where I: TrustedRandomAccess {}
+
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<I, F> TrustedRandomAccessNoCoerce for PeekMap<I, F>
+where
+    I: TrustedRandomAccessNoCoerce,
+{
+    const MAY_HAVE_SIDE_EFFECT: bool = true;
+}
+
+#[unstable(issue = "none", feature = "inplace_iteration")]
+unsafe impl<I, F> SourceIter for PeekMap<I, F>
+where
+    I: SourceIter,
+{
+    type Source = I::Source;
+
+    #[inline]
+    unsafe fn as_inner(&mut self) -> &mut I::Source {
+        // SAFETY: unsafe function forwarding to unsafe function with the same requirements
+        unsafe { SourceIter::as_inner(&mut self.peekable) }
+    }
+}
+
+#[unstable(issue = "none", feature = "inplace_iteration")]
+unsafe impl<I: InPlaceIterable, F> InPlaceIterable for Map<I, F> {
+    const EXPAND_BY: Option<NonZeroUsize> = I::EXPAND_BY;
+    const MERGE_BY: Option<NonZeroUsize> = I::MERGE_BY;
+}

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

@@ -1,4 +1,4 @@
-use crate::iter::{adapters::SourceIter, FusedIterator, TrustedLen};
+use crate::iter::{adapters::PeekMap, adapters::SourceIter, FusedIterator, TrustedLen};
 use crate::ops::{ControlFlow, Try};
 
 /// An iterator with a `peek()` that returns an optional reference to the next
@@ -316,6 +316,13 @@ impl<I: Iterator> Peekable<I> {
     {
         self.next_if(|next| next == expected)
     }
+
+    pub fn peek_map<F>(self, f: F) -> PeekMap<Self, F>
+    where
+        F: FnMut(I::Item, Option<&I::Item>) -> B,
+    {
+        PeekMap::new(self, f)
+    }
 }
 
 #[unstable(feature = "trusted_len", issue = "37572")]