Make Intersperse[With] lazy

src/intersperse.rs

@@ -54,18 +54,20 @@ where
 {
  element: ElemF,
  iter: Fuse<I>,
- peek: Option<I::Item>,
+ /// `peek` is None while no item have been taken out of `iter` (at definition).
+ /// Then `peek` will alternatively be `Some(None)` and `Some(Some(item))`,
+ /// where `None` indicates it's time to generate from `element` (unless `iter` is empty).
+ peek: Option<Option<I::Item>>,
 }
 
 /// Create a new `IntersperseWith` iterator
 pub fn intersperse_with<I, ElemF>(iter: I, elt: ElemF) -> IntersperseWith<I, ElemF>
 where
  I: Iterator,
 {
- let mut iter = iter.fuse();
  IntersperseWith {
- peek: iter.next(),
- iter,
+ peek: None,
+ iter: iter.fuse(),
  element: elt,
  }
 }
@@ -78,39 +80,54 @@ where
  type Item = I::Item;
  #[inline]
  fn next(&mut self) -> Option<Self::Item> {
- if self.peek.is_some() {
- self.peek.take()
- } else {
- self.peek = self.iter.next();
- if self.peek.is_some() {
- Some(self.element.generate())
- } else {
- None
+ let Self {
+ element,
+ iter,
+ peek,
+ } = self;
+ match peek {
+ Some(item @ Some(_)) => item.take(),
+ Some(None) => match iter.next() {
+ new @ Some(_) => {
+ *peek = Some(new);
+ Some(element.generate())
+ }
+ None => None,
+ },
+ None => {
+ *peek = Some(None);
+ iter.next()
  }
  }
  }
 
  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)
+ let mut sh = self.iter.size_hint();
+ sh = size_hint::add(sh, sh);
+ match self.peek {
+ Some(Some(_)) => size_hint::add_scalar(sh, 1),
+ Some(None) => sh,
+ None => size_hint::sub_scalar(sh, 1),
+ }
  }
 
- fn fold<B, F>(mut self, init: B, mut f: F) -> B
+ fn fold<B, F>(self, init: B, mut f: F) -> B
  where
  Self: Sized,
  F: FnMut(B, Self::Item) -> B,
  {
+ let Self {
+ mut element,
+ mut iter,
+ peek,
+ } = self;
  let mut accum = init;
 
- if let Some(x) = self.peek.take() {
+ if let Some(x) = peek.unwrap_or_else(|| iter.next()) {
  accum = f(accum, x);
  }
 
- let element = &mut self.element;
-
- self.iter.fold(accum, |accum, x| {
+ iter.fold(accum, |accum, x| {
  let accum = f(accum, element.generate());
  f(accum, x)
  })