Write View::into_iter() and Index::iter()

src/index.rs

@@ -1,4 +1,4 @@
-use std::fmt::{Debug};
+use std::{fmt::{Debug}, marker::PhantomData};
 
 use super::{div_mod, Coated, Isomorphic};
 
@@ -66,10 +66,34 @@ pub trait Index: Debug + Copy + PartialEq {
         for i in 0..Self::length(size) { f(Self::from_usize(size, i).1); }
     }
 
+    fn iter(size: Self::Size) -> Iter<Self::Size, Self> {
+        let range_iter = 0..Self::length(size);
+        Iter::<Self::Size, Self> { range_iter, size, index: PhantomData, }
+    }
+
     /// Returns a View of the specified size that maps every `Self` to itself.
     fn all(size: impl Isomorphic<Self::Size>) -> All<Self> { All(size.to_iso()) }
 }
 
+pub struct Iter<S, I> {
+    range_iter: std::ops::Range<usize>,
+    size: S,
+    index: PhantomData<I>,
+}
+impl<S, I> Iterator for Iter<S, I>
+where
+    S: Size,
+    I: Index<Size = S>,
+{
+    type Item = I;
+    fn next(&mut self) -> Option<Self::Item> {
+        let Some(i) = self.range_iter.next() else {
+            return None;
+        };
+        Some(I::from_usize(self.size, i).1)
+    }
+}
+
 // `impl Index for ()` is provided by implementing `StaticIndex`.
 
 impl<I: Index> Index for (I,) {

src/view.rs

@@ -251,6 +251,11 @@ pub trait View: Sized {
         Self::I::each(self.size(), |i| f(self.at(i)));
     }
 
+    fn into_iter(self) -> IntoIter<<<Self as View>::I as Index>::Size, <Self as View>::I, Self> {
+        let index_iter = Self::I::iter(self.size());
+        IntoIter { index_iter, view: self }
+    }
+
     /// Creates a `View` with the same `Index` type as `self` such that `at(i)`
     /// returns `(i, self.at(i))`.
     ///
@@ -661,6 +666,25 @@ impl<V: View, T: Deref<Target=V>> View for T {
     fn at(&self, index: Self::I) -> Self::T { V::at(self, index) }
 }
 
+pub struct IntoIter<S, I, V> {
+    index_iter: crate::index::Iter<S, I>,
+    view: V,
+}
+impl<S, I, V> Iterator for IntoIter<S, I, V>
+where
+    S: crate::Size,
+    I: Index<Size = S>,
+    V: View<I = I>,
+{
+    type Item = V::T;
+    fn next(&mut self) -> Option<Self::Item> {
+        let Some(i) = self.index_iter.next() else {
+            return None;
+        };
+        Some(self.view.at(i))
+    }
+}
+
 // ----------------------------------------------------------------------------
 
 /// A [`View`] that is backed by memory.