feat: simplify works with iter of V not just &V

src/range.rs

@@ -441,30 +441,35 @@ impl<V: Ord + Clone> Range<V> {
     ///  - If none of the versions are contained in the original than the range will be simplified to `empty`.
     ///
     /// If versions are not sorted the correctness of this function is not guaranteed.
-    pub fn simplify<'v, I>(&self, versions: I) -> Self
+    pub fn simplify<'s, I, BV>(&self, versions: I) -> Self
     where
-        I: Iterator<Item = &'v V> + 'v,
-        V: 'v,
+        I: Iterator<Item = BV> + 's,
+        BV: Borrow<V> + 's,
     {
         #[cfg(debug_assertions)]
-        let mut last: Option<&V> = None;
+        let mut last: Option<BV> = None;
         // Return the segment index in the range for each version in the range, None otherwise
         let version_locations = versions.scan(0, move |i, v| {
             #[cfg(debug_assertions)]
             {
-                assert!(
-                    last <= Some(v),
-                    "`simplify` `versions` argument incorrectly sorted"
-                );
-                last = Some(v);
+                if let Some(l) = last.as_ref() {
+                    assert!(
+                        l.borrow() <= v.borrow(),
+                        "`simplify` `versions` argument incorrectly sorted"
+                    );
+                }
             }
             while let Some(segment) = self.segments.get(*i) {
-                match within_bounds(v, segment) {
+                match within_bounds(v.borrow(), segment) {
                     Ordering::Less => return Some(None),
                     Ordering::Equal => return Some(Some(*i)),
                     Ordering::Greater => *i += 1,
                 }
             }
+            #[cfg(debug_assertions)]
+            {
+                last = Some(v);
+            }
             Some(None)
         });
         let kept_segments = group_adjacent_locations(version_locations);
@@ -813,4 +818,20 @@ pub mod tests {
             range.contains_many(versions.into_iter()).count()
         );
     }
+
+    #[test]
+    fn simplify_can_take_owned() {
+        let range: Range<u8> = Range::singleton(1);
+        let versions = vec![1, 2, 3];
+        // Check that iter can be a Cow
+        assert_eq!(
+            range.simplify(versions.iter()),
+            range.simplify(versions.iter().map(std::borrow::Cow::Borrowed))
+        );
+        // Check that iter can be a V
+        assert_eq!(
+            range.simplify(versions.iter()),
+            range.simplify(versions.into_iter())
+        );
+    }
 }