ndslice: make iterators owned (#734)

Summary:
Pull Request resolved: #734

Pull Request resolved: #713

References make them needlessly difficult to compose in practice. For example, it is very hard to build an iterator that composes on slice iterators, without creating an explicit intermediate object first.

Reviewed By: shayne-fletcher

Differential Revision: D79400562

fbshipit-source-id: 2cf74bea92039d2d7535d02bdb800daa3899989a

Author: mariusae

hyperactor_mesh/src/mesh.rs

@@ -55,7 +55,7 @@ pub trait Mesh {
 /// An iterator over the nodes of a mesh.
 pub struct MeshIter<'a, M: Mesh + ?Sized> {
     mesh: &'a M,
-    slice_iter: SliceIterator<'a>,
+    slice_iter: SliceIterator,
 }
 
 impl<M: Mesh> Iterator for MeshIter<'_, M> {

ndslice/src/shape.rs

@@ -232,7 +232,7 @@ impl Shape {
 /// `[2, 2, 8]` shape.
 pub struct SelectIterator<'a> {
     shape: &'a Shape,
-    iter: DimSliceIterator<'a>,
+    iter: DimSliceIterator,
 }
 
 impl<'a> Iterator for SelectIterator<'a> {

ndslice/src/slice.rs

@@ -385,15 +385,15 @@ impl Slice {
     /// Iterator over the slice's indices.
     pub fn iter(&self) -> SliceIterator {
         SliceIterator {
-            slice: self,
-            pos: CartesianIterator::new(&self.sizes),
+            slice: self.clone(),
+            pos: CartesianIterator::new(self.sizes.clone()),
         }
     }
 
     /// Iterator over sub-dimensions of the slice.
     pub fn dim_iter(&self, dims: usize) -> DimSliceIterator {
         DimSliceIterator {
-            pos: CartesianIterator::new(&self.sizes[0..dims]),
+            pos: CartesianIterator::new(self.sizes[0..dims].to_vec()),
         }
     }
 
@@ -607,7 +607,7 @@ impl Slice {
 
         // Validate that every address in the new view maps to a valid
         // coordinate in base.
-        for coord in CartesianIterator::new(new_sizes) {
+        for coord in CartesianIterator::new(new_sizes.to_vec()) {
             #[allow(clippy::identity_op)]
             let offset_in_view = 0 + coord
                 .iter()
@@ -662,20 +662,20 @@ impl std::fmt::Display for Slice {
     }
 }
 
-impl<'a> IntoIterator for &'a Slice {
+impl IntoIterator for &Slice {
     type Item = usize;
-    type IntoIter = SliceIterator<'a>;
+    type IntoIter = SliceIterator;
     fn into_iter(self) -> Self::IntoIter {
         self.iter()
     }
 }
 
-pub struct SliceIterator<'a> {
-    pub(crate) slice: &'a Slice,
-    pos: CartesianIterator<'a>,
+pub struct SliceIterator {
+    pub(crate) slice: Slice,
+    pos: CartesianIterator,
 }
 
-impl<'a> Iterator for SliceIterator<'a> {
+impl Iterator for SliceIterator {
     type Item = usize;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -694,11 +694,11 @@ impl<'a> Iterator for SliceIterator<'a> {
 ///
 /// Coordinates are yielded in row-major order (last dimension varies
 /// fastest).
-pub struct DimSliceIterator<'a> {
-    pos: CartesianIterator<'a>,
+pub struct DimSliceIterator {
+    pos: CartesianIterator,
 }
 
-impl<'a> Iterator for DimSliceIterator<'a> {
+impl Iterator for DimSliceIterator {
     type Item = Vec<usize>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -712,25 +712,25 @@ impl<'a> Iterator for DimSliceIterator<'a> {
 /// `dims`, where each coordinate lies in `[0..dims[i])`.
 /// # Example
 /// ```ignore
-/// let iter = CartesianIterator::new(&[2, 3]);
+/// let iter = CartesianIterator::new(vec![2, 3]);
 /// let coords: Vec<_> = iter.collect();
 /// assert_eq!(coords, vec![
 ///     vec![0, 0], vec![0, 1], vec![0, 2],
 ///     vec![1, 0], vec![1, 1], vec![1, 2],
 /// ]);
 /// ```
-pub(crate) struct CartesianIterator<'a> {
-    dims: &'a [usize],
+pub(crate) struct CartesianIterator {
+    dims: Vec<usize>,
     index: usize,
 }
 
-impl<'a> CartesianIterator<'a> {
-    pub(crate) fn new(dims: &'a [usize]) -> Self {
+impl CartesianIterator {
+    pub(crate) fn new(dims: Vec<usize>) -> Self {
         CartesianIterator { dims, index: 0 }
     }
 }
 
-impl<'a> Iterator for CartesianIterator<'a> {
+impl Iterator for CartesianIterator {
     type Item = Vec<usize>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -804,7 +804,7 @@ mod tests {
     #[test]
     fn test_cartesian_iterator() {
         let dims = vec![2, 2, 2];
-        let iter = CartesianIterator::new(&dims);
+        let iter = CartesianIterator::new(dims);
         let products: Vec<Vec<usize>> = iter.collect();
         assert_eq!(
             products,

ndslice/src/view.rs

@@ -176,7 +176,7 @@ impl Extent {
     pub fn iter(&self) -> ExtentIterator {
         ExtentIterator {
             extent: self,
-            pos: CartesianIterator::new(self.sizes()),
+            pos: CartesianIterator::new(self.sizes().to_vec()),
         }
     }
 }
@@ -197,7 +197,7 @@ impl std::fmt::Display for Extent {
 /// An iterator for points in an extent.
 pub struct ExtentIterator<'a> {
     extent: &'a Extent,
-    pos: CartesianIterator<'a>,
+    pos: CartesianIterator,
 }
 
 impl<'a> Iterator for ExtentIterator<'a> {
@@ -412,12 +412,12 @@ impl View {
 }
 
 /// The iterator over views.
-pub struct ViewIterator<'a> {
-    extent: Extent,         // Note that `extent` and...
-    pos: SliceIterator<'a>, // ... `pos` share the same `Slice`.
+pub struct ViewIterator {
+    extent: Extent,     // Note that `extent` and...
+    pos: SliceIterator, // ... `pos` share the same `Slice`.
 }
 
-impl<'a> Iterator for ViewIterator<'a> {
+impl Iterator for ViewIterator {
     type Item = (Point, usize);
 
     fn next(&mut self) -> Option<Self::Item> {