Eliminate redundant CombinationsWithReplacement::max_index

Can be inferred from `pool`:

* For `self.indices.len()==0`, the first iteration yields `Some(self.current())`, and afterwards we just go through, unnecessarily call `self.pool.get_next()`, `increment` stays `None` as the loop is not iterated, and we return `None`.
* For `self.indices.len()>0`:
  * If `pool` is empty from the start, `pool.get_next` is always `false` and we will always return `None` (without even setting `first=false`).
  * Otherwise (i.e. if `pool` is non-empty), we return `Some(self.current())` on first it eration, and afterwards always call `pool.get_next`, possibly updating `self.max_index`.
  In the first iteration `max_index` is 0, thus equals `pool.len()-1` when we return `Some(self.current())`.
  Thus, we know that `self.max_index` is equal to `self.pool.len()-1` when we come to the line `let mut increment...`.

Author: phimuemue

src/combinations_with_replacement.rs

@@ -13,8 +13,6 @@ where
     I::Item: Clone,
 {
     indices: Vec<usize>,
-    // The current known max index value. This increases as pool grows.
-    max_index: usize,
     pool: LazyBuffer<I>,
     first: bool,
 }
@@ -24,7 +22,7 @@ where
     I: Iterator + fmt::Debug,
     I::Item: fmt::Debug + Clone,
 {
-    debug_fmt_fields!(Combinations, indices, max_index, pool, first);
+    debug_fmt_fields!(Combinations, indices, pool, first);
 }
 
 impl<I> CombinationsWithReplacement<I>
@@ -49,7 +47,6 @@ where
 
     CombinationsWithReplacement {
         indices,
-        max_index: 0,
         pool,
         first: true,
     }
@@ -76,14 +73,12 @@ where
 
         // Check if we need to consume more from the iterator
         // This will run while we increment our first index digit
-        if self.pool.get_next() {
-            self.max_index = self.pool.len() - 1;
-        }
+        self.pool.get_next();
 
         // Work out where we need to update our indices
         let mut increment: Option<(usize, usize)> = None;
         for (i, indices_int) in self.indices.iter().enumerate().rev() {
-            if indices_int < &self.max_index {
+            if *indices_int < self.pool.len()-1 {
                 increment = Some((i, indices_int + 1));
                 break;
             }