code_ownership 2.0.0.pre.1 → 2.0.0.pre.3

data/ext/cargo-vendor/rayon-1.10.0/src/str.rs

@@ -1,1010 +0,0 @@
-//! Parallel iterator types for [strings][std::str]
-//!
-//! You will rarely need to interact with this module directly unless you need
-//! to name one of the iterator types.
-//!
-//! Note: [`ParallelString::par_split()`] and [`par_split_terminator()`]
-//! reference a `Pattern` trait which is not visible outside this crate.
-//! This trait is intentionally kept private, for use only by Rayon itself.
-//! It is implemented for `char`, `&[char]`, `[char; N]`, `&[char; N]`,
-//! and any function or closure `F: Fn(char) -> bool + Sync + Send`.
-//!
-//! [`ParallelString::par_split()`]: trait.ParallelString.html#method.par_split
-//! [`par_split_terminator()`]: trait.ParallelString.html#method.par_split_terminator
-//!
-//! [std::str]: https://doc.rust-lang.org/stable/std/str/
-
-use crate::iter::plumbing::*;
-use crate::iter::*;
-use crate::split_producer::*;
-
-/// Test if a byte is the start of a UTF-8 character.
-/// (extracted from `str::is_char_boundary`)
-#[inline]
-fn is_char_boundary(b: u8) -> bool {
-    // This is bit magic equivalent to: b < 128 || b >= 192
-    (b as i8) >= -0x40
-}
-
-/// Find the index of a character boundary near the midpoint.
-#[inline]
-fn find_char_midpoint(chars: &str) -> usize {
-    let mid = chars.len() / 2;
-
-    // We want to split near the midpoint, but we need to find an actual
-    // character boundary.  So we look at the raw bytes, first scanning
-    // forward from the midpoint for a boundary, then trying backward.
-    let (left, right) = chars.as_bytes().split_at(mid);
-    match right.iter().copied().position(is_char_boundary) {
-        Some(i) => mid + i,
-        None => left
-            .iter()
-            .copied()
-            .rposition(is_char_boundary)
-            .unwrap_or(0),
-    }
-}
-
-/// Try to split a string near the midpoint.
-#[inline]
-fn split(chars: &str) -> Option<(&str, &str)> {
-    let index = find_char_midpoint(chars);
-    if index > 0 {
-        Some(chars.split_at(index))
-    } else {
-        None
-    }
-}
-
-/// Parallel extensions for strings.
-pub trait ParallelString {
-    /// Returns a plain string slice, which is used to implement the rest of
-    /// the parallel methods.
-    fn as_parallel_string(&self) -> &str;
-
-    /// Returns a parallel iterator over the characters of a string.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rayon::prelude::*;
-    /// let max = "hello".par_chars().max_by_key(|c| *c as i32);
-    /// assert_eq!(Some('o'), max);
-    /// ```
-    fn par_chars(&self) -> Chars<'_> {
-        Chars {
-            chars: self.as_parallel_string(),
-        }
-    }
-
-    /// Returns a parallel iterator over the characters of a string, with their positions.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rayon::prelude::*;
-    /// let min = "hello".par_char_indices().min_by_key(|&(_i, c)| c as i32);
-    /// assert_eq!(Some((1, 'e')), min);
-    /// ```
-    fn par_char_indices(&self) -> CharIndices<'_> {
-        CharIndices {
-            chars: self.as_parallel_string(),
-        }
-    }
-
-    /// Returns a parallel iterator over the bytes of a string.
-    ///
-    /// Note that multi-byte sequences (for code points greater than `U+007F`)
-    /// are produced as separate items, but will not be split across threads.
-    /// If you would prefer an indexed iterator without that guarantee, consider
-    /// `string.as_bytes().par_iter().copied()` instead.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rayon::prelude::*;
-    /// let max = "hello".par_bytes().max();
-    /// assert_eq!(Some(b'o'), max);
-    /// ```
-    fn par_bytes(&self) -> Bytes<'_> {
-        Bytes {
-            chars: self.as_parallel_string(),
-        }
-    }
-
-    /// Returns a parallel iterator over a string encoded as UTF-16.
-    ///
-    /// Note that surrogate pairs (for code points greater than `U+FFFF`) are
-    /// produced as separate items, but will not be split across threads.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rayon::prelude::*;
-    ///
-    /// let max = "hello".par_encode_utf16().max();
-    /// assert_eq!(Some(b'o' as u16), max);
-    ///
-    /// let text = "Zażółć gęślą jaźń";
-    /// let utf8_len = text.len();
-    /// let utf16_len = text.par_encode_utf16().count();
-    /// assert!(utf16_len <= utf8_len);
-    /// ```
-    fn par_encode_utf16(&self) -> EncodeUtf16<'_> {
-        EncodeUtf16 {
-            chars: self.as_parallel_string(),
-        }
-    }
-
-    /// Returns a parallel iterator over substrings separated by a
-    /// given character or predicate, similar to `str::split`.
-    ///
-    /// Note: the `Pattern` trait is private, for use only by Rayon itself.
-    /// It is implemented for `char`, `&[char]`, `[char; N]`, `&[char; N]`,
-    /// and any function or closure `F: Fn(char) -> bool + Sync + Send`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rayon::prelude::*;
-    /// let total = "1, 2, buckle, 3, 4, door"
-    ///    .par_split(',')
-    ///    .filter_map(|s| s.trim().parse::<i32>().ok())
-    ///    .sum();
-    /// assert_eq!(10, total);
-    /// ```
-    fn par_split<P: Pattern>(&self, separator: P) -> Split<'_, P> {
-        Split::new(self.as_parallel_string(), separator)
-    }
-
-    /// Returns a parallel iterator over substrings separated by a
-    /// given character or predicate, keeping the matched part as a terminator
-    /// of the substring similar to `str::split_inclusive`.
-    ///
-    /// Note: the `Pattern` trait is private, for use only by Rayon itself.
-    /// It is implemented for `char`, `&[char]`, `[char; N]`, `&[char; N]`,
-    /// and any function or closure `F: Fn(char) -> bool + Sync + Send`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rayon::prelude::*;
-    /// let lines: Vec<_> = "Mary had a little lamb\nlittle lamb\nlittle lamb."
-    ///    .par_split_inclusive('\n')
-    ///    .collect();
-    /// assert_eq!(lines, ["Mary had a little lamb\n", "little lamb\n", "little lamb."]);
-    /// ```
-    fn par_split_inclusive<P: Pattern>(&self, separator: P) -> SplitInclusive<'_, P> {
-        SplitInclusive::new(self.as_parallel_string(), separator)
-    }
-
-    /// Returns a parallel iterator over substrings terminated by a
-    /// given character or predicate, similar to `str::split_terminator`.
-    /// It's equivalent to `par_split`, except it doesn't produce an empty
-    /// substring after a trailing terminator.
-    ///
-    /// Note: the `Pattern` trait is private, for use only by Rayon itself.
-    /// It is implemented for `char`, `&[char]`, `[char; N]`, `&[char; N]`,
-    /// and any function or closure `F: Fn(char) -> bool + Sync + Send`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rayon::prelude::*;
-    /// let parts: Vec<_> = "((1 + 3) * 2)"
-    ///     .par_split_terminator(|c| c == '(' || c == ')')
-    ///     .collect();
-    /// assert_eq!(vec!["", "", "1 + 3", " * 2"], parts);
-    /// ```
-    fn par_split_terminator<P: Pattern>(&self, terminator: P) -> SplitTerminator<'_, P> {
-        SplitTerminator::new(self.as_parallel_string(), terminator)
-    }
-
-    /// Returns a parallel iterator over the lines of a string, ending with an
-    /// optional carriage return and with a newline (`\r\n` or just `\n`).
-    /// The final line ending is optional, and line endings are not included in
-    /// the output strings.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rayon::prelude::*;
-    /// let lengths: Vec<_> = "hello world\nfizbuzz"
-    ///     .par_lines()
-    ///     .map(|l| l.len())
-    ///     .collect();
-    /// assert_eq!(vec![11, 7], lengths);
-    /// ```
-    fn par_lines(&self) -> Lines<'_> {
-        Lines(self.as_parallel_string())
-    }
-
-    /// Returns a parallel iterator over the sub-slices of a string that are
-    /// separated by any amount of whitespace.
-    ///
-    /// As with `str::split_whitespace`, 'whitespace' is defined according to
-    /// the terms of the Unicode Derived Core Property `White_Space`.
-    /// If you only want to split on ASCII whitespace instead, use
-    /// [`par_split_ascii_whitespace`][`ParallelString::par_split_ascii_whitespace`].
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rayon::prelude::*;
-    /// let longest = "which is the longest word?"
-    ///     .par_split_whitespace()
-    ///     .max_by_key(|word| word.len());
-    /// assert_eq!(Some("longest"), longest);
-    /// ```
-    ///
-    /// All kinds of whitespace are considered:
-    ///
-    /// ```
-    /// use rayon::prelude::*;
-    /// let words: Vec<&str> = " Mary   had\ta\u{2009}little  \n\t lamb"
-    ///     .par_split_whitespace()
-    ///     .collect();
-    /// assert_eq!(words, ["Mary", "had", "a", "little", "lamb"]);
-    /// ```
-    ///
-    /// If the string is empty or all whitespace, the iterator yields no string slices:
-    ///
-    /// ```
-    /// use rayon::prelude::*;
-    /// assert_eq!("".par_split_whitespace().count(), 0);
-    /// assert_eq!("   ".par_split_whitespace().count(), 0);
-    /// ```
-    fn par_split_whitespace(&self) -> SplitWhitespace<'_> {
-        SplitWhitespace(self.as_parallel_string())
-    }
-
-    /// Returns a parallel iterator over the sub-slices of a string that are
-    /// separated by any amount of ASCII whitespace.
-    ///
-    /// To split by Unicode `White_Space` instead, use
-    /// [`par_split_whitespace`][`ParallelString::par_split_whitespace`].
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rayon::prelude::*;
-    /// let longest = "which is the longest word?"
-    ///     .par_split_ascii_whitespace()
-    ///     .max_by_key(|word| word.len());
-    /// assert_eq!(Some("longest"), longest);
-    /// ```
-    ///
-    /// All kinds of ASCII whitespace are considered, but not Unicode `White_Space`:
-    ///
-    /// ```
-    /// use rayon::prelude::*;
-    /// let words: Vec<&str> = " Mary   had\ta\u{2009}little  \n\t lamb"
-    ///     .par_split_ascii_whitespace()
-    ///     .collect();
-    /// assert_eq!(words, ["Mary", "had", "a\u{2009}little", "lamb"]);
-    /// ```
-    ///
-    /// If the string is empty or all ASCII whitespace, the iterator yields no string slices:
-    ///
-    /// ```
-    /// use rayon::prelude::*;
-    /// assert_eq!("".par_split_whitespace().count(), 0);
-    /// assert_eq!("   ".par_split_whitespace().count(), 0);
-    /// ```
-    fn par_split_ascii_whitespace(&self) -> SplitAsciiWhitespace<'_> {
-        SplitAsciiWhitespace(self.as_parallel_string())
-    }
-
-    /// Returns a parallel iterator over substrings that match a
-    /// given character or predicate, similar to `str::matches`.
-    ///
-    /// Note: the `Pattern` trait is private, for use only by Rayon itself.
-    /// It is implemented for `char`, `&[char]`, `[char; N]`, `&[char; N]`,
-    /// and any function or closure `F: Fn(char) -> bool + Sync + Send`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rayon::prelude::*;
-    /// let total = "1, 2, buckle, 3, 4, door"
-    ///    .par_matches(char::is_numeric)
-    ///    .map(|s| s.parse::<i32>().expect("digit"))
-    ///    .sum();
-    /// assert_eq!(10, total);
-    /// ```
-    fn par_matches<P: Pattern>(&self, pattern: P) -> Matches<'_, P> {
-        Matches {
-            chars: self.as_parallel_string(),
-            pattern,
-        }
-    }
-
-    /// Returns a parallel iterator over substrings that match a given character
-    /// or predicate, with their positions, similar to `str::match_indices`.
-    ///
-    /// Note: the `Pattern` trait is private, for use only by Rayon itself.
-    /// It is implemented for `char`, `&[char]`, `[char; N]`, `&[char; N]`,
-    /// and any function or closure `F: Fn(char) -> bool + Sync + Send`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rayon::prelude::*;
-    /// let digits: Vec<_> = "1, 2, buckle, 3, 4, door"
-    ///    .par_match_indices(char::is_numeric)
-    ///    .collect();
-    /// assert_eq!(digits, vec![(0, "1"), (3, "2"), (14, "3"), (17, "4")]);
-    /// ```
-    fn par_match_indices<P: Pattern>(&self, pattern: P) -> MatchIndices<'_, P> {
-        MatchIndices {
-            chars: self.as_parallel_string(),
-            pattern,
-        }
-    }
-}
-
-impl ParallelString for str {
-    #[inline]
-    fn as_parallel_string(&self) -> &str {
-        self
-    }
-}
-
-// /////////////////////////////////////////////////////////////////////////
-
-/// We hide the `Pattern` trait in a private module, as its API is not meant
-/// for general consumption.  If we could have privacy on trait items, then it
-/// would be nicer to have its basic existence and implementors public while
-/// keeping all of the methods private.
-mod private {
-    use crate::iter::plumbing::Folder;
-
-    /// Pattern-matching trait for `ParallelString`, somewhat like a mix of
-    /// `std::str::pattern::{Pattern, Searcher}`.
-    ///
-    /// Implementing this trait is not permitted outside of `rayon`.
-    pub trait Pattern: Sized + Sync + Send {
-        private_decl! {}
-        fn find_in(&self, haystack: &str) -> Option<usize>;
-        fn rfind_in(&self, haystack: &str) -> Option<usize>;
-        fn is_suffix_of(&self, haystack: &str) -> bool;
-        fn fold_splits<'ch, F>(&self, haystack: &'ch str, folder: F, skip_last: bool) -> F
-        where
-            F: Folder<&'ch str>;
-        fn fold_inclusive_splits<'ch, F>(&self, haystack: &'ch str, folder: F) -> F
-        where
-            F: Folder<&'ch str>;
-        fn fold_matches<'ch, F>(&self, haystack: &'ch str, folder: F) -> F
-        where
-            F: Folder<&'ch str>;
-        fn fold_match_indices<'ch, F>(&self, haystack: &'ch str, folder: F, base: usize) -> F
-        where
-            F: Folder<(usize, &'ch str)>;
-    }
-}
-use self::private::Pattern;
-
-#[inline]
-fn offset<T>(base: usize) -> impl Fn((usize, T)) -> (usize, T) {
-    move |(i, x)| (base + i, x)
-}
-
-macro_rules! impl_pattern {
-    (&$self:ident => $pattern:expr) => {
-        private_impl! {}
-
-        #[inline]
-        fn find_in(&$self, chars: &str) -> Option<usize> {
-            chars.find($pattern)
-        }
-
-        #[inline]
-        fn rfind_in(&$self, chars: &str) -> Option<usize> {
-            chars.rfind($pattern)
-        }
-
-        #[inline]
-        fn is_suffix_of(&$self, chars: &str) -> bool {
-            chars.ends_with($pattern)
-        }
-
-        fn fold_splits<'ch, F>(&$self, chars: &'ch str, folder: F, skip_last: bool) -> F
-        where
-            F: Folder<&'ch str>,
-        {
-            let mut split = chars.split($pattern);
-            if skip_last {
-                split.next_back();
-            }
-            folder.consume_iter(split)
-        }
-
-        fn fold_inclusive_splits<'ch, F>(&$self, chars: &'ch str, folder: F) -> F
-        where
-            F: Folder<&'ch str>,
-        {
-            folder.consume_iter(chars.split_inclusive($pattern))
-        }
-
-        fn fold_matches<'ch, F>(&$self, chars: &'ch str, folder: F) -> F
-        where
-            F: Folder<&'ch str>,
-        {
-            folder.consume_iter(chars.matches($pattern))
-        }
-
-        fn fold_match_indices<'ch, F>(&$self, chars: &'ch str, folder: F, base: usize) -> F
-        where
-            F: Folder<(usize, &'ch str)>,
-        {
-            folder.consume_iter(chars.match_indices($pattern).map(offset(base)))
-        }
-    }
-}
-
-impl Pattern for char {
-    impl_pattern!(&self => *self);
-}
-
-impl Pattern for &[char] {
-    impl_pattern!(&self => *self);
-}
-
-// TODO (MSRV 1.75): use `*self` for array patterns too.
-// - Needs `DoubleEndedSearcher` so `split.next_back()` works.
-
-impl<const N: usize> Pattern for [char; N] {
-    impl_pattern!(&self => self.as_slice());
-}
-
-impl<const N: usize> Pattern for &[char; N] {
-    impl_pattern!(&self => self.as_slice());
-}
-
-impl<FN: Sync + Send + Fn(char) -> bool> Pattern for FN {
-    impl_pattern!(&self => self);
-}
-
-// /////////////////////////////////////////////////////////////////////////
-
-/// Parallel iterator over the characters of a string
-#[derive(Debug, Clone)]
-pub struct Chars<'ch> {
-    chars: &'ch str,
-}
-
-struct CharsProducer<'ch> {
-    chars: &'ch str,
-}
-
-impl<'ch> ParallelIterator for Chars<'ch> {
-    type Item = char;
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: UnindexedConsumer<Self::Item>,
-    {
-        bridge_unindexed(CharsProducer { chars: self.chars }, consumer)
-    }
-}
-
-impl<'ch> UnindexedProducer for CharsProducer<'ch> {
-    type Item = char;
-
-    fn split(self) -> (Self, Option<Self>) {
-        match split(self.chars) {
-            Some((left, right)) => (
-                CharsProducer { chars: left },
-                Some(CharsProducer { chars: right }),
-            ),
-            None => (self, None),
-        }
-    }
-
-    fn fold_with<F>(self, folder: F) -> F
-    where
-        F: Folder<Self::Item>,
-    {
-        folder.consume_iter(self.chars.chars())
-    }
-}
-
-// /////////////////////////////////////////////////////////////////////////
-
-/// Parallel iterator over the characters of a string, with their positions
-#[derive(Debug, Clone)]
-pub struct CharIndices<'ch> {
-    chars: &'ch str,
-}
-
-struct CharIndicesProducer<'ch> {
-    index: usize,
-    chars: &'ch str,
-}
-
-impl<'ch> ParallelIterator for CharIndices<'ch> {
-    type Item = (usize, char);
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: UnindexedConsumer<Self::Item>,
-    {
-        let producer = CharIndicesProducer {
-            index: 0,
-            chars: self.chars,
-        };
-        bridge_unindexed(producer, consumer)
-    }
-}
-
-impl<'ch> UnindexedProducer for CharIndicesProducer<'ch> {
-    type Item = (usize, char);
-
-    fn split(self) -> (Self, Option<Self>) {
-        match split(self.chars) {
-            Some((left, right)) => (
-                CharIndicesProducer {
-                    chars: left,
-                    ..self
-                },
-                Some(CharIndicesProducer {
-                    chars: right,
-                    index: self.index + left.len(),
-                }),
-            ),
-            None => (self, None),
-        }
-    }
-
-    fn fold_with<F>(self, folder: F) -> F
-    where
-        F: Folder<Self::Item>,
-    {
-        let base = self.index;
-        folder.consume_iter(self.chars.char_indices().map(offset(base)))
-    }
-}
-
-// /////////////////////////////////////////////////////////////////////////
-
-/// Parallel iterator over the bytes of a string
-#[derive(Debug, Clone)]
-pub struct Bytes<'ch> {
-    chars: &'ch str,
-}
-
-struct BytesProducer<'ch> {
-    chars: &'ch str,
-}
-
-impl<'ch> ParallelIterator for Bytes<'ch> {
-    type Item = u8;
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: UnindexedConsumer<Self::Item>,
-    {
-        bridge_unindexed(BytesProducer { chars: self.chars }, consumer)
-    }
-}
-
-impl<'ch> UnindexedProducer for BytesProducer<'ch> {
-    type Item = u8;
-
-    fn split(self) -> (Self, Option<Self>) {
-        match split(self.chars) {
-            Some((left, right)) => (
-                BytesProducer { chars: left },
-                Some(BytesProducer { chars: right }),
-            ),
-            None => (self, None),
-        }
-    }
-
-    fn fold_with<F>(self, folder: F) -> F
-    where
-        F: Folder<Self::Item>,
-    {
-        folder.consume_iter(self.chars.bytes())
-    }
-}
-
-// /////////////////////////////////////////////////////////////////////////
-
-/// Parallel iterator over a string encoded as UTF-16
-#[derive(Debug, Clone)]
-pub struct EncodeUtf16<'ch> {
-    chars: &'ch str,
-}
-
-struct EncodeUtf16Producer<'ch> {
-    chars: &'ch str,
-}
-
-impl<'ch> ParallelIterator for EncodeUtf16<'ch> {
-    type Item = u16;
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: UnindexedConsumer<Self::Item>,
-    {
-        bridge_unindexed(EncodeUtf16Producer { chars: self.chars }, consumer)
-    }
-}
-
-impl<'ch> UnindexedProducer for EncodeUtf16Producer<'ch> {
-    type Item = u16;
-
-    fn split(self) -> (Self, Option<Self>) {
-        match split(self.chars) {
-            Some((left, right)) => (
-                EncodeUtf16Producer { chars: left },
-                Some(EncodeUtf16Producer { chars: right }),
-            ),
-            None => (self, None),
-        }
-    }
-
-    fn fold_with<F>(self, folder: F) -> F
-    where
-        F: Folder<Self::Item>,
-    {
-        folder.consume_iter(self.chars.encode_utf16())
-    }
-}
-
-// /////////////////////////////////////////////////////////////////////////
-
-/// Parallel iterator over substrings separated by a pattern
-#[derive(Debug, Clone)]
-pub struct Split<'ch, P: Pattern> {
-    chars: &'ch str,
-    separator: P,
-}
-
-impl<'ch, P: Pattern> Split<'ch, P> {
-    fn new(chars: &'ch str, separator: P) -> Self {
-        Split { chars, separator }
-    }
-}
-
-impl<'ch, P: Pattern> ParallelIterator for Split<'ch, P> {
-    type Item = &'ch str;
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: UnindexedConsumer<Self::Item>,
-    {
-        let producer = SplitProducer::new(self.chars, &self.separator);
-        bridge_unindexed(producer, consumer)
-    }
-}
-
-/// Implement support for `SplitProducer`.
-impl<'ch, P: Pattern> Fissile<P> for &'ch str {
-    fn length(&self) -> usize {
-        self.len()
-    }
-
-    fn midpoint(&self, end: usize) -> usize {
-        // First find a suitable UTF-8 boundary.
-        find_char_midpoint(&self[..end])
-    }
-
-    fn find(&self, separator: &P, start: usize, end: usize) -> Option<usize> {
-        separator.find_in(&self[start..end])
-    }
-
-    fn rfind(&self, separator: &P, end: usize) -> Option<usize> {
-        separator.rfind_in(&self[..end])
-    }
-
-    fn split_once<const INCL: bool>(self, index: usize) -> (Self, Self) {
-        if INCL {
-            // include the separator in the left side
-            let separator = self[index..].chars().next().unwrap();
-            self.split_at(index + separator.len_utf8())
-        } else {
-            let (left, right) = self.split_at(index);
-            let mut right_iter = right.chars();
-            right_iter.next(); // skip the separator
-            (left, right_iter.as_str())
-        }
-    }
-
-    fn fold_splits<F, const INCL: bool>(self, separator: &P, folder: F, skip_last: bool) -> F
-    where
-        F: Folder<Self>,
-    {
-        if INCL {
-            debug_assert!(!skip_last);
-            separator.fold_inclusive_splits(self, folder)
-        } else {
-            separator.fold_splits(self, folder, skip_last)
-        }
-    }
-}
-
-// /////////////////////////////////////////////////////////////////////////
-
-/// Parallel iterator over substrings separated by a pattern
-#[derive(Debug, Clone)]
-pub struct SplitInclusive<'ch, P: Pattern> {
-    chars: &'ch str,
-    separator: P,
-}
-
-impl<'ch, P: Pattern> SplitInclusive<'ch, P> {
-    fn new(chars: &'ch str, separator: P) -> Self {
-        SplitInclusive { chars, separator }
-    }
-}
-
-impl<'ch, P: Pattern> ParallelIterator for SplitInclusive<'ch, P> {
-    type Item = &'ch str;
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: UnindexedConsumer<Self::Item>,
-    {
-        let producer = SplitInclusiveProducer::new_incl(self.chars, &self.separator);
-        bridge_unindexed(producer, consumer)
-    }
-}
-
-// /////////////////////////////////////////////////////////////////////////
-
-/// Parallel iterator over substrings separated by a terminator pattern
-#[derive(Debug, Clone)]
-pub struct SplitTerminator<'ch, P: Pattern> {
-    chars: &'ch str,
-    terminator: P,
-}
-
-struct SplitTerminatorProducer<'ch, 'sep, P: Pattern> {
-    splitter: SplitProducer<'sep, P, &'ch str>,
-    skip_last: bool,
-}
-
-impl<'ch, P: Pattern> SplitTerminator<'ch, P> {
-    fn new(chars: &'ch str, terminator: P) -> Self {
-        SplitTerminator { chars, terminator }
-    }
-}
-
-impl<'ch, 'sep, P: Pattern + 'sep> SplitTerminatorProducer<'ch, 'sep, P> {
-    fn new(chars: &'ch str, terminator: &'sep P) -> Self {
-        SplitTerminatorProducer {
-            splitter: SplitProducer::new(chars, terminator),
-            skip_last: chars.is_empty() || terminator.is_suffix_of(chars),
-        }
-    }
-}
-
-impl<'ch, P: Pattern> ParallelIterator for SplitTerminator<'ch, P> {
-    type Item = &'ch str;
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: UnindexedConsumer<Self::Item>,
-    {
-        let producer = SplitTerminatorProducer::new(self.chars, &self.terminator);
-        bridge_unindexed(producer, consumer)
-    }
-}
-
-impl<'ch, 'sep, P: Pattern + 'sep> UnindexedProducer for SplitTerminatorProducer<'ch, 'sep, P> {
-    type Item = &'ch str;
-
-    fn split(mut self) -> (Self, Option<Self>) {
-        let (left, right) = self.splitter.split();
-        self.splitter = left;
-        let right = right.map(|right| {
-            let skip_last = self.skip_last;
-            self.skip_last = false;
-            SplitTerminatorProducer {
-                splitter: right,
-                skip_last,
-            }
-        });
-        (self, right)
-    }
-
-    fn fold_with<F>(self, folder: F) -> F
-    where
-        F: Folder<Self::Item>,
-    {
-        self.splitter.fold_with(folder, self.skip_last)
-    }
-}
-
-// /////////////////////////////////////////////////////////////////////////
-
-/// Parallel iterator over lines in a string
-#[derive(Debug, Clone)]
-pub struct Lines<'ch>(&'ch str);
-
-#[inline]
-fn no_carriage_return(line: &str) -> &str {
-    line.strip_suffix('\r').unwrap_or(line)
-}
-
-impl<'ch> ParallelIterator for Lines<'ch> {
-    type Item = &'ch str;
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: UnindexedConsumer<Self::Item>,
-    {
-        self.0
-            .par_split_terminator('\n')
-            .map(no_carriage_return)
-            .drive_unindexed(consumer)
-    }
-}
-
-// /////////////////////////////////////////////////////////////////////////
-
-/// Parallel iterator over substrings separated by whitespace
-#[derive(Debug, Clone)]
-pub struct SplitWhitespace<'ch>(&'ch str);
-
-#[inline]
-fn not_empty(s: &&str) -> bool {
-    !s.is_empty()
-}
-
-impl<'ch> ParallelIterator for SplitWhitespace<'ch> {
-    type Item = &'ch str;
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: UnindexedConsumer<Self::Item>,
-    {
-        self.0
-            .par_split(char::is_whitespace)
-            .filter(not_empty)
-            .drive_unindexed(consumer)
-    }
-}
-
-// /////////////////////////////////////////////////////////////////////////
-
-/// Parallel iterator over substrings separated by ASCII whitespace
-#[derive(Debug, Clone)]
-pub struct SplitAsciiWhitespace<'ch>(&'ch str);
-
-#[inline]
-fn is_ascii_whitespace(c: char) -> bool {
-    c.is_ascii_whitespace()
-}
-
-impl<'ch> ParallelIterator for SplitAsciiWhitespace<'ch> {
-    type Item = &'ch str;
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: UnindexedConsumer<Self::Item>,
-    {
-        self.0
-            .par_split(is_ascii_whitespace)
-            .filter(not_empty)
-            .drive_unindexed(consumer)
-    }
-}
-
-// /////////////////////////////////////////////////////////////////////////
-
-/// Parallel iterator over substrings that match a pattern
-#[derive(Debug, Clone)]
-pub struct Matches<'ch, P: Pattern> {
-    chars: &'ch str,
-    pattern: P,
-}
-
-struct MatchesProducer<'ch, 'pat, P: Pattern> {
-    chars: &'ch str,
-    pattern: &'pat P,
-}
-
-impl<'ch, P: Pattern> ParallelIterator for Matches<'ch, P> {
-    type Item = &'ch str;
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: UnindexedConsumer<Self::Item>,
-    {
-        let producer = MatchesProducer {
-            chars: self.chars,
-            pattern: &self.pattern,
-        };
-        bridge_unindexed(producer, consumer)
-    }
-}
-
-impl<'ch, 'pat, P: Pattern> UnindexedProducer for MatchesProducer<'ch, 'pat, P> {
-    type Item = &'ch str;
-
-    fn split(self) -> (Self, Option<Self>) {
-        match split(self.chars) {
-            Some((left, right)) => (
-                MatchesProducer {
-                    chars: left,
-                    ..self
-                },
-                Some(MatchesProducer {
-                    chars: right,
-                    ..self
-                }),
-            ),
-            None => (self, None),
-        }
-    }
-
-    fn fold_with<F>(self, folder: F) -> F
-    where
-        F: Folder<Self::Item>,
-    {
-        self.pattern.fold_matches(self.chars, folder)
-    }
-}
-
-// /////////////////////////////////////////////////////////////////////////
-
-/// Parallel iterator over substrings that match a pattern, with their positions
-#[derive(Debug, Clone)]
-pub struct MatchIndices<'ch, P: Pattern> {
-    chars: &'ch str,
-    pattern: P,
-}
-
-struct MatchIndicesProducer<'ch, 'pat, P: Pattern> {
-    index: usize,
-    chars: &'ch str,
-    pattern: &'pat P,
-}
-
-impl<'ch, P: Pattern> ParallelIterator for MatchIndices<'ch, P> {
-    type Item = (usize, &'ch str);
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: UnindexedConsumer<Self::Item>,
-    {
-        let producer = MatchIndicesProducer {
-            index: 0,
-            chars: self.chars,
-            pattern: &self.pattern,
-        };
-        bridge_unindexed(producer, consumer)
-    }
-}
-
-impl<'ch, 'pat, P: Pattern> UnindexedProducer for MatchIndicesProducer<'ch, 'pat, P> {
-    type Item = (usize, &'ch str);
-
-    fn split(self) -> (Self, Option<Self>) {
-        match split(self.chars) {
-            Some((left, right)) => (
-                MatchIndicesProducer {
-                    chars: left,
-                    ..self
-                },
-                Some(MatchIndicesProducer {
-                    chars: right,
-                    index: self.index + left.len(),
-                    ..self
-                }),
-            ),
-            None => (self, None),
-        }
-    }
-
-    fn fold_with<F>(self, folder: F) -> F
-    where
-        F: Folder<Self::Item>,
-    {
-        self.pattern
-            .fold_match_indices(self.chars, folder, self.index)
-    }
-}