Merge rayon-rs#627 rayon-rs#633

627: Add `find_map` with `any`, `first`, and `last` variants r=cuviper a=seanchen1991

PR opened in response to rayon-rs#607. 

633: Update dev and demo dependencies r=cuviper a=cuviper

- `cgmath 0.17`
- `glium 0.23`
- `rand 0.6`

Co-authored-by: Sean <[email protected]>
Co-authored-by: Josh Stone <[email protected]>

Author: 3 people

Cargo.toml

@@ -30,6 +30,7 @@ default-features = false
 [dev-dependencies]
 docopt = "1"
 lazy_static = "1"
-rand = "0.5"
+rand = "0.6"
+rand_xorshift = "0.1"
 serde = "1"
 serde_derive = "1"

rayon-core/Cargo.toml

@@ -28,7 +28,8 @@ version = "0.2.0"
 version = "0.3.0"
 
 [dev-dependencies]
-rand = "0.5"
+rand = "0.6"
+rand_xorshift = "0.1"
 
 [[test]]
 name = "stack_overflow_crash"

rayon-core/src/join/test.rs

@@ -2,7 +2,8 @@
 
 use join::*;
 use rand::distributions::Standard;
-use rand::{Rng, SeedableRng, XorShiftRng};
+use rand::{Rng, SeedableRng};
+use rand_xorshift::XorShiftRng;
 use unwind;
 use ThreadPoolBuilder;
 

rayon-core/src/lib.rs

@@ -40,6 +40,8 @@ extern crate num_cpus;
 
 #[cfg(test)]
 extern crate rand;
+#[cfg(test)]
+extern crate rand_xorshift;
 
 #[macro_use]
 mod log;

rayon-core/src/scope/test.rs

@@ -1,4 +1,5 @@
-use rand::{Rng, SeedableRng, XorShiftRng};
+use rand::{Rng, SeedableRng};
+use rand_xorshift::XorShiftRng;
 use std::cmp;
 use std::iter::once;
 use std::sync::atomic::{AtomicUsize, Ordering};

rayon-demo/Cargo.toml

@@ -6,13 +6,14 @@ publish = false
 
 [dependencies]
 rayon = { path = "../" }
-cgmath = "0.16"
+cgmath = "0.17"
 docopt = "1"
 fixedbitset = "0.1.5"
-glium = "0.21"
+glium = "0.23"
 lazy_static = "1"
 odds = "0.3"
-rand = "0.5"
+rand = "0.6"
+rand_xorshift = "0.1"
 regex = "1"
 serde = "1"
 serde_derive = "1"

rayon-demo/src/main.rs

@@ -48,6 +48,7 @@ extern crate libc; // life
 extern crate num;
 extern crate odds; // sieve
 extern crate rand; // nbody
+extern crate rand_xorshift; // nbody
 extern crate time; // nbody, sieve // factorial
 #[macro_use]
 extern crate lazy_static; // find
@@ -109,8 +110,9 @@ fn main() {
     }
 }
 
-fn seeded_rng() -> rand::XorShiftRng {
-    use rand::{SeedableRng, XorShiftRng};
+fn seeded_rng() -> rand_xorshift::XorShiftRng {
+    use rand::SeedableRng;
+    use rand_xorshift::XorShiftRng;
     let mut seed = <XorShiftRng as SeedableRng>::Seed::default();
     (0..).zip(seed.as_mut()).for_each(|(i, x)| *x = i);
     XorShiftRng::from_seed(seed)

rayon-demo/src/nbody/visualize.rs

@@ -80,7 +80,7 @@ implement_vertex!(Instance, color, world_position);
 pub fn visualize_benchmarks(num_bodies: usize, mut mode: ExecutionMode) {
     let mut events_loop = EventsLoop::new();
     let window = WindowBuilder::new()
-        .with_dimensions(800, 600)
+        .with_dimensions((800, 600).into())
         .with_title("nbody demo".to_string());
     let context = ContextBuilder::new().with_depth_buffer(24);
     let display = Display::new(window, context, &events_loop).unwrap();
@@ -191,7 +191,7 @@ pub fn visualize_benchmarks(num_bodies: usize, mut mode: ExecutionMode) {
         events_loop.poll_events(|event| {
             if let Event::WindowEvent { event, .. } = event {
                 match event {
-                    WindowEvent::Closed => done = true,
+                    WindowEvent::CloseRequested => done = true,
                     WindowEvent::KeyboardInput { input, .. } => {
                         if let ElementState::Pressed = input.state {
                             match input.virtual_keycode {

rayon-demo/src/str_split.rs

@@ -1,14 +1,14 @@
 //! Some microbenchmarks for splitting strings
 
-use rand::Rng;
+use rand::seq::SliceRandom;
 use rayon::prelude::*;
 use test::Bencher;
 
 lazy_static! {
     static ref HAYSTACK: String = {
         let mut rng = ::seeded_rng();
         let mut bytes: Vec<u8> = "abcdefg ".bytes().cycle().take(1_000_000).collect();
-        rng.shuffle(&mut bytes);
+        bytes.shuffle(&mut rng);
         String::from_utf8(bytes).unwrap()
     };
     static ref COUNT: usize = { HAYSTACK.split(' ').count() };

src/iter/mod.rs

@@ -1504,7 +1504,7 @@ pub trait ParallelIterator: Sized + Send {
     /// just want the first match that discovered anywhere in the iterator,
     /// `find_any` is a better choice.
     ///
-    /// # Exmaples
+    /// # Examples
     ///
     /// ```
     /// use rayon::prelude::*;
@@ -1551,6 +1551,99 @@ pub trait ParallelIterator: Sized + Send {
         find_first_last::find_last(self, predicate)
     }
 
+    /// Applies the given predicate to the items in the parallel iterator
+    /// and returns **any** non-None result of the map operation.
+    ///
+    /// Once a non-None value is produced from the map operation, we will
+    /// attempt to stop processing the rest of the items in the iterator
+    /// as soon as possible.
+    ///
+    /// Note that this method only returns **some** item in the parallel
+    /// iterator that is not None from the map predicate. The item returned
+    /// may not be the **first** non-None value produced in the parallel
+    /// sequence, since the entire sequence is mapped over in parallel.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let c = ["lol", "NaN", "5", "5"];
+    ///
+    /// let first_number = c.par_iter().find_map_first(|s| s.parse().ok());
+    ///
+    /// assert_eq!(first_number, Some(5));
+    /// ```
+    fn find_map_any<P, R>(self, predicate: P) -> Option<R>
+    where
+        P: Fn(Self::Item) -> Option<R> + Sync + Send,
+        R: Send,
+    {
+        self.filter_map(predicate).find_any(|_| true)
+    }
+
+    /// Applies the given predicate to the items in the parallel iterator and
+    /// returns the sequentially **first** non-None result of the map operation.
+    ///
+    /// Once a non-None value is produced from the map operation, 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 non-None value discovered anywhere in the iterator,
+    /// `find_map_any` is a better choice.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let c = ["lol", "NaN", "2", "5"];
+    ///
+    /// let first_number = c.par_iter().find_map_first(|s| s.parse().ok());
+    ///
+    /// assert_eq!(first_number, Some(2));
+    /// ```
+    fn find_map_first<P, R>(self, predicate: P) -> Option<R>
+    where
+        P: Fn(Self::Item) -> Option<R> + Sync + Send,
+        R: Send,
+    {
+        self.filter_map(predicate).find_first(|_| true)
+    }
+
+    /// Applies the given predicate to the items in the parallel iterator and
+    /// returns the sequentially **last** non-None result of the map operation.
+    ///
+    /// Once a non-None value is produced from the map operation, 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 "first" may be nebulous. If you
+    /// just want the first non-None value discovered anywhere in the iterator,
+    /// `find_map_any` is a better choice.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let c = ["lol", "NaN", "2", "5"];
+    ///
+    /// let first_number = c.par_iter().find_map_last(|s| s.parse().ok());
+    ///
+    /// assert_eq!(first_number, Some(5));
+    /// ```
+    fn find_map_last<P, R>(self, predicate: P) -> Option<R>
+    where
+        P: Fn(Self::Item) -> Option<R> + Sync + Send,
+        R: Send,
+    {
+        self.filter_map(predicate).find_last(|_| true)
+    }
+
     #[doc(hidden)]
     #[deprecated(note = "parallel `find` does not search in order -- use `find_any`, \\
                          `find_first`, or `find_last`")]