maybe_rayon/
lib.rs

Help
1#![warn(clippy::all)]
2
3cfg_if::cfg_if! {
4  if #[cfg(any(not(feature = "threads"), all(target_arch="wasm32", not(target_feature = "atomics"))))] {
5    #[derive(Default)]
6    pub struct ThreadPoolBuilder ();
7    impl ThreadPoolBuilder {
8      #[inline(always)]
9      pub fn new() -> ThreadPoolBuilder {
10        ThreadPoolBuilder()
11      }
12
13      #[inline(always)]
14      pub fn build(self) -> Result<ThreadPool, ::core::convert::Infallible> {
15        Ok(ThreadPool())
16      }
17
18      #[inline(always)]
19      pub fn num_threads(self, _num_threads: usize) -> ThreadPoolBuilder {
20        ThreadPoolBuilder()
21      }
22    }
23    #[derive(Debug)]
24    pub struct ThreadPool ();
25    impl ThreadPool {
26      #[inline(always)]
27      pub fn install<OP, R>(&self, op: OP) -> R where
28            OP: FnOnce() -> R + Send,
29                R: Send, {
30        op()
31      }
32    }
33
34    pub mod iter {
35      pub trait IntoParallelIterator {
36          type Iter: Iterator<Item = Self::Item>;
37          type Item: Send;
38
39          fn into_par_iter(self) -> Self::Iter;
40      }
41
42      impl<I: IntoIterator> IntoParallelIterator for I where
43        I::Item : Send {
44        type Item = I::Item;
45        type Iter = I::IntoIter;
46
47        #[inline(always)]
48        fn into_par_iter(self) -> I::IntoIter {
49          self.into_iter()
50        }
51      }
52
53      pub trait IntoParallelRefMutIterator<'data> {
54          type Iter: IntoParallelIterator<Item = Self::Item>;
55          type Item: Send + 'data;
56
57          fn par_iter_mut(&'data mut self) -> Self::Iter;
58      }
59
60      impl<'data, I: 'data + ?Sized> IntoParallelRefMutIterator<'data> for I
61      where
62          &'data mut I: IntoParallelIterator,
63      {
64          type Iter = <&'data mut I as IntoParallelIterator>::Iter;
65          type Item = <&'data mut I as IntoParallelIterator>::Item;
66
67          #[inline(always)]
68          fn par_iter_mut(&'data mut self) -> Self::Iter {
69              self.into_par_iter()
70          }
71      }
72
73      pub trait ParallelIterator: Iterator {
74        #[inline(always)]
75        fn flat_map_iter<U, F>(self, f: F) -> std::iter::FlatMap<Self, U, F>
76        where
77          Self: Sized,
78          U: IntoIterator,
79          F: FnMut(<Self as Iterator>::Item) -> U,
80        {
81          self.flat_map(f)
82        }
83      }
84
85      impl<I: Iterator> ParallelIterator for I {}
86    }
87    pub mod slice {
88      pub trait ParallelSlice<T: Sync> {
89        fn par_chunks_exact(
90          &self, chunk_size: usize,
91        ) -> std::slice::ChunksExact<'_, T>;
92      }
93
94      impl<T: Sync> ParallelSlice<T> for [T] {
95        #[inline(always)]
96        fn par_chunks_exact(
97          &self, chunk_size: usize,
98        ) -> std::slice::ChunksExact<'_, T> {
99          self.chunks_exact(chunk_size)
100        }
101      }
102    }
103
104    pub mod prelude {
105      pub use super::iter::*;
106      pub use super::slice::*;
107    }
108
109    #[inline(always)]
110    pub fn join<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
111    where
112      A: FnOnce() -> RA + Send,
113      B: FnOnce() -> RB + Send,
114      RA: Send,
115      RB: Send {
116      (oper_a(), oper_b())
117    }
118
119    use std::marker::PhantomData;
120
121    pub struct Scope<'scope>{
122      #[allow(clippy::type_complexity)]
123      marker: PhantomData<Box<dyn FnOnce(&Scope<'scope>) + Send + Sync + 'scope>>,
124    }
125
126    impl<'scope> Scope<'scope> {
127      #[inline(always)]
128      pub fn spawn<BODY>(&self, body: BODY)
129        where BODY: FnOnce(&Scope<'scope>) + Send + 'scope
130      {
131        body(self)
132      }
133    }
134
135    #[inline(always)]
136    pub fn scope<'scope, OP, R>(op: OP) -> R
137      where OP: for<'s> FnOnce(&'s Scope<'scope>) -> R + 'scope + Send, R: Send,
138    {
139      op(&Scope { marker: PhantomData })
140    }
141  } else {
142    pub use rayon::*;
143  }
144}
maybe_rayon/lib.rs

maybe_rayon/
lib.rs
