feat: add iter_cow_from for List and Vector

src/interface.rs

@@ -110,7 +110,10 @@ where
     }
 
     pub fn iter_cow(&mut self) -> InterfaceIterCow<'_, T, U> {
-        let index = 0;
+        self.iter_cow_from(0)
+    }
+
+    pub fn iter_cow_from(&mut self, index: usize) -> InterfaceIterCow<'_, T, U> {
         InterfaceIterCow {
             tree_iter: self.backing.iter_from(index),
             updates: &mut self.updates,
@@ -199,4 +202,16 @@ mod test {
 
         assert_eq!(list.to_vec(), vec![0, 1, 2]);
     }
+
+    #[test]
+    fn cow_iter_from() {
+        let mut list = List::<u64, U8>::new(vec![1, 2, 3, 4, 5]).unwrap();
+
+        let mut iter = list.iter_cow_from(2).unwrap();
+        while let Some((index, v)) = iter.next_cow() {
+            *v.into_mut().unwrap() = (index * 10) as u64;
+        }
+
+        assert_eq!(list.to_vec(), vec![1, 2, 20, 30, 40]);
+    }
 }

src/list.rs

@@ -152,6 +152,16 @@ impl<T: Value, N: Unsigned, U: UpdateMap<T>> List<T, N, U> {
         self.interface.iter_cow()
     }
 
+    pub fn iter_cow_from(&mut self, index: usize) -> Result<InterfaceIterCow<'_, T, U>, Error> {
+        if index > self.len() {
+            return Err(Error::OutOfBoundsIterFrom {
+                index,
+                len: self.len(),
+            });
+        }
+        Ok(self.interface.iter_cow_from(index))
+    }
+
     // Wrap trait methods so we present a Vec-like interface without having to import anything.
     pub fn get(&self, index: usize) -> Option<&'_ T> {
         self.interface.get(index)

src/tests/proptest/operations.rs

@@ -4,6 +4,7 @@ use proptest::prelude::*;
 use ssz::{Decode, Encode};
 use std::fmt::Debug;
 use std::marker::PhantomData;
+use std::ops::Deref;
 use tree_hash::{Hash256, TreeHash};
 use typenum::{U1, U2, U3, U4, U7, U8, U9, U32, U33, U1024, Unsigned};
 
@@ -109,6 +110,8 @@ pub enum Op<T> {
     Iter,
     /// Check the `iter_from` method.
     IterFrom(usize),
+    /// Check the `iter_cow_from` method.
+    IterCowFrom(usize),
     /// Check the `pop_front` method.
     PopFront(usize),
     /// Apply updates to the backing list.
@@ -144,10 +147,11 @@ where
         strategy.prop_map(Op::Push),
         Just(Op::Iter),
         arb_index(n).prop_map(Op::IterFrom),
+        arb_index(n).prop_map(Op::IterCowFrom),
         arb_index(n).prop_map(Op::PopFront),
-        Just(Op::ApplyUpdates),
     ];
     let b_block = prop_oneof![
+        Just(Op::ApplyUpdates),
         Just(Op::TreeHash),
         Just(Op::Checkpoint),
         Just(Op::Rebase),
@@ -157,7 +161,7 @@ where
     ];
     prop_oneof![
         10 => a_block,
-        6 => b_block
+        7 => b_block
     ]
 }
 
@@ -215,6 +219,22 @@ where
                 (Err(e1), Err(e2)) => assert_eq!(e1, e2),
                 (Err(e), _) | (_, Err(e)) => panic!("iter_from mismatch: {}", e),
             },
+            Op::IterCowFrom(index) => match (list.iter_cow_from(index), spec.iter_from(index)) {
+                (Ok(mut cow_iter), Ok(spec_iter)) => {
+                    let mut cow_values = Vec::new();
+                    while let Some((idx, cow)) = cow_iter.next_cow() {
+                        assert_eq!(
+                            idx,
+                            index + cow_values.len(),
+                            "index mismatch in iter_cow_from"
+                        );
+                        cow_values.push(cow.deref().clone());
+                    }
+                    assert!(cow_values.iter().eq(spec_iter));
+                }
+                (Err(e1), Err(e2)) => assert_eq!(e1, e2),
+                (Err(e), _) | (_, Err(e)) => panic!("iter_cow_from mismatch: {}", e),
+            },
             Op::PopFront(index) => match (list.pop_front(index), spec.pop_front(index)) {
                 (Ok(()), Ok(())) => {
                     assert_eq!(list.len(), spec.len());
@@ -311,6 +331,22 @@ where
                 (Err(e1), Err(e2)) => assert_eq!(e1, e2),
                 (Err(e), _) | (_, Err(e)) => panic!("iter_from mismatch: {}", e),
             },
+            Op::IterCowFrom(index) => match (vect.iter_cow_from(index), spec.iter_from(index)) {
+                (Ok(mut cow_iter), Ok(spec_iter)) => {
+                    let mut cow_values = Vec::new();
+                    while let Some((idx, cow)) = cow_iter.next_cow() {
+                        assert_eq!(
+                            idx,
+                            index + cow_values.len(),
+                            "index mismatch in iter_cow_from"
+                        );
+                        cow_values.push(cow.deref().clone());
+                    }
+                    assert!(cow_values.iter().eq(spec_iter));
+                }
+                (Err(e1), Err(e2)) => assert_eq!(e1, e2),
+                (Err(e), _) | (_, Err(e)) => panic!("iter_cow_from mismatch: {}", e),
+            },
             Op::PopFront(_) => {
                 // No-op
             }

src/vector.rs

@@ -1,5 +1,5 @@
 use crate::interface::{ImmList, Interface, MutList};
-use crate::interface_iter::InterfaceIter;
+use crate::interface_iter::{InterfaceIter, InterfaceIterCow};
 use crate::iter::Iter;
 use crate::level_iter::LevelIter;
 use crate::tree::{IntraRebaseAction, RebaseAction};
@@ -88,6 +88,20 @@ impl<T: Value, N: Unsigned, U: UpdateMap<T>> Vector<T, N, U> {
         Ok(self.interface.iter_from(index))
     }
 
+    pub fn iter_cow(&mut self) -> InterfaceIterCow<'_, T, U> {
+        self.interface.iter_cow()
+    }
+
+    pub fn iter_cow_from(&mut self, index: usize) -> Result<InterfaceIterCow<'_, T, U>, Error> {
+        if index > self.len() {
+            return Err(Error::OutOfBoundsIterFrom {
+                index,
+                len: self.len(),
+            });
+        }
+        Ok(self.interface.iter_cow_from(index))
+    }
+
     // Wrap trait methods so we present a Vec-like interface without having to import anything.
     pub fn get(&self, index: usize) -> Option<&'_ T> {
         self.interface.get(index)