Add Itertools::intersperse_with

Author: gin-ahirsch

src/intersperse.rs

@@ -62,7 +62,7 @@ impl<I> Iterator for Intersperse<I>
         Self: Sized, F: FnMut(B, Self::Item) -> B,
     {
         let mut accum = init;
-        
+
         if let Some(x) = self.peek.take() {
             accum = f(accum, x);
         }
@@ -77,3 +77,81 @@ impl<I> Iterator for Intersperse<I>
         })
     }
 }
+
+/// An iterator adaptor to insert a particular value created by a function
+/// between each element of the adapted iterator.
+///
+/// Iterator element type is `I::Item`
+///
+/// This iterator is *fused*.
+///
+/// See [`.intersperse_with()`](../trait.Itertools.html#method.intersperse_with) for more information.
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug)]
+pub struct IntersperseWith<I, ElemF>
+    where I: Iterator,
+    ElemF: FnMut() -> I::Item,
+{
+    element: ElemF,
+    iter: Fuse<I>,
+    peek: Option<I::Item>,
+}
+
+/// Create a new IntersperseWith iterator
+pub fn intersperse_with<I, ElemF>(iter: I, elt: ElemF) -> IntersperseWith<I, ElemF>
+    where I: Iterator,
+    ElemF: FnMut() -> I::Item
+{
+    let mut iter = iter.fuse();
+    IntersperseWith {
+        peek: iter.next(),
+        iter: iter,
+        element: elt,
+    }
+}
+
+impl<I, ElemF> Iterator for IntersperseWith<I, ElemF>
+    where I: Iterator,
+          ElemF: FnMut() -> I::Item
+{
+    type Item = I::Item;
+    #[inline]
+    fn next(&mut self) -> Option<I::Item> {
+        if self.peek.is_some() {
+            self.peek.take()
+        } else {
+            self.peek = self.iter.next();
+            if self.peek.is_some() {
+                Some((self.element)())
+            } else {
+                None
+            }
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        // 2 * SH + { 1 or 0 }
+        let has_peek = self.peek.is_some() as usize;
+        let sh = self.iter.size_hint();
+        size_hint::add_scalar(size_hint::add(sh, sh), has_peek)
+    }
+
+    fn fold<B, F>(mut self, init: B, mut f: F) -> B where
+        Self: Sized, F: FnMut(B, Self::Item) -> B,
+    {
+        let mut accum = init;
+
+        if let Some(x) = self.peek.take() {
+            accum = f(accum, x);
+        }
+
+        let element = &mut self.element;
+
+        self.iter.fold(accum,
+            |accum, x| {
+                let accum = f(accum, (element)());
+                let accum = f(accum, x);
+                accum
+        })
+    }
+}

src/lib.rs

@@ -109,7 +109,7 @@ pub mod structs {
     pub use format::{Format, FormatWith};
     #[cfg(feature = "use_std")]
     pub use groupbylazy::{IntoChunks, Chunk, Chunks, GroupBy, Group, Groups};
-    pub use intersperse::Intersperse;
+    pub use intersperse::{Intersperse, IntersperseWith};
     #[cfg(feature = "use_std")]
     pub use kmerge_impl::{KMerge, KMergeBy};
     pub use merge_join::MergeJoinBy;
@@ -400,6 +400,26 @@ pub trait Itertools : Iterator {
         intersperse::intersperse(self, element)
     }
 
+    /// An iterator adaptor to insert a particular value created by a function
+    /// between each element of the adapted iterator.
+    ///
+    /// Iterator element type is `Self::Item`.
+    ///
+    /// This iterator is *fused*.
+    ///
+    /// ```
+    /// use itertools::Itertools;
+    ///
+    /// let mut i = 10;
+    /// itertools::assert_equal((0..3).intersperse_with(|| { i -= 1; i }), vec![0, 9, 1, 8, 2]);
+    /// ```
+    fn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F>
+        where Self: Sized,
+        F: FnMut() -> Self::Item
+    {
+        intersperse::intersperse_with(self, element)
+    }
+
     /// Create an iterator which iterates over both this and the specified
     /// iterator simultaneously, yielding pairs of two optional elements.
     ///