Make iterators generic on Deref to allow for owned versions through Rc

Author: Ten0

src/groupbylazy.rs

@@ -1,4 +1,6 @@
 use std::cell::{Cell, RefCell};
+use std::ops::Deref;
+use std::rc::Rc;
 use alloc::vec::{self, Vec};
 
 /// A trait to unify FnMut for GroupBy with the chunk key in IntoChunks
@@ -334,20 +336,44 @@ impl<K, I, F> GroupBy<K, I, F>
     }
 }
 
+impl<K, I, F> IntoIterator for GroupBy<K, I, F>
+    where I: Iterator,
+          F: FnMut(&I::Item) -> K,
+          K: PartialEq
+{
+    type Item = (K, Group<K, I, F, Rc<Self>>);
+    type IntoIter = Groups<K, I, F, Rc<Self>>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        Groups { parent: Rc::new(self) }
+    }
+}
+
 impl<'a, K, I, F> IntoIterator for &'a GroupBy<K, I, F>
     where I: Iterator,
-          I::Item: 'a,
           F: FnMut(&I::Item) -> K,
           K: PartialEq
 {
-    type Item = (K, Group<'a, K, I, F>);
-    type IntoIter = Groups<'a, K, I, F>;
+    type Item = (K, Group<K, I, F, Self>);
+    type IntoIter = Groups<K, I, F, Self>;
 
     fn into_iter(self) -> Self::IntoIter {
         Groups { parent: self }
     }
 }
 
+impl<K, I, F> GroupBy<K, I, F>
+    where I: Iterator,
+          F: FnMut(&I::Item) -> K,
+          K: PartialEq
+{
+    /// This is pretty much the same as `.into_iter()`, except it uses references
+    /// in the underlying iterators instead of reference counts, resulting in one less
+    /// allocation. You may however hit lifetime errors if you require full ownership.
+    pub fn borrowed_iter<'a>(&'a self) -> <&'a Self as IntoIterator>::IntoIter {
+        self.into_iter()
+    }
+}
 
 /// An iterator that yields the Group iterators.
 ///
@@ -356,20 +382,19 @@ impl<'a, K, I, F> IntoIterator for &'a GroupBy<K, I, F>
 ///
 /// See [`.group_by()`](../trait.Itertools.html#method.group_by) for more information.
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-pub struct Groups<'a, K: 'a, I: 'a, F: 'a>
+pub struct Groups<K, I, F, D: Deref<Target=GroupBy<K, I, F>>>
     where I: Iterator,
-          I::Item: 'a
 {
-    parent: &'a GroupBy<K, I, F>,
+    parent: D,
 }
 
-impl<'a, K, I, F> Iterator for Groups<'a, K, I, F>
+impl<K, I, F, D> Iterator for Groups<K, I, F, D>
     where I: Iterator,
-          I::Item: 'a,
           F: FnMut(&I::Item) -> K,
-          K: PartialEq
+          K: PartialEq,
+          D: Deref<Target=GroupBy<K, I, F>> + Clone,
 {
-    type Item = (K, Group<'a, K, I, F>);
+    type Item = (K, Group<K, I, F, D>);
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
@@ -379,7 +404,7 @@ impl<'a, K, I, F> Iterator for Groups<'a, K, I, F>
         inner.step(index).map(|elt| {
             let key = inner.group_key(index);
             (key, Group {
-                parent: self.parent,
+                parent: self.parent.clone(),
                 index,
                 first: Some(elt),
             })
@@ -390,29 +415,29 @@ impl<'a, K, I, F> Iterator for Groups<'a, K, I, F>
 /// An iterator for the elements in a single group.
 ///
 /// Iterator element type is `I::Item`.
-pub struct Group<'a, K: 'a, I: 'a, F: 'a>
+pub struct Group<K, I, F, D>
     where I: Iterator,
-          I::Item: 'a,
+          D: Deref<Target=GroupBy<K,I,F>>
 {
-    parent: &'a GroupBy<K, I, F>,
+    parent: D,
     index: usize,
     first: Option<I::Item>,
 }
 
-impl<'a, K, I, F> Drop for Group<'a, K, I, F>
+impl<K, I, F, D> Drop for Group<K, I, F, D>
     where I: Iterator,
-          I::Item: 'a,
+          D: Deref<Target=GroupBy<K,I,F>>
 {
     fn drop(&mut self) {
         self.parent.drop_group(self.index);
     }
 }
 
-impl<'a, K, I, F> Iterator for Group<'a, K, I, F>
+impl<K, I, F, D> Iterator for Group<K, I, F, D>
     where I: Iterator,
-          I::Item: 'a,
           F: FnMut(&I::Item) -> K,
           K: PartialEq,
+          D: Deref<Target=GroupBy<K,I,F>>
 {
     type Item = I::Item;
     #[inline]
@@ -486,12 +511,24 @@ impl<I> IntoChunks<I>
     }
 }
 
+impl<I> IntoIterator for IntoChunks<I>
+    where I: Iterator,
+{
+    type Item = Chunk<I, Rc<Self>>;
+    type IntoIter = Chunks<I, Rc<Self>>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        Chunks {
+            parent: Rc::new(self),
+        }
+    }
+}
+
 impl<'a, I> IntoIterator for &'a IntoChunks<I>
     where I: Iterator,
-          I::Item: 'a,
 {
-    type Item = Chunk<'a, I>;
-    type IntoIter = Chunks<'a, I>;
+    type Item = Chunk<I, Self>;
+    type IntoIter = Chunks<I, Self>;
 
     fn into_iter(self) -> Self::IntoIter {
         Chunks {
@@ -500,25 +537,36 @@ impl<'a, I> IntoIterator for &'a IntoChunks<I>
     }
 }
 
+impl<I> IntoChunks<I>
+    where I: Iterator,
+{
+    /// This is pretty much the same as `.into_iter()`, except it uses references
+    /// in the underlying iterators instead of reference counts, resulting in one less
+    /// allocation. You may however hit lifetime errors if you require full ownership.
+    pub fn borrowed_iter<'a>(&'a self) -> <&'a Self as IntoIterator>::IntoIter {
+        self.into_iter()
+    }
+}
+
 
 /// An iterator that yields the Chunk iterators.
 ///
 /// Iterator element type is `Chunk`.
 ///
 /// See [`.chunks()`](../trait.Itertools.html#method.chunks) for more information.
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-pub struct Chunks<'a, I: 'a>
+pub struct Chunks<I, D>
     where I: Iterator,
-          I::Item: 'a,
+          D: Deref<Target=IntoChunks<I>>
 {
-    parent: &'a IntoChunks<I>,
+    parent: D,
 }
 
-impl<'a, I> Iterator for Chunks<'a, I>
+impl<I, D> Iterator for Chunks<I, D>
     where I: Iterator,
-          I::Item: 'a,
+          D: Deref<Target=IntoChunks<I>> + Clone,
 {
-    type Item = Chunk<'a, I>;
+    type Item = Chunk<I, D>;
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
@@ -527,7 +575,7 @@ impl<'a, I> Iterator for Chunks<'a, I>
         let inner = &mut *self.parent.inner.borrow_mut();
         inner.step(index).map(|elt| {
             Chunk {
-                parent: self.parent,
+                parent: self.parent.clone(),
                 index,
                 first: Some(elt),
             }
@@ -538,27 +586,27 @@ impl<'a, I> Iterator for Chunks<'a, I>
 /// An iterator for the elements in a single chunk.
 ///
 /// Iterator element type is `I::Item`.
-pub struct Chunk<'a, I: 'a>
+pub struct Chunk<I, D>
     where I: Iterator,
-          I::Item: 'a,
+          D: Deref<Target=IntoChunks<I>>
 {
-    parent: &'a IntoChunks<I>,
+    parent: D,
     index: usize,
     first: Option<I::Item>,
 }
 
-impl<'a, I> Drop for Chunk<'a, I>
+impl<I, D> Drop for Chunk<I, D>
     where I: Iterator,
-          I::Item: 'a,
+          D: Deref<Target=IntoChunks<I>>
 {
     fn drop(&mut self) {
         self.parent.drop_group(self.index);
     }
 }
 
-impl<'a, I> Iterator for Chunk<'a, I>
+impl<I, D> Iterator for Chunk<I, D>
     where I: Iterator,
-          I::Item: 'a,
+          D: Deref<Target=IntoChunks<I>>
 {
     type Item = I::Item;
     #[inline]

tests/quick.rs

@@ -954,8 +954,8 @@ quickcheck! {
 quickcheck! {
     fn fuzz_group_by_lazy_duo(data: Vec<u8>, order: Vec<(bool, bool)>) -> bool {
         let grouper = data.iter().group_by(|k| *k / 3);
-        let mut groups1 = grouper.into_iter();
-        let mut groups2 = grouper.into_iter();
+        let mut groups1 = grouper.borrowed_iter();
+        let mut groups2 = grouper.borrowed_iter();
         let mut elts = Vec::<&u8>::new();
         let mut old_groups = Vec::new();