fn position_first<O>(self, operation: O) -> Position<Self, O>
    where
        O: Fn(Self::Item) -> bool + Clone + Send + 'a,
    {
        Position::new(self, operation, FindMatch::First)
    }
/// Searches for the sequentially **first** item in the parallel iterator
/// that matches the given operation, and returns its index.
///
/// Like `ParallelIterator::find_first`, 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,
/// `position_any` is a better choice.
///
/// # Examples
///
/// ```
/// use asparit::*;
///
/// let a = [1, 2, 3, 3];
///
/// assert_eq!(a.par_iter().position_first(|&x| x == 3).exec(), Some(2));
///
/// assert_eq!(a.par_iter().position_first(|&x| x == 100).exec(), None);
/// ```
Searches for the sequentially **first** item in the parallel iterator
that matches the given operation, and returns its index.

Like `ParallelIterator::find_first`, 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,
`position_any` is a better choice.
Searches for the sequentially ** first ** item in the parallel iterator that matches the given operation and returns its index . Like ` ParallelIterator :: find_first ` 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 ` position_any ` is a better choice .
fn position_first<O>(self, operation: O) -> Position<Self, O>
    where
        O: Fn(Self::Item) -> bool + Clone + Send + 'a,
    {
        Position::new(self, operation, FindMatch::First)
    }
fn position_first < O > ( self , operation : O ) -> Position < Self , O > where O : Fn ( Self :: Item ) -> bool + Clone + Send + ' a , { Position :: new ( self , operation , FindMatch :: First ) }
Searches for the sequentially **first** item in the parallel iterator
that matches the given operation, and returns its index.
Searches for the sequentially ** first ** item in the parallel iterator that matches the given operation and returns its index .
self
operation
O
self
operation
O
examples
None