Trait astral::thirdparty::rayon::iter::ParallelIterator

pub trait ParallelIterator: Send {
    type Item: Send;
    fn drive_unindexed<C>(
        self, 
        consumer: C
    ) -> <C as Consumer<Self::Item>>::Result
    where
        C: UnindexedConsumer<Self::Item>;

    fn for_each<OP>(self, op: OP)
    where
        OP: Fn(Self::Item) + Sync + Send,
    { ... }
    fn for_each_with<OP, T>(self, init: T, op: OP)
    where
        OP: Fn(&mut T, Self::Item) + Sync + Send,
        T: Send + Clone,
    { ... }
    fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP)
    where
        INIT: Fn() -> T + Sync + Send,
        OP: Fn(&mut T, Self::Item) + Sync + Send,
    { ... }
    fn try_for_each<OP, R>(self, op: OP) -> R
    where
        OP: Fn(Self::Item) -> R + Sync + Send,
        R: Try<Ok = ()> + Send,
    { ... }
    fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R
    where
        OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
        R: Try<Ok = ()> + Send,
        T: Send + Clone,
    { ... }
    fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R
    where
        INIT: Fn() -> T + Sync + Send,
        OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
        R: Try<Ok = ()> + Send,
    { ... }
    fn count(self) -> usize { ... }
    fn map<F, R>(self, map_op: F) -> Map<Self, F>
    where
        F: Fn(Self::Item) -> R + Sync + Send,
        R: Send,
    { ... }
    fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F>
    where
        F: Fn(&mut T, Self::Item) -> R + Sync + Send,
        R: Send,
        T: Send + Clone,
    { ... }
    fn map_init<F, INIT, T, R>(
        self, 
        init: INIT, 
        map_op: F
    ) -> MapInit<Self, INIT, F>
    where
        F: Fn(&mut T, Self::Item) -> R + Sync + Send,
        INIT: Fn() -> T + Sync + Send,
        R: Send,
    { ... }
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
        Self: ParallelIterator<Item = &'a T>,
        T: 'a + Clone + Send,
    { ... }
    fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP>
    where
        OP: Fn(&Self::Item) + Sync + Send,
    { ... }
    fn update<F>(self, update_op: F) -> Update<Self, F>
    where
        F: Fn(&mut Self::Item) + Sync + Send,
    { ... }
    fn filter<P>(self, filter_op: P) -> Filter<Self, P>
    where
        P: Fn(&Self::Item) -> bool + Sync + Send,
    { ... }
    fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P>
    where
        P: Fn(Self::Item) -> Option<R> + Sync + Send,
        R: Send,
    { ... }
    fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F>
    where
        F: Fn(Self::Item) -> PI + Sync + Send,
        PI: IntoParallelIterator,
    { ... }
    fn flatten(self) -> Flatten<Self>
    where
        Self::Item: IntoParallelIterator,
    { ... }
    fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item
    where
        ID: Fn() -> Self::Item + Sync + Send,
        OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
    { ... }
    fn reduce_with<OP>(self, op: OP) -> Option<Self::Item>
    where
        OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
    { ... }
    fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item
    where
        ID: Fn() -> T + Sync + Send,
        OP: Fn(T, T) -> Self::Item + Sync + Send,
        Self::Item: Try,
        <Self::Item as Try>::Ok == T,
    { ... }
    fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item>
    where
        OP: Fn(T, T) -> Self::Item + Sync + Send,
        Self::Item: Try,
        <Self::Item as Try>::Ok == T,
    { ... }
    fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F>
    where
        F: Fn(T, Self::Item) -> T + Sync + Send,
        ID: Fn() -> T + Sync + Send,
        T: Send,
    { ... }
    fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F>
    where
        F: Fn(T, Self::Item) -> T + Sync + Send,
        T: Send + Clone,
    { ... }
    fn try_fold<T, R, ID, F>(
        self, 
        identity: ID, 
        fold_op: F
    ) -> TryFold<Self, R, ID, F>
    where
        F: Fn(T, Self::Item) -> R + Sync + Send,
        ID: Fn() -> T + Sync + Send,
        R: Try<Ok = T> + Send,
    { ... }
    fn try_fold_with<F, T, R>(
        self, 
        init: T, 
        fold_op: F
    ) -> TryFoldWith<Self, R, F>
    where
        F: Fn(T, Self::Item) -> R + Sync + Send,
        R: Try<Ok = T> + Send,
        T: Clone + Send,
    { ... }
    fn sum<S>(self) -> S
    where
        S: Send + Sum<Self::Item> + Sum<S>,
    { ... }
    fn product<P>(self) -> P
    where
        P: Send + Product<Self::Item> + Product<P>,
    { ... }
    fn min(self) -> Option<Self::Item>
    where
        Self::Item: Ord,
    { ... }
    fn min_by<F>(self, f: F) -> Option<Self::Item>
    where
        F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
    { ... }
    fn min_by_key<K, F>(self, f: F) -> Option<Self::Item>
    where
        F: Sync + Send + Fn(&Self::Item) -> K,
        K: Ord + Send,
    { ... }
    fn max(self) -> Option<Self::Item>
    where
        Self::Item: Ord,
    { ... }
    fn max_by<F>(self, f: F) -> Option<Self::Item>
    where
        F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
    { ... }
    fn max_by_key<K, F>(self, f: F) -> Option<Self::Item>
    where
        F: Sync + Send + Fn(&Self::Item) -> K,
        K: Ord + Send,
    { ... }
    fn chain<C>(
        self, 
        chain: C
    ) -> Chain<Self, <C as IntoParallelIterator>::Iter>
    where
        C: IntoParallelIterator<Item = Self::Item>,
    { ... }
    fn find_any<P>(self, predicate: P) -> Option<Self::Item>
    where
        P: Fn(&Self::Item) -> bool + Sync + Send,
    { ... }
    fn find_first<P>(self, predicate: P) -> Option<Self::Item>
    where
        P: Fn(&Self::Item) -> bool + Sync + Send,
    { ... }
    fn find_last<P>(self, predicate: P) -> Option<Self::Item>
    where
        P: Fn(&Self::Item) -> bool + Sync + Send,
    { ... }
    fn any<P>(self, predicate: P) -> bool
    where
        P: Fn(Self::Item) -> bool + Sync + Send,
    { ... }
    fn all<P>(self, predicate: P) -> bool
    where
        P: Fn(Self::Item) -> bool + Sync + Send,
    { ... }
    fn while_some<T>(self) -> WhileSome<Self>
    where
        Self: ParallelIterator<Item = Option<T>>,
        T: Send,
    { ... }
    fn collect<C>(self) -> C
    where
        C: FromParallelIterator<Self::Item>,
    { ... }
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
        A: Send,
        B: Send,
        FromA: Default + Send + ParallelExtend<A>,
        FromB: Default + Send + ParallelExtend<B>,
        Self: ParallelIterator<Item = (A, B)>,
    { ... }
    fn partition<A, B, P>(self, predicate: P) -> (A, B)
    where
        A: Default + Send + ParallelExtend<Self::Item>,
        B: Default + Send + ParallelExtend<Self::Item>,
        P: Fn(&Self::Item) -> bool + Sync + Send,
    { ... }
    fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B)
    where
        A: Default + Send + ParallelExtend<L>,
        B: Default + Send + ParallelExtend<R>,
        L: Send,
        P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
        R: Send,
    { ... }
    fn intersperse(self, element: Self::Item) -> Intersperse<Self>
    where
        Self::Item: Clone,
    { ... }
    fn opt_len(&self) -> Option<usize> { ... }
}

Parallel version of the standard iterator trait.

The combinators on this trait are available on all parallel iterators. Additional methods can be found on the IndexedParallelIterator trait: those methods are only available for parallel iterators where the number of items is known in advance (so, e.g., after invoking filter, those methods become unavailable).

For examples of using parallel iterators, see the docs on the iter module.

Associated Types

type Item: Send

The type of item that this parallel iterator produces. For example, if you use the for_each method, this is the type of item that your closure will be invoked with.

Loading content...

Required methods

fn drive_unindexed<C>(self, consumer: C) -> <C as Consumer<Self::Item>>::Result where
    C: UnindexedConsumer<Self::Item>, 

Internal method used to define the behavior of this parallel iterator. You should not need to call this directly.

This method causes the iterator self to start producing items and to feed them to the consumer consumer one by one. It may split the consumer before doing so to create the opportunity to produce in parallel.

See the README for more details on the internals of parallel iterators.

Loading content...

Provided methods

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

Executes OP on each item produced by the iterator, in parallel.

Examples

use rayon::prelude::*;

(0..100).into_par_iter().for_each(|x| println!("{:?}", x));

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

Executes OP on the given init value with each item produced by the iterator, in parallel.

The init value will be cloned only as needed to be paired with the group of items in each rayon job. It does not require the type to be Sync.

Examples

use std::sync::mpsc::channel;
use rayon::prelude::*;

let (sender, receiver) = channel();

(0..5).into_par_iter().for_each_with(sender, |s, x| s.send(x).unwrap());

let mut res: Vec<_> = receiver.iter().collect();

res.sort();

assert_eq!(&res[..], &[0, 1, 2, 3, 4])

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

Executes OP on a value returned by init with each item produced by the iterator, in parallel.

The init function will be called only as needed for a value to be paired with the group of items in each rayon job. There is no constraint on that returned type at all!

Examples

extern crate rand;
extern crate rayon;

use rand::Rng;
use rayon::prelude::*;

let mut v = vec![0u8; 1_000_000];

v.par_chunks_mut(1000)
    .for_each_init(
        || rand::thread_rng(),
        |rng, chunk| rng.fill(chunk),
    );

// There's a remote chance that this will fail...
for i in 0u8..=255 {
    assert!(v.contains(&i));
}

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

Executes a fallible OP on each item produced by the iterator, in parallel.

If the OP returns Result::Err or Option::None, we will attempt to stop processing the rest of the items in the iterator as soon as possible, and we will return that terminating value. Otherwise, we will return an empty Result::Ok(()) or Option::Some(()). If there are multiple errors in parallel, it is not specified which will be returned.

Examples

use rayon::prelude::*;
use std::io::{self, Write};

// This will stop iteration early if there's any write error, like
// having piped output get closed on the other end.
(0..100).into_par_iter()
    .try_for_each(|x| writeln!(io::stdout(), "{:?}", x))
    .expect("expected no write errors");

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

Executes a fallible OP on the given init value with each item produced by the iterator, in parallel.

This combines the init semantics of for_each_with() and the failure semantics of try_for_each().

Examples

use std::sync::mpsc::channel;
use rayon::prelude::*;

let (sender, receiver) = channel();

(0..5).into_par_iter()
    .try_for_each_with(sender, |s, x| s.send(x))
    .expect("expected no send errors");

let mut res: Vec<_> = receiver.iter().collect();

res.sort();

assert_eq!(&res[..], &[0, 1, 2, 3, 4])

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

Executes a fallible OP on a value returned by init with each item produced by the iterator, in parallel.

This combines the init semantics of for_each_init() and the failure semantics of try_for_each().

Examples

extern crate rand;
extern crate rayon;

use rand::Rng;
use rayon::prelude::*;

let mut v = vec![0u8; 1_000_000];

v.par_chunks_mut(1000)
    .try_for_each_init(
        || rand::thread_rng(),
        |rng, chunk| rng.try_fill(chunk),
    )
    .expect("expected no rand errors");

// There's a remote chance that this will fail...
for i in 0u8..=255 {
    assert!(v.contains(&i));
}

fn count(self) -> usize

Counts the number of items in this parallel iterator.

Examples

use rayon::prelude::*;

let count = (0..100).into_par_iter().count();

assert_eq!(count, 100);

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

Applies map_op to each item of this iterator, producing a new iterator with the results.

Examples

use rayon::prelude::*;

let mut par_iter = (0..5).into_par_iter().map(|x| x * 2);

let doubles: Vec<_> = par_iter.collect();

assert_eq!(&doubles[..], &[0, 2, 4, 6, 8]);

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

Applies map_op to the given init value with each item of this iterator, producing a new iterator with the results.

The init value will be cloned only as needed to be paired with the group of items in each rayon job. It does not require the type to be Sync.

Examples

use std::sync::mpsc::channel;
use rayon::prelude::*;

let (sender, receiver) = channel();

let a: Vec<_> = (0..5)
                .into_par_iter()            // iterating over i32
                .map_with(sender, |s, x| {
                    s.send(x).unwrap();     // sending i32 values through the channel
                    x                       // returning i32
                })
                .collect();                 // collecting the returned values into a vector

let mut b: Vec<_> = receiver.iter()         // iterating over the values in the channel
                            .collect();     // and collecting them
b.sort();

assert_eq!(a, b);

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

Applies map_op to a value returned by init with each item of this iterator, producing a new iterator with the results.

The init function will be called only as needed for a value to be paired with the group of items in each rayon job. There is no constraint on that returned type at all!

Examples

extern crate rand;
extern crate rayon;

use rand::Rng;
use rayon::prelude::*;

let a: Vec<_> = (1i32..1_000_000)
    .into_par_iter()
    .map_init(
        || rand::thread_rng(),  // get the thread-local RNG
        |rng, x| if rng.gen() { // randomly negate items
            -x
        } else {
            x
        },
    ).collect();

// There's a remote chance that this will fail...
assert!(a.iter().any(|&x| x < 0));
assert!(a.iter().any(|&x| x > 0));

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

Creates an iterator which clones all of its elements. This may be useful when you have an iterator over &T, but you need T.

Examples

use rayon::prelude::*;

let a = [1, 2, 3];

let v_cloned: Vec<_> = a.par_iter().cloned().collect();

// cloned is the same as .map(|&x| x), for integers
let v_map: Vec<_> = a.par_iter().map(|&x| x).collect();

assert_eq!(v_cloned, vec![1, 2, 3]);
assert_eq!(v_map, vec![1, 2, 3]);

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

Applies inspect_op to a reference to each item of this iterator, producing a new iterator passing through the original items. This is often useful for debugging to see what's happening in iterator stages.

Examples

use rayon::prelude::*;

let a = [1, 4, 2, 3];

// this iterator sequence is complex.
let sum = a.par_iter()
            .cloned()
            .filter(|&x| x % 2 == 0)
            .reduce(|| 0, |sum, i| sum + i);

println!("{}", sum);

// let's add some inspect() calls to investigate what's happening
let sum = a.par_iter()
            .cloned()
            .inspect(|x| println!("about to filter: {}", x))
            .filter(|&x| x % 2 == 0)
            .inspect(|x| println!("made it through filter: {}", x))
            .reduce(|| 0, |sum, i| sum + i);

println!("{}", sum);

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

Mutates each item of this iterator before yielding it.

Examples

use rayon::prelude::*;

let par_iter = (0..5).into_par_iter().update(|x| {*x *= 2;});

let doubles: Vec<_> = par_iter.collect();

assert_eq!(&doubles[..], &[0, 2, 4, 6, 8]);

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

Applies filter_op to each item of this iterator, producing a new iterator with only the items that gave true results.

Examples

use rayon::prelude::*;

let mut par_iter = (0..10).into_par_iter().filter(|x| x % 2 == 0);

let even_numbers: Vec<_> = par_iter.collect();

assert_eq!(&even_numbers[..], &[0, 2, 4, 6, 8]);

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

Applies filter_op to each item of this iterator to get an Option, producing a new iterator with only the items from Some results.

Examples

use rayon::prelude::*;

let mut par_iter = (0..10).into_par_iter()
                        .filter_map(|x| {
                            if x % 2 == 0 { Some(x * 3) }
                            else { None }
                        });

let even_numbers: Vec<_> = par_iter.collect();

assert_eq!(&even_numbers[..], &[0, 6, 12, 18, 24]);

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

Applies map_op to each item of this iterator to get nested iterators, producing a new iterator that flattens these back into one.

Examples

use rayon::prelude::*;

let a = [[1, 2], [3, 4], [5, 6], [7, 8]];

let par_iter = a.par_iter().cloned().flat_map(|a| a.to_vec());

let vec: Vec<_> = par_iter.collect();

assert_eq!(&vec[..], &[1, 2, 3, 4, 5, 6, 7, 8]);

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

An adaptor that flattens iterable Items into one large iterator

Examples

use rayon::prelude::*;

let x: Vec<Vec<_>> = vec![vec![1, 2], vec![3, 4]];
let y: Vec<_> = x.into_par_iter().flatten().collect();

assert_eq!(y, vec![1, 2, 3, 4]);

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

Reduces the items in the iterator into one item using op. The argument identity should be a closure that can produce "identity" value which may be inserted into the sequence as needed to create opportunities for parallel execution. So, for example, if you are doing a summation, then identity() ought to produce something that represents the zero for your type (but consider just calling sum() in that case).

Examples

// Iterate over a sequence of pairs `(x0, y0), ..., (xN, yN)`
// and use reduce to compute one pair `(x0 + ... + xN, y0 + ... + yN)`
// where the first/second elements are summed separately.
use rayon::prelude::*;
let sums = [(0, 1), (5, 6), (16, 2), (8, 9)]
           .par_iter()        // iterating over &(i32, i32)
           .cloned()          // iterating over (i32, i32)
           .reduce(|| (0, 0), // the "identity" is 0 in both columns
                   |a, b| (a.0 + b.0, a.1 + b.1));
assert_eq!(sums, (0 + 5 + 16 + 8, 1 + 6 + 2 + 9));

Note: unlike a sequential fold operation, the order in which op will be applied to reduce the result is not fully specified. So op should be associative or else the results will be non-deterministic. And of course identity() should produce a true identity.

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

Reduces the items in the iterator into one item using op. If the iterator is empty, None is returned; otherwise, Some is returned.

This version of reduce is simple but somewhat less efficient. If possible, it is better to call reduce(), which requires an identity element.

Examples

use rayon::prelude::*;
let sums = [(0, 1), (5, 6), (16, 2), (8, 9)]
           .par_iter()        // iterating over &(i32, i32)
           .cloned()          // iterating over (i32, i32)
           .reduce_with(|a, b| (a.0 + b.0, a.1 + b.1))
           .unwrap();
assert_eq!(sums, (0 + 5 + 16 + 8, 1 + 6 + 2 + 9));

Note: unlike a sequential fold operation, the order in which op will be applied to reduce the result is not fully specified. So op should be associative or else the results will be non-deterministic.

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

Reduces the items in the iterator into one item using a fallible op. The identity argument is used the same way as in reduce().

If a Result::Err or Option::None item is found, or if op reduces to one, we will attempt to stop processing the rest of the items in the iterator as soon as possible, and we will return that terminating value. Otherwise, we will return the final reduced Result::Ok(T) or Option::Some(T). If there are multiple errors in parallel, it is not specified which will be returned.

Examples

use rayon::prelude::*;

// Compute the sum of squares, being careful about overflow.
fn sum_squares<I: IntoParallelIterator<Item = i32>>(iter: I) -> Option<i32> {
    iter.into_par_iter()
        .map(|i| i.checked_mul(i))            // square each item,
        .try_reduce(|| 0, i32::checked_add)   // and add them up!
}
assert_eq!(sum_squares(0..5), Some(0 + 1 + 4 + 9 + 16));

// The sum might overflow
assert_eq!(sum_squares(0..10_000), None);

// Or the squares might overflow before it even reaches `try_reduce`
assert_eq!(sum_squares(1_000_000..1_000_001), None);

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

Reduces the items in the iterator into one item using a fallible op.

Like reduce_with(), if the iterator is empty, None is returned; otherwise, Some is returned. Beyond that, it behaves like try_reduce() for handling Err/None.

For instance, with Option items, the return value may be:

• None, the iterator was empty
• Some(None), we stopped after encountering None.
• Some(Some(x)), the entire iterator reduced to x.

With Result items, the nesting is more obvious:

• None, the iterator was empty
• Some(Err(e)), we stopped after encountering an error e.
• Some(Ok(x)), the entire iterator reduced to x.

Examples

use rayon::prelude::*;

let files = ["/dev/null", "/does/not/exist"];

// Find the biggest file
files.into_par_iter()
    .map(|path| std::fs::metadata(path).map(|m| (path, m.len())))
    .try_reduce_with(|a, b| {
        Ok(if a.1 >= b.1 { a } else { b })
    })
    .expect("Some value, since the iterator is not empty")
    .expect_err("not found");

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

Parallel fold is similar to sequential fold except that the sequence of items may be subdivided before it is folded. Consider a list of numbers like 22 3 77 89 46. If you used sequential fold to add them (fold(0, |a,b| a+b), you would wind up first adding 0 + 22, then 22 + 3, then 25 + 77, and so forth. The parallel fold works similarly except that it first breaks up your list into sublists, and hence instead of yielding up a single sum at the end, it yields up multiple sums. The number of results is nondeterministic, as is the point where the breaks occur.

So if did the same parallel fold (fold(0, |a,b| a+b)) on our example list, we might wind up with a sequence of two numbers, like so:

22 3 77 89 46
      |     |
    102   135

Or perhaps these three numbers:

22 3 77 89 46
      |  |  |
    102 89 46

In general, Rayon will attempt to find good breaking points that keep all of your cores busy.

Fold versus reduce

The fold() and reduce() methods each take an identity element and a combining function, but they operate rather differently.

reduce() requires that the identity function has the same type as the things you are iterating over, and it fully reduces the list of items into a single item. So, for example, imagine we are iterating over a list of bytes bytes: [128_u8, 64_u8, 64_u8]. If we used bytes.reduce(|| 0_u8, |a: u8, b: u8| a + b), we would get an overflow. This is because 0, a, and b here are all bytes, just like the numbers in the list (I wrote the types explicitly above, but those are the only types you can use). To avoid the overflow, we would need to do something like bytes.map(|b| b as u32).reduce(|| 0, |a, b| a + b), in which case our result would be 256.

In contrast, with fold(), the identity function does not have to have the same type as the things you are iterating over, and you potentially get back many results. So, if we continue with the bytes example from the previous paragraph, we could do bytes.fold(|| 0_u32, |a, b| a + (b as u32)) to convert our bytes into u32. And of course we might not get back a single sum.

There is a more subtle distinction as well, though it's actually implied by the above points. When you use reduce(), your reduction function is sometimes called with values that were never part of your original parallel iterator (for example, both the left and right might be a partial sum). With fold(), in contrast, the left value in the fold function is always the accumulator, and the right value is always from your original sequence.

Fold vs Map/Reduce

Fold makes sense if you have some operation where it is cheaper to create groups of elements at a time. For example, imagine collecting characters into a string. If you were going to use map/reduce, you might try this:

use rayon::prelude::*;

let s =
    ['a', 'b', 'c', 'd', 'e']
    .par_iter()
    .map(|c: &char| format!("{}", c))
    .reduce(|| String::new(),
            |mut a: String, b: String| { a.push_str(&b); a });

assert_eq!(s, "abcde");

Because reduce produces the same type of element as its input, you have to first map each character into a string, and then you can reduce them. This means we create one string per element in our iterator -- not so great. Using fold, we can do this instead:

use rayon::prelude::*;

let s =
    ['a', 'b', 'c', 'd', 'e']
    .par_iter()
    .fold(|| String::new(),
            |mut s: String, c: &char| { s.push(*c); s })
    .reduce(|| String::new(),
            |mut a: String, b: String| { a.push_str(&b); a });

assert_eq!(s, "abcde");

Now fold will process groups of our characters at a time, and we only make one string per group. We should wind up with some small-ish number of strings roughly proportional to the number of CPUs you have (it will ultimately depend on how busy your processors are). Note that we still need to do a reduce afterwards to combine those groups of strings into a single string.

You could use a similar trick to save partial results (e.g., a cache) or something similar.

Combining fold with other operations

You can combine fold with reduce if you want to produce a single value. This is then roughly equivalent to a map/reduce combination in effect:

use rayon::prelude::*;

let bytes = 0..22_u8;
let sum = bytes.into_par_iter()
               .fold(|| 0_u32, |a: u32, b: u8| a + (b as u32))
               .sum::<u32>();

assert_eq!(sum, (0..22).sum()); // compare to sequential

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

Applies fold_op to the given init value with each item of this iterator, finally producing the value for further use.

This works essentially like fold(|| init.clone(), fold_op), except it doesn't require the init type to be Sync, nor any other form of added synchronization.

Examples

use rayon::prelude::*;

let bytes = 0..22_u8;
let sum = bytes.into_par_iter()
               .fold_with(0_u32, |a: u32, b: u8| a + (b as u32))
               .sum::<u32>();

assert_eq!(sum, (0..22).sum()); // compare to sequential

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

Perform a fallible parallel fold.

This is a variation of fold() for operations which can fail with Option::None or Result::Err. The first such failure stops processing the local set of items, without affecting other folds in the iterator's subdivisions.

Often, try_fold() will be followed by try_reduce() for a final reduction and global short-circuiting effect.

Examples

use rayon::prelude::*;

let bytes = 0..22_u8;
let sum = bytes.into_par_iter()
               .try_fold(|| 0_u32, |a: u32, b: u8| a.checked_add(b as u32))
               .try_reduce(|| 0, u32::checked_add);

assert_eq!(sum, Some((0..22).sum())); // compare to sequential

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

Perform a fallible parallel fold with a cloneable init value.

This combines the init semantics of fold_with() and the failure semantics of try_fold().

use rayon::prelude::*;

let bytes = 0..22_u8;
let sum = bytes.into_par_iter()
               .try_fold_with(0_u32, |a: u32, b: u8| a.checked_add(b as u32))
               .try_reduce(|| 0, u32::checked_add);

assert_eq!(sum, Some((0..22).sum())); // compare to sequential

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

Sums up the items in the iterator.

Note that the order in items will be reduced is not specified, so if the + operator is not truly associative (as is the case for floating point numbers), then the results are not fully deterministic.

Basically equivalent to self.reduce(|| 0, |a, b| a + b), except that the type of 0 and the + operation may vary depending on the type of value being produced.

Examples

use rayon::prelude::*;

let a = [1, 5, 7];

let sum: i32 = a.par_iter().sum();

assert_eq!(sum, 13);

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

Multiplies all the items in the iterator.

Note that the order in items will be reduced is not specified, so if the * operator is not truly associative (as is the case for floating point numbers), then the results are not fully deterministic.

Basically equivalent to self.reduce(|| 1, |a, b| a * b), except that the type of 1 and the * operation may vary depending on the type of value being produced.

Examples

use rayon::prelude::*;

fn factorial(n: u32) -> u32 {
   (1..n+1).into_par_iter().product()
}

assert_eq!(factorial(0), 1);
assert_eq!(factorial(1), 1);
assert_eq!(factorial(5), 120);

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

Computes the minimum of all the items in the iterator. If the iterator is empty, None is returned; otherwise, Some(min) is returned.

Note that the order in which the items will be reduced is not specified, so if the Ord impl is not truly associative, then the results are not deterministic.

Basically equivalent to self.reduce_with(|a, b| cmp::min(a, b)).

Examples

use rayon::prelude::*;

let a = [45, 74, 32];

assert_eq!(a.par_iter().min(), Some(&32));

let b: [i32; 0] = [];

assert_eq!(b.par_iter().min(), None);

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

Computes the minimum of all the items in the iterator with respect to the given comparison function. If the iterator is empty, None is returned; otherwise, Some(min) is returned.

Note that the order in which the items will be reduced is not specified, so if the comparison function is not associative, then the results are not deterministic.

Examples

use rayon::prelude::*;

let a = [-3_i32, 77, 53, 240, -1];

assert_eq!(a.par_iter().min_by(|x, y| x.cmp(y)), Some(&-3));

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

Computes the item that yields the minimum value for the given function. If the iterator is empty, None is returned; otherwise, Some(item) is returned.

Note that the order in which the items will be reduced is not specified, so if the Ord impl is not truly associative, then the results are not deterministic.

Examples

use rayon::prelude::*;

let a = [-3_i32, 34, 2, 5, -10, -3, -23];

assert_eq!(a.par_iter().min_by_key(|x| x.abs()), Some(&2));

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

Computes the maximum of all the items in the iterator. If the iterator is empty, None is returned; otherwise, Some(max) is returned.

Note that the order in which the items will be reduced is not specified, so if the Ord impl is not truly associative, then the results are not deterministic.

Basically equivalent to self.reduce_with(|a, b| cmp::max(a, b)).

Examples

use rayon::prelude::*;

let a = [45, 74, 32];

assert_eq!(a.par_iter().max(), Some(&74));

let b: [i32; 0] = [];

assert_eq!(b.par_iter().max(), None);

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

Computes the maximum of all the items in the iterator with respect to the given comparison function. If the iterator is empty, None is returned; otherwise, Some(min) is returned.

Note that the order in which the items will be reduced is not specified, so if the comparison function is not associative, then the results are not deterministic.

Examples

use rayon::prelude::*;

let a = [-3_i32, 77, 53, 240, -1];

assert_eq!(a.par_iter().max_by(|x, y| x.abs().cmp(&y.abs())), Some(&240));

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

Computes the item that yields the maximum value for the given function. If the iterator is empty, None is returned; otherwise, Some(item) is returned.

Note that the order in which the items will be reduced is not specified, so if the Ord impl is not truly associative, then the results are not deterministic.

Examples

use rayon::prelude::*;

let a = [-3_i32, 34, 2, 5, -10, -3, -23];

assert_eq!(a.par_iter().max_by_key(|x| x.abs()), Some(&34));

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

Takes two iterators and creates a new iterator over both.

Examples

use rayon::prelude::*;

let a = [0, 1, 2];
let b = [9, 8, 7];

let par_iter = a.par_iter().chain(b.par_iter());

let chained: Vec<_> = par_iter.cloned().collect();

assert_eq!(&chained[..], &[0, 1, 2, 9, 8, 7]);

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

Searches for some item in the parallel iterator that matches the given predicate and returns it. This operation is similar to find on sequential iterators but the item returned may not be the first one in the parallel sequence which matches, since we search the entire sequence in parallel.

Once a match is found, we will attempt to stop processing the rest of the items in the iterator as soon as possible (just as find stops iterating once a match is found).

Examples

use rayon::prelude::*;

let a = [1, 2, 3, 3];

assert_eq!(a.par_iter().find_any(|&&x| x == 3), Some(&3));

assert_eq!(a.par_iter().find_any(|&&x| x == 100), None);

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

Searches for the sequentially first item in the parallel iterator that matches the given predicate and returns it.

Once a match is found, all attempts to the right of the match will be stopped, while attempts to the left must continue in case an earlier match is found.

Note that not all parallel iterators have a useful order, much like sequential HashMap iteration, so "first" may be nebulous. If you just want the first match that discovered anywhere in the iterator, find_any is a better choice.

Exmaples

use rayon::prelude::*;

let a = [1, 2, 3, 3];

assert_eq!(a.par_iter().find_first(|&&x| x == 3), Some(&3));

assert_eq!(a.par_iter().find_first(|&&x| x == 100), None);

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

Searches for the sequentially last item in the parallel iterator that matches the given predicate and returns it.

Once a match is found, all attempts to the left of the match will be stopped, while attempts to the right must continue in case a later match is found.

Note that not all parallel iterators have a useful order, much like sequential HashMap iteration, so "last" may be nebulous. When the order doesn't actually matter to you, find_any is a better choice.

Examples

use rayon::prelude::*;

let a = [1, 2, 3, 3];

assert_eq!(a.par_iter().find_last(|&&x| x == 3), Some(&3));

assert_eq!(a.par_iter().find_last(|&&x| x == 100), None);

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

Searches for some item in the parallel iterator that matches the given predicate, and if so returns true. Once a match is found, we'll attempt to stop process the rest of the items. Proving that there's no match, returning false, does require visiting every item.

Examples

use rayon::prelude::*;

let a = [0, 12, 3, 4, 0, 23, 0];

let is_valid = a.par_iter().any(|&x| x > 10);

assert!(is_valid);

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

Tests that every item in the parallel iterator matches the given predicate, and if so returns true. If a counter-example is found, we'll attempt to stop processing more items, then return false.

Examples

use rayon::prelude::*;

let a = [0, 12, 3, 4, 0, 23, 0];

let is_valid = a.par_iter().all(|&x| x > 10);

assert!(!is_valid);

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

Creates an iterator over the Some items of this iterator, halting as soon as any None is found.

Examples

use rayon::prelude::*;
use std::sync::atomic::{AtomicUsize, Ordering};

let counter = AtomicUsize::new(0);
let value = (0_i32..2048)
    .into_par_iter()
    .map(|x| {
             counter.fetch_add(1, Ordering::SeqCst);
             if x < 1024 { Some(x) } else { None }
         })
    .while_some()
    .max();

assert!(value < Some(1024));
assert!(counter.load(Ordering::SeqCst) < 2048); // should not have visited every single one

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

Create a fresh collection containing all the element produced by this parallel iterator.

You may prefer to use collect_into_vec(), which allocates more efficiently with precise knowledge of how many elements the iterator contains, and even allows you to reuse an existing vector's backing store rather than allocating a fresh vector.

Examples

use rayon::prelude::*;

let sync_vec: Vec<_> = (0..100).into_iter().collect();

let async_vec: Vec<_> = (0..100).into_par_iter().collect();

assert_eq!(sync_vec, async_vec);

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

Unzips the items of a parallel iterator into a pair of arbitrary ParallelExtend containers.

You may prefer to use unzip_into_vecs(), which allocates more efficiently with precise knowledge of how many elements the iterator contains, and even allows you to reuse existing vectors' backing stores rather than allocating fresh vectors.

Examples

use rayon::prelude::*;

let a = [(0, 1), (1, 2), (2, 3), (3, 4)];

let (left, right): (Vec<_>, Vec<_>) = a.par_iter().cloned().unzip();

assert_eq!(left, [0, 1, 2, 3]);
assert_eq!(right, [1, 2, 3, 4]);

Nested pairs can be unzipped too.

use rayon::prelude::*;

let (values, (squares, cubes)): (Vec<_>, (Vec<_>, Vec<_>)) = (0..4).into_par_iter()
    .map(|i| (i, (i * i, i * i * i)))
    .unzip();

assert_eq!(values, [0, 1, 2, 3]);
assert_eq!(squares, [0, 1, 4, 9]);
assert_eq!(cubes, [0, 1, 8, 27]);

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

Partitions the items of a parallel iterator into a pair of arbitrary ParallelExtend containers. Items for which the predicate returns true go into the first container, and the rest go into the second.

Note: unlike the standard Iterator::partition, this allows distinct collection types for the left and right items. This is more flexible, but may require new type annotations when converting sequential code that used type inferrence assuming the two were the same.

Examples

use rayon::prelude::*;

let (left, right): (Vec<_>, Vec<_>) = (0..8).into_par_iter().partition(|x| x % 2 == 0);

assert_eq!(left, [0, 2, 4, 6]);
assert_eq!(right, [1, 3, 5, 7]);

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

Partitions and maps the items of a parallel iterator into a pair of arbitrary ParallelExtend containers. Either::Left items go into the first container, and Either::Right items go into the second.

Examples

use rayon::prelude::*;
use rayon::iter::Either;

let (left, right): (Vec<_>, Vec<_>) = (0..8).into_par_iter()
    .partition_map(|x| {
        if x % 2 == 0 {
            Either::Left(x * 4)
        } else {
            Either::Right(x * 3)
        }
    });

assert_eq!(left, [0, 8, 16, 24]);
assert_eq!(right, [3, 9, 15, 21]);

Nested Either enums can be split as well.

use rayon::prelude::*;
use rayon::iter::Either::*;

let ((fizzbuzz, fizz), (buzz, other)): ((Vec<_>, Vec<_>), (Vec<_>, Vec<_>)) = (1..20)
    .into_par_iter()
    .partition_map(|x| match (x % 3, x % 5) {
        (0, 0) => Left(Left(x)),
        (0, _) => Left(Right(x)),
        (_, 0) => Right(Left(x)),
        (_, _) => Right(Right(x)),
    });

assert_eq!(fizzbuzz, [15]);
assert_eq!(fizz, [3, 6, 9, 12, 18]);
assert_eq!(buzz, [5, 10]);
assert_eq!(other, [1, 2, 4, 7, 8, 11, 13, 14, 16, 17, 19]);

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

Intersperses clones of an element between items of this iterator.

Examples

use rayon::prelude::*;

let x = vec![1, 2, 3];
let r: Vec<_> = x.into_par_iter().intersperse(-1).collect();

assert_eq!(r, vec![1, -1, 2, -1, 3]);

fn opt_len(&self) -> Option<usize>

Internal method used to define the behavior of this parallel iterator. You should not need to call this directly.

Returns the number of items produced by this iterator, if known statically. This can be used by consumers to trigger special fast paths. Therefore, if Some(_) is returned, this iterator must only use the (indexed) Consumer methods when driving a consumer, such as split_at(). Calling UnindexedConsumer::split_off_left() or other UnindexedConsumer methods -- or returning an inaccurate value -- may result in panics.

This method is currently used to optimize collect for want of true Rust specialization; it may be removed when specialization is stable.

Loading content...

Implementors

impl ParallelIterator for astral::thirdparty::rayon::range::Iter<i128>

type Item = i128

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<i128> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<i128> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl ParallelIterator for astral::thirdparty::rayon::range::Iter<i16>

type Item = i16

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<i16> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<i16> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl ParallelIterator for astral::thirdparty::rayon::range::Iter<i32>

type Item = i32

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<i32> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<i32> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl ParallelIterator for astral::thirdparty::rayon::range::Iter<i64>

type Item = i64

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<i64> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<i64> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl ParallelIterator for astral::thirdparty::rayon::range::Iter<i8>

type Item = i8

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<i8> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<i8> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl ParallelIterator for astral::thirdparty::rayon::range::Iter<isize>

type Item = isize

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<isize> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<isize> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl ParallelIterator for astral::thirdparty::rayon::range::Iter<u128>

type Item = u128

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<u128> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<u128> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl ParallelIterator for astral::thirdparty::rayon::range::Iter<u16>

type Item = u16

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<u16> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<u16> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl ParallelIterator for astral::thirdparty::rayon::range::Iter<u32>

type Item = u32

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<u32> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<u32> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl ParallelIterator for astral::thirdparty::rayon::range::Iter<u64>

type Item = u64

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<u64> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<u64> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl ParallelIterator for astral::thirdparty::rayon::range::Iter<u8>

type Item = u8

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<u8> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<u8> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl ParallelIterator for astral::thirdparty::rayon::range::Iter<usize>

type Item = usize

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<usize> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<usize> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'a, K, V> ParallelIterator for astral::thirdparty::rayon::collections::btree_map::Iter<'a, K, V> where
    K: 'a + Sync + Ord,
    V: 'a + Sync, 

type Item = (&'a K, &'a V)

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<'a, K, V> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<'a, K, V> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'a, K, V> ParallelIterator for astral::thirdparty::rayon::collections::btree_map::IterMut<'a, K, V> where
    K: 'a + Sync + Ord,
    V: 'a + Send, 

type Item = (&'a K, &'a mut V)

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<IterMut<'a, K, V> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<IterMut<'a, K, V> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'a, K, V> ParallelIterator for astral::thirdparty::rayon::collections::hash_map::Iter<'a, K, V> where
    K: 'a + Sync + Eq + Hash,
    V: 'a + Sync, 

type Item = (&'a K, &'a V)

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<'a, K, V> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<'a, K, V> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'a, K, V> ParallelIterator for astral::thirdparty::rayon::collections::hash_map::IterMut<'a, K, V> where
    K: 'a + Sync + Eq + Hash,
    V: 'a + Send, 

type Item = (&'a K, &'a mut V)

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<IterMut<'a, K, V> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<IterMut<'a, K, V> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'a, T> ParallelIterator for astral::thirdparty::rayon::collections::binary_heap::Iter<'a, T> where
    T: 'a + Sync + Ord, 

type Item = &'a T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<'a, T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<'a, T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'a, T> ParallelIterator for astral::thirdparty::rayon::collections::btree_set::Iter<'a, T> where
    T: 'a + Sync + Ord, 

type Item = &'a T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<'a, T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<'a, T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'a, T> ParallelIterator for astral::thirdparty::rayon::collections::hash_set::Iter<'a, T> where
    T: 'a + Sync + Eq + Hash, 

type Item = &'a T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<'a, T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<'a, T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'a, T> ParallelIterator for astral::thirdparty::rayon::collections::linked_list::Iter<'a, T> where
    T: 'a + Sync, 

type Item = &'a T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<'a, T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<'a, T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'a, T> ParallelIterator for astral::thirdparty::rayon::collections::linked_list::IterMut<'a, T> where
    T: 'a + Send, 

type Item = &'a mut T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<IterMut<'a, T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<IterMut<'a, T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'a, T> ParallelIterator for astral::thirdparty::rayon::collections::vec_deque::Iter<'a, T> where
    T: 'a + Sync, 

type Item = &'a T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<'a, T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<'a, T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'a, T> ParallelIterator for astral::thirdparty::rayon::collections::vec_deque::IterMut<'a, T> where
    T: 'a + Send, 

type Item = &'a mut T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<IterMut<'a, T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<IterMut<'a, T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'a, T> ParallelIterator for astral::thirdparty::rayon::option::Iter<'a, T> where
    T: 'a + Sync, 

type Item = &'a T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<'a, T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<'a, T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'a, T> ParallelIterator for astral::thirdparty::rayon::option::IterMut<'a, T> where
    T: 'a + Send, 

type Item = &'a mut T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<IterMut<'a, T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<IterMut<'a, T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'a, T> ParallelIterator for astral::thirdparty::rayon::result::Iter<'a, T> where
    T: 'a + Sync, 

type Item = &'a T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<'a, T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<'a, T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'a, T> ParallelIterator for astral::thirdparty::rayon::result::IterMut<'a, T> where
    T: 'a + Send, 

type Item = &'a mut T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<IterMut<'a, T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<IterMut<'a, T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'a, T, I> ParallelIterator for Cloned<I> where
    I: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send + Sync, 

type Item = T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Cloned<I> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Cloned<I> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'ch> ParallelIterator for Bytes<'ch>

type Item = u8

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Bytes<'ch> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Bytes<'ch> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<'ch> ParallelIterator for CharIndices<'ch>

type Item = (usize, char)

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<CharIndices<'ch> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<CharIndices<'ch> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<'ch> ParallelIterator for Chars<'ch>

type Item = char

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Chars<'ch> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Chars<'ch> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<'ch> ParallelIterator for EncodeUtf16<'ch>

type Item = u16

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<EncodeUtf16<'ch> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<EncodeUtf16<'ch> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<'ch> ParallelIterator for Lines<'ch>

type Item = &'ch str

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Lines<'ch> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Lines<'ch> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<'ch> ParallelIterator for SplitWhitespace<'ch>

type Item = &'ch str

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<SplitWhitespace<'ch> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<SplitWhitespace<'ch> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<'ch, P> ParallelIterator for MatchIndices<'ch, P> where
    P: Pattern, 

type Item = (usize, &'ch str)

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<MatchIndices<'ch, P> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<MatchIndices<'ch, P> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<'ch, P> ParallelIterator for Matches<'ch, P> where
    P: Pattern, 

type Item = &'ch str

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Matches<'ch, P> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Matches<'ch, P> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<'ch, P> ParallelIterator for astral::thirdparty::rayon::str::Split<'ch, P> where
    P: Pattern, 

type Item = &'ch str

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Split<'ch, P> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Split<'ch, P> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<'ch, P> ParallelIterator for SplitTerminator<'ch, P> where
    P: Pattern, 

type Item = &'ch str

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<SplitTerminator<'ch, P> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<SplitTerminator<'ch, P> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<'data, T> ParallelIterator for astral::thirdparty::rayon::slice::Chunks<'data, T> where
    T: 'data + Sync, 

type Item = &'data [T]

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Chunks<'data, T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Chunks<'data, T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'data, T> ParallelIterator for ChunksMut<'data, T> where
    T: 'data + Send, 

type Item = &'data mut [T]

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<ChunksMut<'data, T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<ChunksMut<'data, T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'data, T> ParallelIterator for astral::thirdparty::rayon::slice::Iter<'data, T> where
    T: 'data + Sync, 

type Item = &'data T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Iter<'data, T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Iter<'data, T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'data, T> ParallelIterator for astral::thirdparty::rayon::slice::IterMut<'data, T> where
    T: 'data + Send, 

type Item = &'data mut T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<IterMut<'data, T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<IterMut<'data, T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'data, T> ParallelIterator for Windows<'data, T> where
    T: 'data + Sync, 

type Item = &'data [T]

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Windows<'data, T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Windows<'data, T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<'data, T, P> ParallelIterator for astral::thirdparty::rayon::slice::Split<'data, T, P> where
    P: Fn(&T) -> bool + Sync + Send,
    T: Sync, 

type Item = &'data [T]

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Split<'data, T, P> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Split<'data, T, P> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<'data, T, P> ParallelIterator for SplitMut<'data, T, P> where
    P: Fn(&T) -> bool + Sync + Send,
    T: Send, 

type Item = &'data mut [T]

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<SplitMut<'data, T, P> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<SplitMut<'data, T, P> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<A, B> ParallelIterator for Chain<A, B> where
    A: ParallelIterator,
    B: ParallelIterator<Item = <A as ParallelIterator>::Item>, 

type Item = <A as ParallelIterator>::Item

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Chain<A, B> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Chain<A, B> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<A, B> ParallelIterator for Zip<A, B> where
    A: IndexedParallelIterator,
    B: IndexedParallelIterator, 

type Item = (<A as ParallelIterator>::Item, <B as ParallelIterator>::Item)

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Zip<A, B> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Zip<A, B> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<A, B> ParallelIterator for ZipEq<A, B> where
    A: IndexedParallelIterator,
    B: IndexedParallelIterator, 

type Item = (<A as ParallelIterator>::Item, <B as ParallelIterator>::Item)

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<ZipEq<A, B> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<ZipEq<A, B> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<D, S> ParallelIterator for astral::thirdparty::rayon::iter::Split<D, S> where
    D: Send,
    S: Fn(D) -> (D, Option<D>) + Sync + Send, 

type Item = D

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Split<D, S> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Split<D, S> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<I> ParallelIterator for astral::thirdparty::rayon::iter::Chunks<I> where
    I: IndexedParallelIterator, 

type Item = Vec<<I as ParallelIterator>::Item>

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<Vec<<I as ParallelIterator>::Item>>>::Result where
    C: Consumer<Vec<<I as ParallelIterator>::Item>>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<I> ParallelIterator for Enumerate<I> where
    I: IndexedParallelIterator, 

type Item = (usize, <I as ParallelIterator>::Item)

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Enumerate<I> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Enumerate<I> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<I> ParallelIterator for Intersperse<I> where
    I: ParallelIterator,
    <I as ParallelIterator>::Item: Clone,
    <I as ParallelIterator>::Item: Send, 

type Item = <I as ParallelIterator>::Item

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<I as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<I as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<I> ParallelIterator for MaxLen<I> where
    I: IndexedParallelIterator, 

type Item = <I as ParallelIterator>::Item

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<MaxLen<I> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<MaxLen<I> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<I> ParallelIterator for MinLen<I> where
    I: IndexedParallelIterator, 

type Item = <I as ParallelIterator>::Item

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<MinLen<I> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<MinLen<I> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<I> ParallelIterator for Rev<I> where
    I: IndexedParallelIterator, 

type Item = <I as ParallelIterator>::Item

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Rev<I> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Rev<I> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<I> ParallelIterator for Skip<I> where
    I: IndexedParallelIterator, 

type Item = <I as ParallelIterator>::Item

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Skip<I> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Skip<I> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<I> ParallelIterator for Take<I> where
    I: IndexedParallelIterator, 

type Item = <I as ParallelIterator>::Item

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Take<I> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Take<I> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<I, F> ParallelIterator for Inspect<I, F> where
    F: Fn(&<I as ParallelIterator>::Item) + Sync + Send,
    I: ParallelIterator, 

type Item = <I as ParallelIterator>::Item

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Inspect<I, F> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Inspect<I, F> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<I, F> ParallelIterator for Update<I, F> where
    F: Fn(&mut <I as ParallelIterator>::Item) + Send + Sync,
    I: ParallelIterator, 

type Item = <I as ParallelIterator>::Item

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Update<I, F> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Update<I, F> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<I, F, PI> ParallelIterator for FlatMap<I, F> where
    F: Fn(<I as ParallelIterator>::Item) -> PI + Sync + Send,
    I: ParallelIterator,
    PI: IntoParallelIterator, 

type Item = <PI as IntoParallelIterator>::Item

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<FlatMap<I, F> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<FlatMap<I, F> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<I, F, R> ParallelIterator for Map<I, F> where
    F: Fn(<I as ParallelIterator>::Item) -> R + Sync + Send,
    I: ParallelIterator,
    R: Send, 

type Item = <F as FnOnce(<I as ParallelIterator>::Item)>::Output

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Map<I, F> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Map<I, F> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<I, INIT, T, F, R> ParallelIterator for MapInit<I, INIT, F> where
    F: Fn(&mut T, <I as ParallelIterator>::Item) -> R + Sync + Send,
    I: ParallelIterator,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

type Item = R

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<MapInit<I, INIT, F> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<MapInit<I, INIT, F> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<I, J> ParallelIterator for Interleave<I, J> where
    I: IndexedParallelIterator,
    J: IndexedParallelIterator<Item = <I as ParallelIterator>::Item>, 

type Item = <I as ParallelIterator>::Item

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<I as ParallelIterator>::Item>>::Result where
    C: Consumer<<I as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<I, J> ParallelIterator for InterleaveShortest<I, J> where
    I: IndexedParallelIterator,
    J: IndexedParallelIterator<Item = <I as ParallelIterator>::Item>, 

type Item = <I as ParallelIterator>::Item

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<I as ParallelIterator>::Item>>::Result where
    C: Consumer<<I as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<I, P> ParallelIterator for Filter<I, P> where
    I: ParallelIterator,
    P: Fn(&<I as ParallelIterator>::Item) -> bool + Sync + Send, 

type Item = <I as ParallelIterator>::Item

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Filter<I, P> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Filter<I, P> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<I, P, R> ParallelIterator for FilterMap<I, P> where
    I: ParallelIterator,
    P: Fn(<I as ParallelIterator>::Item) -> Option<R> + Sync + Send,
    R: Send, 

type Item = R

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<FilterMap<I, P> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<FilterMap<I, P> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<I, PI> ParallelIterator for Flatten<I> where
    I: ParallelIterator<Item = PI>,
    PI: IntoParallelIterator + Send, 

type Item = <PI as IntoParallelIterator>::Item

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Flatten<I> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Flatten<I> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<I, T> ParallelIterator for WhileSome<I> where
    I: ParallelIterator<Item = Option<T>>,
    T: Send, 

type Item = T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<WhileSome<I> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<WhileSome<I> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<I, T, F, R> ParallelIterator for MapWith<I, T, F> where
    F: Fn(&mut T, <I as ParallelIterator>::Item) -> R + Sync + Send,
    I: ParallelIterator,
    R: Send,
    T: Send + Clone, 

type Item = R

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<MapWith<I, T, F> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<MapWith<I, T, F> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<Iter> ParallelIterator for IterBridge<Iter> where
    Iter: Send + Iterator,
    <Iter as Iterator>::Item: Send, 

type Item = <Iter as Iterator>::Item

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<IterBridge<Iter> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<IterBridge<Iter> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<K, V> ParallelIterator for astral::thirdparty::rayon::collections::btree_map::IntoIter<K, V> where
    K: Send + Ord,
    V: Send, 

type Item = (K, V)

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<IntoIter<K, V> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<IntoIter<K, V> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<K, V> ParallelIterator for astral::thirdparty::rayon::collections::hash_map::IntoIter<K, V> where
    K: Send + Eq + Hash,
    V: Send, 

type Item = (K, V)

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<IntoIter<K, V> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<IntoIter<K, V> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<L, R> ParallelIterator for Either<L, R> where
    L: ParallelIterator,
    R: ParallelIterator<Item = <L as ParallelIterator>::Item>, 

Either<L, R> is a parallel iterator if both L and R are parallel iterators.

type Item = <L as ParallelIterator>::Item

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Either<L, R> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Either<L, R> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<T> ParallelIterator for astral::thirdparty::rayon::collections::binary_heap::IntoIter<T> where
    T: Send + Ord, 

type Item = T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<IntoIter<T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<IntoIter<T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<T> ParallelIterator for astral::thirdparty::rayon::collections::btree_set::IntoIter<T> where
    T: Send + Ord, 

type Item = T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<IntoIter<T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<IntoIter<T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<T> ParallelIterator for astral::thirdparty::rayon::collections::hash_set::IntoIter<T> where
    T: Send + Eq + Hash, 

type Item = T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<IntoIter<T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<IntoIter<T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<T> ParallelIterator for astral::thirdparty::rayon::collections::linked_list::IntoIter<T> where
    T: Send, 

type Item = T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<IntoIter<T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<IntoIter<T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<T> ParallelIterator for astral::thirdparty::rayon::collections::vec_deque::IntoIter<T> where
    T: Send, 

type Item = T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<IntoIter<T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<IntoIter<T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<T> ParallelIterator for Empty<T> where
    T: Send, 

type Item = T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Empty<T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Empty<T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<T> ParallelIterator for Once<T> where
    T: Send, 

type Item = T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Once<T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Once<T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<T> ParallelIterator for Repeat<T> where
    T: Clone + Send, 

type Item = T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Repeat<T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Repeat<T> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<T> ParallelIterator for RepeatN<T> where
    T: Clone + Send, 

type Item = T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<RepeatN<T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<RepeatN<T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<T> ParallelIterator for astral::thirdparty::rayon::option::IntoIter<T> where
    T: Send, 

type Item = T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<IntoIter<T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<IntoIter<T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<T> ParallelIterator for astral::thirdparty::rayon::result::IntoIter<T> where
    T: Send, 

type Item = T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<IntoIter<T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<IntoIter<T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<T> ParallelIterator for astral::thirdparty::rayon::vec::IntoIter<T> where
    T: Send, 

type Item = T

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<IntoIter<T> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<IntoIter<T> as ParallelIterator>::Item>, 

fn opt_len(&self) -> Option<usize>

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

impl<U, I, F> ParallelIterator for FoldWith<I, U, F> where
    F: Fn(U, <I as ParallelIterator>::Item) -> U + Sync + Send,
    I: ParallelIterator,
    U: Send + Clone, 

type Item = U

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<FoldWith<I, U, F> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<FoldWith<I, U, F> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<U, I, F> ParallelIterator for TryFoldWith<I, U, F> where
    F: Fn(<U as Try>::Ok, <I as ParallelIterator>::Item) -> U + Sync + Send,
    I: ParallelIterator,
    U: Try + Send,
    <U as Try>::Ok: Clone,
    <U as Try>::Ok: Send, 

type Item = U

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<TryFoldWith<I, U, F> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<TryFoldWith<I, U, F> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<U, I, ID, F> ParallelIterator for Fold<I, ID, F> where
    F: Fn(U, <I as ParallelIterator>::Item) -> U + Sync + Send,
    I: ParallelIterator,
    ID: Fn() -> U + Sync + Send,
    U: Send, 

type Item = U

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<Fold<I, ID, F> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<Fold<I, ID, F> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

impl<U, I, ID, F> ParallelIterator for TryFold<I, U, ID, F> where
    F: Fn(<U as Try>::Ok, <I as ParallelIterator>::Item) -> U + Sync + Send,
    I: ParallelIterator,
    ID: Fn() -> <U as Try>::Ok + Sync + Send,
    U: Try + Send, 

type Item = U

fn drive_unindexed<C>(
    self,
    consumer: C
) -> <C as Consumer<<TryFold<I, U, ID, F> as ParallelIterator>::Item>>::Result where
    C: UnindexedConsumer<<TryFold<I, U, ID, F> as ParallelIterator>::Item>, 

fn for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send, 

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone, 

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) + Sync + Send, 

fn try_for_each<OP, R>(self, op: OP) -> R where
    OP: Fn(Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send,
    T: Send + Clone, 

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
    INIT: Fn() -> T + Sync + Send,
    OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = ()> + Send, 

fn count(self) -> usize

fn map<F, R>(self, map_op: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> R + Sync + Send,
    R: Send, 

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    R: Send,
    T: Send + Clone, 

fn map_init<F, INIT, T, R>(
    self,
    init: INIT,
    map_op: F
) -> MapInit<Self, INIT, F> where
    F: Fn(&mut T, Self::Item) -> R + Sync + Send,
    INIT: Fn() -> T + Sync + Send,
    R: Send, 

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<Item = &'a T>,
    T: 'a + Clone + Send, 

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
    OP: Fn(&Self::Item) + Sync + Send, 

fn update<F>(self, update_op: F) -> Update<Self, F> where
    F: Fn(&mut Self::Item) + Sync + Send, 

fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
    P: Fn(Self::Item) -> Option<R> + Sync + Send,
    R: Send, 

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
    F: Fn(Self::Item) -> PI + Sync + Send,
    PI: IntoParallelIterator, 

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoParallelIterator, 

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> Self::Item + Sync + Send,
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, 

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
    ID: Fn() -> T + Sync + Send,
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
    OP: Fn(T, T) -> Self::Item + Sync + Send,
    Self::Item: Try,
    <Self::Item as Try>::Ok == T, 

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    T: Send, 

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
    F: Fn(T, Self::Item) -> T + Sync + Send,
    T: Send + Clone, 

fn try_fold<T, R, ID, F>(
    self,
    identity: ID,
    fold_op: F
) -> TryFold<Self, R, ID, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    ID: Fn() -> T + Sync + Send,
    R: Try<Ok = T> + Send, 

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
    F: Fn(T, Self::Item) -> R + Sync + Send,
    R: Try<Ok = T> + Send,
    T: Clone + Send, 

fn sum<S>(self) -> S where
    S: Send + Sum<Self::Item> + Sum<S>, 

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn min_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

fn max_by<F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering, 

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
    F: Sync + Send + Fn(&Self::Item) -> K,
    K: Ord + Send, 

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
    C: IntoParallelIterator<Item = Self::Item>, 

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn any<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn all<P>(self, predicate: P) -> bool where
    P: Fn(Self::Item) -> bool + Sync + Send, 

fn while_some<T>(self) -> WhileSome<Self> where
    Self: ParallelIterator<Item = Option<T>>,
    T: Send, 

fn collect<C>(self) -> C where
    C: FromParallelIterator<Self::Item>, 

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    A: Send,
    B: Send,
    FromA: Default + Send + ParallelExtend<A>,
    FromB: Default + Send + ParallelExtend<B>,
    Self: ParallelIterator<Item = (A, B)>, 

fn partition<A, B, P>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<Self::Item>,
    B: Default + Send + ParallelExtend<Self::Item>,
    P: Fn(&Self::Item) -> bool + Sync + Send, 

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
    A: Default + Send + ParallelExtend<L>,
    B: Default + Send + ParallelExtend<R>,
    L: Send,
    P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
    R: Send, 

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone, 

fn opt_len(&self) -> Option<usize>

Loading content...