API: Rename Zip::apply to Zip::for_each and same for par_apply

Rename apply to for_each, par_apply to par_for_each.

Author: bluss

examples/sort-axis.rs

@@ -112,7 +112,7 @@ where
                 let perm_i = perm.indices[i];
                 Zip::from(result.index_axis_mut(axis, perm_i))
                     .and(self.index_axis(axis, i))
-                    .apply(|to, from| {
+                    .for_each(|to, from| {
                         copy_nonoverlapping(from, to.as_mut_ptr(), 1);
                         moved_elements += 1;
                     });

examples/zip_many.rs

@@ -41,11 +41,11 @@ fn main() {
     // Let's imagine we split to parallelize
     {
         let (x, y) = Zip::indexed(&mut a).split();
-        x.apply(|(_, j), elt| {
+        x.for_each(|(_, j), elt| {
             *elt = elt.powi(j as i32);
         });
 
-        y.apply(|(_, j), elt| {
+        y.for_each(|(_, j), elt| {
             *elt = elt.powi(j as i32);
         });
     }

src/impl_methods.rs

@@ -1985,7 +1985,7 @@ where
         let dim = self.raw_dim();
         Zip::from(LanesMut::new(self.view_mut(), Axis(n - 1)))
             .and(Lanes::new(rhs.broadcast_assume(dim), Axis(n - 1)))
-            .apply(move |s_row, r_row| Zip::from(s_row).and(r_row).apply(|a, b| f(a, b)));
+            .for_each(move |s_row, r_row| Zip::from(s_row).and(r_row).for_each(|a, b| f(a, b)));
     }
 
     fn zip_mut_with_elem<B, F>(&mut self, rhs_elem: &B, mut f: F)
@@ -2343,7 +2343,7 @@ where
         prev.slice_axis_inplace(axis, Slice::from(..-1));
         curr.slice_axis_inplace(axis, Slice::from(1..));
         // This implementation relies on `Zip` iterating along `axis` in order.
-        Zip::from(prev).and(curr).apply(|prev, curr| unsafe {
+        Zip::from(prev).and(curr).for_each(|prev, curr| unsafe {
             // These pointer dereferences and borrows are safe because:
             //
             // 1. They're pointers to elements in the array.

src/linalg/impl_linalg.rs

@@ -679,11 +679,11 @@ unsafe fn general_mat_vec_mul_impl<A, S1, S2>(
 
         if beta.is_zero() {
             // when beta is zero, c may be uninitialized
-            Zip::from(a.outer_iter()).and(y).apply(|row, elt| {
+            Zip::from(a.outer_iter()).and(y).for_each(|row, elt| {
                 elt.write(row.dot(x) * alpha);
             });
         } else {
-            Zip::from(a.outer_iter()).and(y).apply(|row, elt| {
+            Zip::from(a.outer_iter()).and(y).for_each(|row, elt| {
                 *elt = *elt * beta + row.dot(x) * alpha;
             });
         }

src/parallel/impl_par_methods.rs

@@ -59,12 +59,25 @@ macro_rules! zip_impl {
                   D: Dimension,
                   $($p: NdProducer<Dim=D> ,)*
         {
+            /// The `par_for_each` method for `Zip`.
+            ///
+            /// This is a shorthand for using `.into_par_iter().for_each()` on
+            /// `Zip`.
+            ///
+            /// Requires crate feature `rayon`.
+            pub fn par_for_each<F>(self, function: F)
+                where F: Fn($($p::Item),*) + Sync + Send
+            {
+                self.into_par_iter().for_each(move |($($p,)*)| function($($p),*))
+            }
+
             /// The `par_apply` method for `Zip`.
             ///
             /// This is a shorthand for using `.into_par_iter().for_each()` on
             /// `Zip`.
             ///
             /// Requires crate feature `rayon`.
+            #[deprecated(note="Renamed to .par_for_each()", since="0.15.0")]
             pub fn par_apply<F>(self, function: F)
                 where F: Fn($($p::Item),*) + Sync + Send
             {
@@ -133,7 +146,7 @@ macro_rules! zip_impl {
                       Q::Output: Send,
             {
                 self.and(into)
-                    .par_apply(move |$($p, )* output_| {
+                    .par_for_each(move |$($p, )* output_| {
                         output_.assign_elem(f($($p ),*));
                     });
             }

src/parallel/zipmacro.rs

@@ -24,7 +24,7 @@
 /// Is equivalent to:
 ///
 /// ```rust,ignore
-/// Zip::from(&mut a).and(&b).and(&c).par_apply(|a, &b, &c| {
+/// Zip::from(&mut a).and(&b).and(&c).par_for_each(|a, &b, &c| {
 ///     *a = b + c;
 /// });
 /// ```
@@ -54,6 +54,6 @@
 /// ```
 macro_rules! par_azip {
     ($($t:tt)*) => {
-        $crate::azip!(@build par_apply $($t)*)
+        $crate::azip!(@build par_for_each $($t)*)
     };
 }

src/zip/mod.rs

@@ -518,7 +518,7 @@ impl<A, D: Dimension> NdProducer for RawArrayViewMut<A, D> {
 /// The order elements are visited is not specified. The producers don’t have to
 /// have the same item type.
 ///
-/// The `Zip` has two methods for function application: `apply` and
+/// The `Zip` has two methods for function application: `for_each` and
 /// `fold_while`. The zip object can be split, which allows parallelization.
 /// A read-only zip object (no mutable producers) can be cloned.
 ///
@@ -546,7 +546,7 @@ impl<A, D: Dimension> NdProducer for RawArrayViewMut<A, D> {
 ///     .and(&b)
 ///     .and(&c)
 ///     .and(&d)
-///     .apply(|w, &x, &y, &z| {
+///     .for_each(|w, &x, &y, &z| {
 ///         *w += x + y * z;
 ///     });
 ///
@@ -563,7 +563,7 @@ impl<A, D: Dimension> NdProducer for RawArrayViewMut<A, D> {
 ///
 /// Zip::from(&mut totals)
 ///     .and(a.rows())
-///     .apply(|totals, row| *totals = row.sum());
+///     .for_each(|totals, row| *totals = row.sum());
 ///
 /// // Check the result against the built in `.sum_axis()` along axis 1.
 /// assert_eq!(totals, a.sum_axis(Axis(1)));
@@ -692,21 +692,21 @@ impl<P, D> Zip<P, D>
 where
     D: Dimension,
 {
-    fn apply_core<F, Acc>(&mut self, acc: Acc, mut function: F) -> FoldWhile<Acc>
+    fn for_each_core<F, Acc>(&mut self, acc: Acc, mut function: F) -> FoldWhile<Acc>
     where
         F: FnMut(Acc, P::Item) -> FoldWhile<Acc>,
         P: ZippableTuple<Dim = D>,
     {
         if self.dimension.ndim() == 0 {
             function(acc, unsafe { self.parts.as_ref(self.parts.as_ptr()) })
         } else if self.layout.is(CORDER | FORDER) {
-            self.apply_core_contiguous(acc, function)
+            self.for_each_core_contiguous(acc, function)
         } else {
-            self.apply_core_strided(acc, function)
+            self.for_each_core_strided(acc, function)
         }
     }
 
-    fn apply_core_contiguous<F, Acc>(&mut self, acc: Acc, mut function: F) -> FoldWhile<Acc>
+    fn for_each_core_contiguous<F, Acc>(&mut self, acc: Acc, mut function: F) -> FoldWhile<Acc>
     where
         F: FnMut(Acc, P::Item) -> FoldWhile<Acc>,
         P: ZippableTuple<Dim = D>,
@@ -744,7 +744,7 @@ where
     }
 
 
-    fn apply_core_strided<F, Acc>(&mut self, acc: Acc, function: F) -> FoldWhile<Acc>
+    fn for_each_core_strided<F, Acc>(&mut self, acc: Acc, function: F) -> FoldWhile<Acc>
     where
         F: FnMut(Acc, P::Item) -> FoldWhile<Acc>,
         P: ZippableTuple<Dim = D>,
@@ -754,14 +754,14 @@ where
             panic!("Unreachable: ndim == 0 is contiguous")
         }
         if n == 1 || self.layout_tendency >= 0 {
-            self.apply_core_strided_c(acc, function)
+            self.for_each_core_strided_c(acc, function)
         } else {
-            self.apply_core_strided_f(acc, function)
+            self.for_each_core_strided_f(acc, function)
         }
     }
 
     // Non-contiguous but preference for C - unroll over Axis(ndim - 1)
-    fn apply_core_strided_c<F, Acc>(&mut self, mut acc: Acc, mut function: F) -> FoldWhile<Acc>
+    fn for_each_core_strided_c<F, Acc>(&mut self, mut acc: Acc, mut function: F) -> FoldWhile<Acc>
     where
         F: FnMut(Acc, P::Item) -> FoldWhile<Acc>,
         P: ZippableTuple<Dim = D>,
@@ -785,7 +785,7 @@ where
     }
 
     // Non-contiguous but preference for F - unroll over Axis(0)
-    fn apply_core_strided_f<F, Acc>(&mut self, mut acc: Acc, mut function: F) -> FoldWhile<Acc>
+    fn for_each_core_strided_f<F, Acc>(&mut self, mut acc: Acc, mut function: F) -> FoldWhile<Acc>
     where
         F: FnMut(Acc, P::Item) -> FoldWhile<Acc>,
         P: ZippableTuple<Dim = D>,
@@ -939,15 +939,24 @@ macro_rules! map_impl {
         {
             /// Apply a function to all elements of the input arrays,
             /// visiting elements in lock step.
-            pub fn apply<F>(mut self, mut function: F)
+            pub fn for_each<F>(mut self, mut function: F)
                 where F: FnMut($($p::Item),*)
             {
-                self.apply_core((), move |(), args| {
+                self.for_each_core((), move |(), args| {
                     let ($($p,)*) = args;
                     FoldWhile::Continue(function($($p),*))
                 });
             }
 
+            /// Apply a function to all elements of the input arrays,
+            /// visiting elements in lock step.
+            #[deprecated(note="Renamed to .for_each()", since="0.15.0")]
+            pub fn apply<F>(self, function: F)
+                where F: FnMut($($p::Item),*)
+            {
+                self.for_each(function)
+            }
+
             /// Apply a fold function to all elements of the input arrays,
             /// visiting elements in lock step.
             ///
@@ -980,7 +989,7 @@ macro_rules! map_impl {
             where
                 F: FnMut(Acc, $($p::Item),*) -> Acc,
             {
-                self.apply_core(acc, move |acc, args| {
+                self.for_each_core(acc, move |acc, args| {
                     let ($($p,)*) = args;
                     FoldWhile::Continue(function(acc, $($p),*))
                 }).into_inner()
@@ -993,7 +1002,7 @@ macro_rules! map_impl {
                 -> FoldWhile<Acc>
                 where F: FnMut(Acc, $($p::Item),*) -> FoldWhile<Acc>
             {
-                self.apply_core(acc, move |acc, args| {
+                self.for_each_core(acc, move |acc, args| {
                     let ($($p,)*) = args;
                     function(acc, $($p),*)
                 })
@@ -1015,7 +1024,7 @@ macro_rules! map_impl {
             pub fn all<F>(mut self, mut predicate: F) -> bool
                 where F: FnMut($($p::Item),*) -> bool
             {
-                !self.apply_core((), move |_, args| {
+                !self.for_each_core((), move |_, args| {
                     let ($($p,)*) = args;
                     if predicate($($p),*) {
                         FoldWhile::Continue(())
@@ -1096,7 +1105,7 @@ macro_rules! map_impl {
                       Q::Item: AssignElem<R>
             {
                 self.and(into)
-                    .apply(move |$($p, )* output_| {
+                    .for_each(move |$($p, )* output_| {
                         output_.assign_elem(f($($p ),*));
                     });
             }
@@ -1150,7 +1159,7 @@ macro_rules! map_impl {
                     // Apply the mapping function on this zip
                     // if we panic with unwinding; Partial will drop the written elements.
                     let partial_len = &mut partial.len;
-                    self.apply(move |$($p,)* output_elem: *mut R| {
+                    self.for_each(move |$($p,)* output_elem: *mut R| {
                         output_elem.write(f($($p),*));
                         if std::mem::needs_drop::<R>() {
                             *partial_len += 1;

src/zip/zipmacro.rs

@@ -12,7 +12,7 @@
 /// Is equivalent to:
 ///
 /// ```rust,ignore
-/// Zip::from(&mut a).and(&b).and(&c).apply(|a, &b, &c| {
+/// Zip::from(&mut a).and(&b).and(&c).for_each(|a, &b, &c| {
 ///     *a = b + c
 /// });
 /// ```
@@ -27,8 +27,8 @@
 ///
 /// The *expr* are expressions whose types must implement `IntoNdProducer`, the
 /// *pat* are the patterns of the parameters to the closure called by
-/// `Zip::apply`, and *body_expr* is the body of the closure called by
-/// `Zip::apply`. You can think of each *pat* `in` *expr* as being analogous to
+/// `Zip::for_each`, and *body_expr* is the body of the closure called by
+/// `Zip::for_each`. You can think of each *pat* `in` *expr* as being analogous to
 /// the `pat in expr` of a normal loop `for pat in expr { statements }`: a
 /// pattern, followed by `in`, followed by an expression that implements
 /// `IntoNdProducer` (analogous to `IntoIterator` for a `for` loop).
@@ -129,6 +129,6 @@ macro_rules! azip {
     // catch-all rule
     (@build $($t:tt)*) => { compile_error!("Invalid syntax in azip!()") };
     ($($t:tt)*) => {
-        $crate::azip!(@build apply $($t)*)
+        $crate::azip!(@build for_each $($t)*)
     };
 }

tests/array-construct.rs

@@ -231,12 +231,12 @@ fn maybe_uninit_1() {
         let mut a = Mat::maybe_uninit((10, 10));
         let v = a.raw_view_mut();
         Zip::from(v)
-            .apply(|ptr| *(*ptr).as_mut_ptr() = 1.);
+            .for_each(|ptr| *(*ptr).as_mut_ptr() = 1.);
 
         let u = a.raw_view_mut().assume_init();
 
         Zip::from(u)
-            .apply(|ptr| assert_eq!(*ptr, 1.));
+            .for_each(|ptr| assert_eq!(*ptr, 1.));
 
     }
 }