feat(Itertools): add strip_prefix and strip_prefix_by methods

Author: SAY-5

src/lib.rs

@@ -5120,6 +5120,58 @@ pub trait Itertools: Iterator {
             _ => Err(sh),
         }
     }
+
+    /// Removes a prefix from the iterator, returning the rest.
+    ///
+    /// If `self` begins with all the items yielded by `prefix` (in order), this
+    /// returns `Some` of the iterator advanced past that prefix. Otherwise it
+    /// returns `None`. This is the iterator analogue of [`str::strip_prefix`].
+    ///
+    /// See [`strip_prefix_by`](Itertools::strip_prefix_by) for a variant
+    /// taking an explicit equality predicate.
+    ///
+    /// ```
+    /// use itertools::Itertools;
+    ///
+    /// assert_eq!((1..6).strip_prefix([1, 2]).map(Itertools::collect_vec), Some(vec![3, 4, 5]));
+    /// assert_eq!((1..6).strip_prefix([1, 9]).map(Itertools::collect_vec), None);
+    /// assert_eq!((1..6).strip_prefix(std::iter::empty()).map(Itertools::collect_vec), Some(vec![1, 2, 3, 4, 5]));
+    /// ```
+    fn strip_prefix<J>(self, prefix: J) -> Option<Self>
+    where
+        Self: Sized,
+        J: IntoIterator,
+        Self::Item: PartialEq<J::Item>,
+    {
+        self.strip_prefix_by(prefix, |a, b| a == b)
+    }
+
+    /// Removes a prefix from the iterator using `eq` to compare items.
+    ///
+    /// If `self` begins with all the items yielded by `prefix` (in order, as
+    /// judged by `eq`), this returns `Some` of the iterator advanced past that
+    /// prefix. Otherwise it returns `None`. This allows the prefix items to
+    /// have a different type than `Self::Item`.
+    ///
+    /// ```
+    /// use itertools::Itertools;
+    ///
+    /// let path = ["home", "user", "file"];
+    /// let stripped = path.iter().strip_prefix_by(["home", "user"], |a, b| **a == *b);
+    /// assert_eq!(stripped.map(Itertools::collect_vec), Some(vec![&"file"]));
+    /// ```
+    fn strip_prefix_by<J, F>(mut self, prefix: J, mut eq: F) -> Option<Self>
+    where
+        Self: Sized,
+        J: IntoIterator,
+        F: FnMut(&Self::Item, &J::Item) -> bool,
+    {
+        let matched = prefix.into_iter().try_for_each(|wanted| match self.next() {
+            Some(got) if eq(&got, &wanted) => Ok(()),
+            _ => Err(()),
+        });
+        matched.ok().map(|()| self)
+    }
 }
 
 impl<T> Itertools for T where T: Iterator + ?Sized {}

tests/quick.rs

@@ -2098,4 +2098,24 @@ quickcheck! {
         itertools::equal(v.iter().tail(n), result)
             && itertools::equal(v.iter().filter(|_| true).tail(n), result)
     }
+
+    fn strip_prefix_matches_str(haystack: String, needle: String) -> bool {
+        let expected = haystack.strip_prefix(&needle);
+        let got: Option<String> = haystack
+            .chars()
+            .strip_prefix(needle.chars())
+            .map(Iterator::collect);
+        got.as_deref() == expected
+    }
+
+    fn strip_prefix_by_matches_strip_prefix(v: Vec<i32>, n: u8) -> bool {
+        let prefix: Vec<i32> = v.iter().take(n as usize).copied().collect();
+        let by_eq = v.iter().strip_prefix_by(&prefix, |a, b| **a == **b);
+        let plain = v.iter().strip_prefix(prefix.iter());
+        match (by_eq, plain) {
+            (Some(a), Some(b)) => itertools::equal(a, b),
+            (None, None) => true,
+            _ => false,
+        }
+    }
 }