fix exact-size iterator contracts for rows and columns

air/src/proof/table.rs

@@ -136,12 +136,44 @@ impl<'a, E: FieldElement> Iterator for RowIterator<'a, E> {
             },
         }
     }
-}
 
-impl<E: FieldElement> ExactSizeIterator for RowIterator<'_, E> {
-    fn len(&self) -> usize {
-        self.table.num_rows()
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let remaining = self.table.num_rows() - self.cursor;
+        (remaining, Some(remaining))
     }
 }
 
+impl<E: FieldElement> ExactSizeIterator for RowIterator<'_, E> {}
+
 impl<E: FieldElement> FusedIterator for RowIterator<'_, E> {}
+
+#[cfg(test)]
+mod tests {
+    use math::fields::f64::BaseElement;
+    use utils::Serializable;
+
+    use super::Table;
+
+    #[test]
+    fn row_iterator_tracks_remaining_length() {
+        let values = vec![
+            BaseElement::new(1),
+            BaseElement::new(2),
+            BaseElement::new(3),
+            BaseElement::new(4),
+        ];
+        let table: Table<BaseElement> = Table::from_bytes(&values.to_bytes(), 4, 1).unwrap();
+        let mut iter = table.rows();
+
+        assert_eq!(iter.len(), 4);
+        assert_eq!(iter.size_hint(), (4, Some(4)));
+
+        iter.next();
+        assert_eq!(iter.len(), 3);
+        assert_eq!(iter.size_hint(), (3, Some(3)));
+
+        iter.by_ref().for_each(drop);
+        assert_eq!(iter.len(), 0);
+        assert_eq!(iter.size_hint(), (0, Some(0)));
+    }
+}

prover/src/matrix/col_matrix.rs

@@ -331,14 +331,17 @@ impl<'a, E: FieldElement> Iterator for ColumnIter<'a, E> {
             None => None,
         }
     }
-}
 
-impl<E: FieldElement> ExactSizeIterator for ColumnIter<'_, E> {
-    fn len(&self) -> usize {
-        self.matrix.map(|matrix| matrix.num_cols()).unwrap_or_default()
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let remaining =
+            self.matrix.map(|matrix| matrix.num_cols() - self.cursor).unwrap_or_default();
+
+        (remaining, Some(remaining))
     }
 }
 
+impl<E: FieldElement> ExactSizeIterator for ColumnIter<'_, E> {}
+
 impl<E: FieldElement> FusedIterator for ColumnIter<'_, E> {}
 
 impl<E: FieldElement> Default for ColumnIter<'_, E> {
@@ -380,12 +383,13 @@ impl<'a, E: FieldElement> Iterator for ColumnIterMut<'a, E> {
             },
         }
     }
-}
 
-impl<E: FieldElement> ExactSizeIterator for ColumnIterMut<'_, E> {
-    fn len(&self) -> usize {
-        self.matrix.num_cols()
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let remaining = self.matrix.num_cols() - self.cursor;
+        (remaining, Some(remaining))
     }
 }
 
+impl<E: FieldElement> ExactSizeIterator for ColumnIterMut<'_, E> {}
+
 impl<E: FieldElement> FusedIterator for ColumnIterMut<'_, E> {}

prover/src/matrix/tests.rs

@@ -41,6 +41,43 @@ fn test_eval_poly_with_offset_matrix() {
     }
 }
 
+#[test]
+fn column_iterators_track_remaining_length() {
+    let columns = vec![
+        vec![BaseElement::new(1), BaseElement::new(2)],
+        vec![BaseElement::new(3), BaseElement::new(4)],
+        vec![BaseElement::new(5), BaseElement::new(6)],
+        vec![BaseElement::new(7), BaseElement::new(8)],
+    ];
+    let matrix = ColMatrix::new(columns.clone());
+    let mut iter = matrix.columns();
+
+    assert_eq!(iter.len(), 4);
+    assert_eq!(iter.size_hint(), (4, Some(4)));
+
+    iter.next();
+    assert_eq!(iter.len(), 3);
+    assert_eq!(iter.size_hint(), (3, Some(3)));
+
+    iter.by_ref().for_each(drop);
+    assert_eq!(iter.len(), 0);
+    assert_eq!(iter.size_hint(), (0, Some(0)));
+
+    let mut matrix = ColMatrix::new(columns);
+    let mut iter = matrix.columns_mut();
+
+    assert_eq!(iter.len(), 4);
+    assert_eq!(iter.size_hint(), (4, Some(4)));
+
+    iter.next();
+    assert_eq!(iter.len(), 3);
+    assert_eq!(iter.size_hint(), (3, Some(3)));
+
+    iter.by_ref().for_each(drop);
+    assert_eq!(iter.len(), 0);
+    assert_eq!(iter.size_hint(), (0, Some(0)));
+}
+
 // HELPER FUNCTIONS
 // ================================================================================================