Proxy nth in by ref iterators.

When treating a reference to an iterator as an iterator, proxy calls to
nth to the underlying implementation instead of calling the default nth
defined in the trait. This allows us to take advantage of optimized nth
implementations in by-ref iterators.

We can't proxy the other methods due to their sized constraints and the
fact that we can't specialize.

Author: Stebalien

src/libcore/iter.rs

@@ -1127,6 +1127,7 @@ impl<'a, I: Iterator + ?Sized> Iterator for &'a mut I {
     type Item = I::Item;
     fn next(&mut self) -> Option<I::Item> { (**self).next() }
     fn size_hint(&self) -> (usize, Option<usize>) { (**self).size_hint() }
+    fn nth(&mut self, n: usize) -> Option<I::Item> { (**self).nth(n) }
 }
 
 /// Conversion from an `Iterator`

src/libcoretest/iter.rs

@@ -651,6 +651,20 @@ fn test_by_ref() {
     assert_eq!(xs.next(), Some(5));
 }
 
+#[test]
+fn test_by_ref_nth() {
+    let mut xs = 0..10;
+    let mut ys = 0..10;
+    let mut ysr = ys.by_ref();
+    loop {
+        match (xs.nth(2), ysr.nth(2)) {
+            (Some(x), Some(y)) => assert_eq!(x, y),
+            (None, None) => break,
+            _ => panic!("Both iterators should have finished at the same time."),
+        }
+    }
+}
+
 #[test]
 fn test_rev() {
     let xs = [2, 4, 6, 8, 10, 12, 14, 16];