orx-parallel 4.0.0

Performant parallel computations with an expressive iterator API.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

use crate::Par;
use crate::infallible::{ParIter, XapEnumByInput};
use orx_concurrent_iter::{ConcurrentIter, enumerate::Enumerate};

/// Adds index-value pairs to infallible parallel iterators.
///
/// This is the parallel counterpart of [`Iterator::enumerate`](core::iter::Iterator::enumerate).
///
/// # Example
///
/// ```
/// use orx_parallel::*;
///
/// let pairs: Vec<_> = (10..15)
///     .into_par()
///     .enumerate()
///     .collect();
///
/// assert_eq!(pairs.len(), 5);
/// assert!(pairs.contains(&(0, 10)));
/// assert!(pairs.contains(&(4, 14)));
/// ```
pub trait EnumeratePar: Par {
    /// Transforms each item into `(index, item)`.
    ///
    /// Indices are zero-based and correspond to the iterator order.
    ///
    /// # Example
    ///
    /// ```
    /// use orx_parallel::*;
    ///
    /// let idx_sum: usize = (1..6)
    ///     .into_par()
    ///     .enumerate()
    ///     .map(|(i, _)| i)
    ///     .sum();
    ///
    /// assert_eq!(idx_sum, 10);
    /// ```
    fn enumerate(self) -> impl Par<Item = (usize, Self::Item), Input = Enumerate<Self::Input>>;
}

impl<P> EnumeratePar for P
where
    P: Par,
    P::Xap: XapEnumByInput,
{
    fn enumerate(self) -> impl Par<Item = (usize, Self::Item), Input = Enumerate<Self::Input>>
    where
        Self::Xap: XapEnumByInput,
    {
        let (iter, xap, exe, params) = self.destruct();
        let iter = iter.enumerate();
        let xap = xap.enumerate();
        ParIter::new(iter, xap, exe, params)
    }
}