Remove deprecated Zip apply methods

- apply -> for_each
- apply_collect -> map_collect
- apply_assign_into -> map_assign_into
- par_apply -> par_for_each
- par_apply_collect -> par_map_collect
- par_apply_assign_into -> par_map_assign_into

Author: bluss

src/parallel/impl_par_methods.rs

@@ -70,19 +70,6 @@ macro_rules! zip_impl {
                 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
-            {
-                self.into_par_iter().for_each(move |($($p,)*)| function($($p),*))
-            }
-
             expand_if!(@bool [$notlast]
 
             /// Map and collect the results into a new array, which has the same size as the
@@ -134,18 +121,6 @@ macro_rules! zip_impl {
                 }
             }
 
-            /// Map and collect the results into a new array, which has the same size as the
-            /// inputs.
-            ///
-            /// If all inputs are c- or f-order respectively, that is preserved in the output.
-            #[deprecated(note="Renamed to .par_map_collect()", since="0.15.0")]
-            pub fn par_apply_collect<R>(self, f: impl Fn($($p::Item,)* ) -> R + Sync + Send)
-                -> Array<R, D>
-                where R: Send
-            {
-                self.par_map_collect(f)
-            }
-
             /// Map and assign the results into the producer `into`, which should have the same
             /// size as the other inputs.
             ///
@@ -162,20 +137,6 @@ macro_rules! zip_impl {
                     });
             }
 
-            /// Apply and assign the results into the producer `into`, which should have the same
-            /// size as the other inputs.
-            ///
-            /// The producer should have assignable items as dictated by the `AssignElem` trait,
-            /// for example `&mut R`.
-            #[deprecated(note="Renamed to .par_map_assign_into()", since="0.15.0")]
-            pub fn par_apply_assign_into<R, Q>(self, into: Q, f: impl Fn($($p::Item,)* ) -> R + Sync + Send)
-                where Q: IntoNdProducer<Dim=D>,
-                      Q::Item: AssignElem<R> + Send,
-                      Q::Output: Send,
-            {
-                self.par_map_assign_into(into, f)
-            }
-
             /// Parallel version of `fold`.
             ///
             /// Splits the producer in multiple tasks which each accumulate a single value

src/zip/mod.rs

@@ -586,15 +586,6 @@ macro_rules! map_impl {
                 });
             }
 
-            /// 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.
             ///
@@ -791,15 +782,6 @@ macro_rules! map_impl {
                 }
             }
 
-            /// Map and collect the results into a new array, which has the same size as the
-            /// inputs.
-            ///
-            /// If all inputs are c- or f-order respectively, that is preserved in the output.
-            #[deprecated(note="Renamed to .map_collect()", since="0.15.0")]
-            pub fn apply_collect<R>(self, f: impl FnMut($($p::Item,)* ) -> R) -> Array<R, D> {
-                self.map_collect(f)
-            }
-
             /// Map and assign the results into the producer `into`, which should have the same
             /// size as the other inputs.
             ///
@@ -815,20 +797,6 @@ macro_rules! map_impl {
                     });
             }
 
-            /// Map and assign the results into the producer `into`, which should have the same
-            /// size as the other inputs.
-            ///
-            /// The producer should have assignable items as dictated by the `AssignElem` trait,
-            /// for example `&mut R`.
-            #[deprecated(note="Renamed to .map_assign_into()", since="0.15.0")]
-            pub fn apply_assign_into<R, Q>(self, into: Q, f: impl FnMut($($p::Item,)* ) -> R)
-                where Q: IntoNdProducer<Dim=D>,
-                      Q::Item: AssignElem<R>
-            {
-                self.map_assign_into(into, f)
-            }
-
-
             );
 
             /// Split the `Zip` evenly in two.