maybe_rayon/
concurrent.rs

1pub mod prelude {
2    pub use rayon::iter::{IndexedParallelIterator, ParallelIterator};
3    use rayon::prelude::*;
4
5    pub trait MaybeParallelIterator: ParallelIterator {}
6
7    pub trait MaybeIndexedParallelIterator: IndexedParallelIterator {}
8
9    pub trait IntoMaybeParallelIterator: IntoParallelIterator + Sized {
10        fn into_maybe_par_iter(self) -> Self::Iter {
11            self.into_par_iter()
12        }
13    }
14
15    pub trait IntoMaybeParallelRefMutIterator<'data>: IntoParallelRefMutIterator<'data> {
16        fn maybe_par_iter_mut(&'data mut self) -> Self::Iter {
17            self.par_iter_mut()
18        }
19    }
20
21    pub type MaybeIterBridge<I> = rayon::iter::IterBridge<I>;
22
23    pub trait MaybeParallelBridge: ParallelBridge {
24        fn maybe_par_bridge(self) -> MaybeIterBridge<Self> {
25            self.par_bridge()
26        }
27    }
28
29    pub trait MaybeParallelSliceMut<T: Send>: ParallelSliceMut<T> {
30        fn maybe_par_chunks_mut<'data>(
31            &'data mut self,
32            chunk_size: usize,
33        ) -> impl MaybeIndexedParallelIterator<Item = &'data mut [T]>
34        where
35            T: 'data,
36        {
37            self.par_chunks_mut(chunk_size)
38        }
39    }
40
41    // Implementations
42
43    impl<I: ParallelIterator> MaybeParallelIterator for I {}
44
45    impl<I: IndexedParallelIterator> MaybeIndexedParallelIterator for I {}
46
47    impl<I: IntoParallelIterator> IntoMaybeParallelIterator for I {}
48
49    impl<'data, I: 'data + ?Sized> IntoMaybeParallelRefMutIterator<'data> for I where
50        &'data mut I: IntoMaybeParallelIterator
51    {
52    }
53
54    impl<I: ParallelBridge> MaybeParallelBridge for I {}
55
56    impl<T: Send> MaybeParallelSliceMut<T> for [T] {}
57}
58
59pub fn join<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
60where
61    A: FnOnce() -> RA + Send,
62    B: FnOnce() -> RB + Send,
63    RA: Send,
64    RB: Send,
65{
66    rayon::join(oper_a, oper_b)
67}
68
69pub type Scope<'scope> = rayon::Scope<'scope>;
70
71pub fn scope<'scope, OP, R>(op: OP) -> R
72where
73    OP: FnOnce(&Scope<'scope>) -> R + Send,
74    R: Send,
75{
76    rayon::scope(op)
77}
78
79pub fn in_place_scope<'scope, OP, R>(op: OP) -> R
80where
81    OP: FnOnce(&Scope<'scope>) -> R,
82{
83    rayon::in_place_scope(op)
84}
85
86pub fn empty<T: Send>() -> rayon::iter::Empty<T> {
87    rayon::iter::empty()
88}
maybe_rayon/concurrent.rs

maybe_rayon/
concurrent.rs
