Added benchmark for 'BitVec::skip(n)' to ensure the new 'nth' is used

benches/bench.rs

···
         black_box(&mut sieve);
     });
 }
+
+#[bench]
+fn bench_iter_skip(b: &mut test::Bencher) {
+    let start = 3 << 20;
+    let p = 16411;
+    let g = 9749; // 9749 is a primitive root modulo 16411, so we can generate numbers mod p in a seemingly random order
+    let end = start + p;
+    let mut tbl = BitVec::from_elem(end, false);
+    let mut r = g;
+    for i in start..end {
+        tbl.set(i, r&1 != 0);
+        r = r*g%p;
+    }
+    b.iter(|| {
+        black_box(&mut tbl);
+        // start is large relative to end-start, so before Iterator::nth was implemented for bitvec this would
+        // have been much slower
+        black_box(tbl.iter().skip(start).filter(|&v|v).count());
+    });
+}

src/lib.rs

···
     }
 
     fn nth(&mut self, n: usize) -> Option<Self::Item> {
+        // This override is used by the compiler to optimize Iterator::skip.
+        // Without this, the default implementation of Iterator::nth is used, which walks over
+        // the whole iterator up to n.
         self.range.nth(n).and_then(|i|self.bit_vec.get(i))
     }