rename AsParallel to ParallelBridge

Author: QuietMisdreavus

rayon-demo/src/life/bench.rs

@@ -12,5 +12,5 @@ fn parallel_generations(b: &mut ::test::Bencher) {
 
 #[bench]
 fn as_parallel_generations(b: &mut ::test::Bencher) {
-    b.iter(|| super::as_parallel_generations(Board::new(200, 200).random(), 100));
+    b.iter(|| super::par_bridge_generations(Board::new(200, 200).random(), 100));
 }

rayon-demo/src/life/mod.rs

@@ -20,7 +20,7 @@ use time;
 
 use docopt::Docopt;
 use rayon::prelude::*;
-use rayon::iter::AsParallel;
+use rayon::iter::ParallelBridge;
 
 #[cfg(test)]
 mod bench;
@@ -94,9 +94,9 @@ impl Board {
         self.next_board(new_brd)
     }
 
-    pub fn as_parallel_next_generation(&self) -> Board {
+    pub fn par_bridge_next_generation(&self) -> Board {
         let new_brd = (0..self.len())
-            .as_parallel()
+            .par_bridge()
             .map(|cell| self.successor_cell(cell))
             .collect();
 
@@ -155,9 +155,9 @@ fn parallel_generations(board: Board, gens: usize) {
     for _ in 0..gens { brd = brd.parallel_next_generation(); }
 }
 
-fn as_parallel_generations(board: Board, gens: usize) {
+fn par_bridge_generations(board: Board, gens: usize) {
     let mut brd = board;
-    for _ in 0..gens { brd = brd.as_parallel_next_generation(); }
+    for _ in 0..gens { brd = brd.par_bridge_next_generation(); }
 }
 
 fn measure(f: fn(Board, usize) -> (), args: &Args) -> u64 {
@@ -184,8 +184,8 @@ pub fn main(args: &[String]) {
         println!("parallel: {:10} ns -> {:.2}x speedup", parallel,
                  serial as f64 / parallel as f64);
 
-        let as_parallel = measure(as_parallel_generations, &args);
-        println!("as_parallel: {:10} ns -> {:.2}x speedup", as_parallel,
-                 serial as f64 / as_parallel as f64);
+        let par_bridge = measure(par_bridge_generations, &args);
+        println!("par_bridge: {:10} ns -> {:.2}x speedup", par_bridge,
+                 serial as f64 / par_bridge as f64);
     }
 }

rayon-demo/src/nbody/bench.rs

@@ -31,8 +31,8 @@ fn nbody_par(b: &mut ::test::Bencher) {
 }
 
 #[bench]
-fn nbody_par_as_parallel(b: &mut ::test::Bencher) {
-    nbody_bench(b, |n| { n.tick_par_as_parallel(); });
+fn nbody_par_bridge(b: &mut ::test::Bencher) {
+    nbody_bench(b, |n| { n.tick_par_bridge(); });
 }
 
 #[bench]

rayon-demo/src/nbody/nbody.rs

@@ -33,7 +33,7 @@ use cgmath::{InnerSpace, Point3, Vector3, Zero};
 use rand::{Rand, Rng};
 use rayon::prelude::*;
 #[cfg(test)]
-use rayon::iter::AsParallel;
+use rayon::iter::ParallelBridge;
 use std::f64::consts::PI;
 
 const INITIAL_VELOCITY: f64 = 8.0; // set to 0.0 to turn off.
@@ -114,7 +114,7 @@ impl NBodyBenchmark {
     }
 
     #[cfg(test)]
-    pub fn tick_par_as_parallel(&mut self) -> &[Body] {
+    pub fn tick_par_bridge(&mut self) -> &[Body] {
         let (in_bodies, out_bodies) = if (self.time & 1) == 0 {
             (&self.bodies.0, &mut self.bodies.1)
         } else {
@@ -125,7 +125,7 @@ impl NBodyBenchmark {
         out_bodies
             .iter_mut()
             .zip(&in_bodies[..])
-            .as_parallel()
+            .par_bridge()
             .for_each(|(out, prev)| {
                 let (vel, vel2) = next_velocity(time, prev, in_bodies);
                 out.velocity = vel;

src/iter/mod.rs

@@ -84,8 +84,8 @@ use self::plumbing::*;
 //   e.g. `find::find()`, are always used **prefixed**, so that they
 //   can be readily distinguished.
 
-mod as_parallel;
-pub use self::as_parallel::{AsParallel, IterParallel};
+mod par_bridge;
+pub use self::par_bridge::{ParallelBridge, IterParallel};
 
 mod find;
 mod find_first_last;

src/iter/as_parallel.rs renamed to src/iter/par_bridge.rs

@@ -12,24 +12,24 @@ use current_num_threads;
 ///
 /// This needs to be distinct from `IntoParallelIterator` because that trait is already implemented
 /// on a few `Iterator`s, like `std::ops::Range`.
-pub trait AsParallel {
+pub trait ParallelBridge {
     /// What is the type of the output `ParallelIterator`?
     type Iter: ParallelIterator<Item = Self::Item>;
 
     /// What is the `Item` of the output `ParallelIterator`?
     type Item: Send;
 
     /// Convert this type to a `ParallelIterator`.
-    fn as_parallel(self) -> Self::Iter;
+    fn par_bridge(self) -> Self::Iter;
 }
 
-impl<T: Iterator + Send> AsParallel for T
+impl<T: Iterator + Send> ParallelBridge for T
     where T::Item: Send
 {
     type Iter = IterParallel<T>;
     type Item = T::Item;
 
-    fn as_parallel(self) -> Self::Iter {
+    fn par_bridge(self) -> Self::Iter {
         IterParallel {
             iter: self,
         }