API: Rename apply_collect, apply_collect_into to map_collect, map_collect_into

Author: bluss

src/parallel/impl_par_methods.rs

@@ -86,11 +86,11 @@ macro_rules! zip_impl {
 
             expand_if!(@bool [$notlast]
 
-            /// Apply and collect the results into a new array, which has the same size as the
+            /// 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.
-            pub fn par_apply_collect<R>(self, f: impl Fn($($p::Item,)* ) -> R + Sync + Send)
+            pub fn par_map_collect<R>(self, f: impl Fn($($p::Item,)* ) -> R + Sync + Send)
                 -> Array<R, D>
                 where R: Send
             {
@@ -135,12 +135,24 @@ macro_rules! zip_impl {
                 }
             }
 
-            /// Apply and assign the results into the producer `into`, which should have the same
+            /// 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.
             ///
             /// The producer should have assignable items as dictated by the `AssignElem` trait,
             /// for example `&mut R`.
-            pub fn par_apply_assign_into<R, Q>(self, into: Q, f: impl Fn($($p::Item,)* ) -> R + Sync + Send)
+            pub fn par_map_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,
@@ -150,6 +162,21 @@ macro_rules! zip_impl {
                         output_.assign_elem(f($($p ),*));
                     });
             }
+
+            /// 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)
+            }
+
             );
         }
         )+

src/traversal_utils.rs

@@ -21,6 +21,6 @@ pub(crate) fn assign_to<'a, P1, P2, A>(from: P1, to: P2)
           A: Clone + 'a
 {
     Zip::from(from)
-        .apply_assign_into(to, A::clone);
+        .map_assign_into(to, A::clone);
 }
 

src/zip/mod.rs

@@ -1074,12 +1074,11 @@ macro_rules! map_impl {
                 }
             }
 
-            /// Apply and collect the results into a new array, which has the same size as the
+            /// 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.
-            pub fn apply_collect<R>(self, f: impl FnMut($($p::Item,)* ) -> R) -> Array<R, D>
-            {
+            pub fn map_collect<R>(self, f: impl FnMut($($p::Item,)* ) -> R) -> Array<R, D> {
                 // Make uninit result
                 let mut output = self.uninitalized_for_current_layout::<R>();
 
@@ -1095,12 +1094,21 @@ macro_rules! map_impl {
                 }
             }
 
-            /// Apply and assign the results into the producer `into`, which should have the same
+            /// 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.
             ///
             /// The producer should have assignable items as dictated by the `AssignElem` trait,
             /// for example `&mut R`.
-            pub fn apply_assign_into<R, Q>(self, into: Q, mut f: impl FnMut($($p::Item,)* ) -> R)
+            pub fn map_assign_into<R, Q>(self, into: Q, mut f: impl FnMut($($p::Item,)* ) -> R)
                 where Q: IntoNdProducer<Dim=D>,
                       Q::Item: AssignElem<R>
             {
@@ -1110,6 +1118,19 @@ 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)
+            }
+
 
             );
 

tests/azip.rs

@@ -54,13 +54,13 @@ fn test_azip2_3() {
 fn test_zip_collect() {
     use approx::assert_abs_diff_eq;
 
-    // test Zip::apply_collect and that it preserves c/f layout.
+    // test Zip::map_collect and that it preserves c/f layout.
 
     let b = Array::from_shape_fn((5, 10), |(i, j)| 1. / (i + 2 * j + 1) as f32);
     let c = Array::from_shape_fn((5, 10), |(i, j)| f32::exp((i + j) as f32));
 
     {
-        let a = Zip::from(&b).and(&c).apply_collect(|x, y| x + y);
+        let a = Zip::from(&b).and(&c).map_collect(|x, y| x + y);
 
         assert_abs_diff_eq!(a, &b + &c, epsilon = 1e-6);
         assert_eq!(a.strides(), b.strides());
@@ -70,7 +70,7 @@ fn test_zip_collect() {
         let b = b.t();
         let c = c.t();
 
-        let a = Zip::from(&b).and(&c).apply_collect(|x, y| x + y);
+        let a = Zip::from(&b).and(&c).map_collect(|x, y| x + y);
 
         assert_abs_diff_eq!(a, &b + &c, epsilon = 1e-6);
         assert_eq!(a.strides(), b.strides());
@@ -86,7 +86,7 @@ fn test_zip_assign_into() {
     let b = Array::from_shape_fn((5, 10), |(i, j)| 1. / (i + 2 * j + 1) as f32);
     let c = Array::from_shape_fn((5, 10), |(i, j)| f32::exp((i + j) as f32));
 
-    Zip::from(&b).and(&c).apply_assign_into(&mut a, |x, y| x + y);
+    Zip::from(&b).and(&c).map_assign_into(&mut a, |x, y| x + y);
 
     assert_abs_diff_eq!(a, &b + &c, epsilon = 1e-6);
 }
@@ -101,7 +101,7 @@ fn test_zip_assign_into_cell() {
     let b = Array::from_shape_fn((5, 10), |(i, j)| 1. / (i + 2 * j + 1) as f32);
     let c = Array::from_shape_fn((5, 10), |(i, j)| f32::exp((i + j) as f32));
 
-    Zip::from(&b).and(&c).apply_assign_into(&a, |x, y| x + y);
+    Zip::from(&b).and(&c).map_assign_into(&a, |x, y| x + y);
     let a2 = a.mapv(|elt| elt.get());
 
     assert_abs_diff_eq!(a2, &b + &c, epsilon = 1e-6);
@@ -154,7 +154,7 @@ fn test_zip_collect_drop() {
         }
 
         let _result = panic::catch_unwind(panic::AssertUnwindSafe(|| {
-            Zip::from(&a).and(&b).apply_collect(|&elt, _| {
+            Zip::from(&a).and(&b).map_collect(|&elt, _| {
                 if elt.0 > 3 && will_panic {
                     panic!();
                 }
@@ -308,7 +308,7 @@ fn test_indices_0() {
     let a1 = arr0(3);
 
     let mut count = 0;
-    Zip::indexed(&a1).apply(|i, elt| {
+    Zip::indexed(&a1).for_each(|i, elt| {
         count += 1;
         assert_eq!(i, ());
         assert_eq!(*elt, 3);

tests/par_zip.rs

@@ -82,7 +82,7 @@ fn test_zip_collect() {
     let c = Array::from_shape_fn((M, N), |(i, j)| f32::ln((1 + i + j) as f32));
 
     {
-        let a = Zip::from(&b).and(&c).par_apply_collect(|x, y| x + y);
+        let a = Zip::from(&b).and(&c).par_map_collect(|x, y| x + y);
 
         assert_abs_diff_eq!(a, &b + &c, epsilon = 1e-6);
         assert_eq!(a.strides(), b.strides());
@@ -92,7 +92,7 @@ fn test_zip_collect() {
         let b = b.t();
         let c = c.t();
 
-        let a = Zip::from(&b).and(&c).par_apply_collect(|x, y| x + y);
+        let a = Zip::from(&b).and(&c).par_map_collect(|x, y| x + y);
 
         assert_abs_diff_eq!(a, &b + &c, epsilon = 1e-6);
         assert_eq!(a.strides(), b.strides());
@@ -112,7 +112,7 @@ fn test_zip_small_collect() {
             let c = Array::from_shape_fn(dim, |(i, j)| f32::ln((1 + i + j) as f32));
 
             {
-                let a = Zip::from(&b).and(&c).par_apply_collect(|x, y| x + y);
+                let a = Zip::from(&b).and(&c).par_map_collect(|x, y| x + y);
 
                 assert_abs_diff_eq!(a, &b + &c, epsilon = 1e-6);
                 assert_eq!(a.strides(), b.strides());
@@ -130,7 +130,7 @@ fn test_zip_assign_into() {
     let b = Array::from_shape_fn((M, N), |(i, j)| 1. / (i + 2 * j + 1) as f32);
     let c = Array::from_shape_fn((M, N), |(i, j)| f32::ln((1 + i + j) as f32));
 
-    Zip::from(&b).and(&c).par_apply_assign_into(&mut a, |x, y| x + y);
+    Zip::from(&b).and(&c).par_map_assign_into(&mut a, |x, y| x + y);
 
     assert_abs_diff_eq!(a, &b + &c, epsilon = 1e-6);
 }

tests/views.rs

@@ -10,7 +10,7 @@ fn cell_view() {
         let cv1 = a.cell_view();
         let cv2 = cv1;
 
-        Zip::from(cv1).and(cv2).apply(|a, b| a.set(b.get() + 1.));
+        Zip::from(cv1).and(cv2).for_each(|a, b| a.set(b.get() + 1.));
     }
     assert_eq!(a, answer);
 }