Inline CoalesceCore into Coalesce (1)

Author: phimuemue

src/adaptors/mod.rs

@@ -605,27 +605,18 @@ impl<I, J, F> Iterator for MergeBy<I, J, F>
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct CoalesceCore<I, T>
-    where I: Iterator
-{
-    iter: I,
-    last: Option<T>,
-}
-
-impl<I, T> CoalesceCore<I, T>
-    where I: Iterator
+impl<I, F, T> Coalesce<I, F, T>
+    where I: Iterator,
+        F: CoalescePredicate<I::Item, T>,
 {
-    fn next_with<F>(&mut self, mut f: F) -> Option<T>
-        where F: FnMut(T, I::Item) -> Result<T, (T, T)>
-    {
+    fn next_with(&mut self) -> Option<T> {
         // this fuses the iterator
         let mut last = match self.last.take() {
             None => return None,
             Some(x) => x,
         };
         for next in &mut self.iter {
-            match f(last, next) {
+            match self.f.coalesce_pair(last, next) {
                 Ok(joined) => last = joined,
                 Err((last_, next_)) => {
                     self.last = Some(next_);
@@ -637,11 +628,6 @@ impl<I, T> CoalesceCore<I, T>
         Some(last)
     }
 
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let (low, hi) = size_hint::add_scalar(self.iter.size_hint(),
-                                              self.last.is_some() as usize);
-        ((low > 0) as usize, hi)
-    }
 }
 
 /// An iterator adaptor that may join together adjacent elements.
@@ -651,7 +637,8 @@ impl<I, T> CoalesceCore<I, T>
 pub struct Coalesce<I, F, T>
     where I: Iterator
 {
-    iter: CoalesceCore<I, T>,
+    iter: I,
+    last: Option<T>,
     f: F,
 }
 
@@ -670,25 +657,23 @@ impl<F, Item, T> CoalescePredicate<Item, T> for F
 impl<I: Clone, F: Clone, T: Clone> Clone for Coalesce<I, F, T>
     where I: Iterator,
 {
-    clone_fields!(iter, f);
+    clone_fields!(iter, last, f);
 }
 
 impl<I, F, T> fmt::Debug for Coalesce<I, F, T>
     where I: Iterator + fmt::Debug,
           T: fmt::Debug,
 {
-    debug_fmt_fields!(Coalesce, iter);
+    debug_fmt_fields!(Coalesce, iter, last);
 }
 
 /// Create a new `Coalesce`.
 pub fn coalesce<I, F>(mut iter: I, f: F) -> Coalesce<I, F, I::Item>
     where I: Iterator
 {
     Coalesce {
-        iter: CoalesceCore {
-            last: iter.next(),
-            iter,
-        },
+        last: iter.next(),
+        iter,
         f,
     }
 }
@@ -700,20 +685,21 @@ impl<I, F, T> Iterator for Coalesce<I, F, T>
     type Item = T;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let f = &mut self.f;
-        self.iter.next_with(|last, item| f.coalesce_pair(last, item))
+        self.next_with()
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
+        let (low, hi) = size_hint::add_scalar(self.iter.size_hint(),
+                                              self.last.is_some() as usize);
+        ((low > 0) as usize, hi)
     }
 
     fn fold<Acc, FnAcc>(self, acc: Acc, mut fn_acc: FnAcc) -> Acc
         where FnAcc: FnMut(Acc, Self::Item) -> Acc,
     {
-        if let Some(last) = self.iter.last {
+        if let Some(last) = self.last {
             let mut f = self.f;
-            let (last, acc) = self.iter.iter.fold((last, acc), |(last, acc), elt| {
+            let (last, acc) = self.iter.fold((last, acc), |(last, acc), elt| {
                 match f.coalesce_pair(last, elt) {
                     Ok(joined) => (joined, acc),
                     Err((last_, next_)) => (next_, fn_acc(acc, last_)),
@@ -776,10 +762,8 @@ pub fn dedup_by<I, Pred>(mut iter: I, dedup_pred: Pred) -> DedupBy<I, Pred>
     where I: Iterator,
 {
     Coalesce {
-        iter: CoalesceCore {
-            last: iter.next(),
-            iter,
-        },
+        last: iter.next(),
+        iter,
         f: DedupPred2CoalescePred(dedup_pred),
     }
 }