Add cycle

src/lib.rs

@@ -720,6 +720,18 @@ pub trait FallibleIterator {
         Cloned(self)
     }
 
+    /// Returns an iterator which repeas this iterator endlessly.
+    #[inline]
+    fn cycle(self) -> Cycle<Self>
+    where
+        Self: Sized + Clone,
+    {
+        Cycle {
+            it: self.clone(),
+            cur: self,
+        }
+    }
+
     /// Lexicographically compares the elements of this iterator to that of
     /// another.
     #[inline]
@@ -2064,6 +2076,37 @@ where
     }
 }
 
+/// An iterator which cycles another endlessly.
+#[derive(Clone, Debug)]
+pub struct Cycle<I> {
+    it: I,
+    cur: I,
+}
+
+impl<I> FallibleIterator for Cycle<I>
+where
+    I: FallibleIterator + Clone,
+{
+    type Item = I::Item;
+    type Error = I::Error;
+
+    #[inline]
+    fn next(&mut self) -> Result<Option<I::Item>, I::Error> {
+        match self.cur.next()? {
+            None => {
+                self.cur = self.it.clone();
+                self.cur.next()
+            }
+            Some(v) => Ok(Some(v)),
+        }
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (usize::max_value(), None)
+    }
+}
+
 /// An iterator that yields pairs of this iterator's and another iterator's
 /// values.
 #[derive(Clone, Debug)]

src/test.rs

@@ -438,8 +438,18 @@ fn find_map() {
 
 #[test]
 fn unzip() {
-    let it = convert(vec![(0, 0), (1, -1), (2, -2), (3, -3)].into_iter().map(Ok::<_, ()>));
+    let it = convert(
+        vec![(0, 0), (1, -1), (2, -2), (3, -3)]
+            .into_iter()
+            .map(Ok::<_, ()>),
+    );
     let (pos, neg): (Vec<i32>, Vec<i32>) = it.unzip().unwrap();
     assert_eq!(pos, vec![0, 1, 2, 3]);
     assert_eq!(neg, vec![0, -1, -2, -3]);
 }
+
+#[test]
+fn cycle() {
+    let it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<i32, ()>)).cycle();
+    assert_eq!(it.take(6).clone().collect::<Vec<_>>(), Ok(vec![0, 1, 2, 3, 0, 1]));
+}