FEAT: Add method Zip::apply_collect to collect results into Array

Use Array::maybe_uniit to not need to zero result elements; Restrict
to Copy, because we don't implement correct drop on panic yet.

Author: bluss

src/zip/mod.rs

@@ -982,6 +982,29 @@ macro_rules! map_impl {
                     dimension: self.dimension,
                 }
             }
+
+            /// Apply 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.
+            ///
+            /// Restricted to functions that produce copyable results for technical reasons; other
+            /// cases are not yet implemented.
+            pub fn apply_collect<R>(self, mut f: impl FnMut($($p::Item,)* ) -> R) -> Array<R, D>
+                where R: Copy,
+            {
+                unsafe {
+                    let is_c = self.layout.is(CORDER);
+                    let is_f = !is_c && self.layout.is(FORDER);
+                    let mut output = Array::maybe_uninit(self.dimension.clone().set_f(is_f));
+                    self.and(&mut output)
+                        .apply(move |$($p, )* output_| {
+                            std::ptr::write(output_.as_mut_ptr(), f($($p ),*));
+                        });
+                    output.assume_init()
+                }
+            }
+
             );
 
             /// Split the `Zip` evenly in two.

tests/azip.rs

@@ -49,6 +49,34 @@ fn test_azip2_3() {
     assert!(a != b);
 }
 
+#[test]
+#[cfg(feature = "approx")]
+fn test_zip_collect() {
+    use approx::assert_abs_diff_eq;
+
+    // test Zip::apply_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);
+
+        assert_abs_diff_eq!(a, &b + &c, epsilon = 1e-6);
+        assert_eq!(a.strides(), b.strides());
+    }
+
+    {
+        let b = b.t();
+        let c = c.t();
+
+        let a = Zip::from(&b).and(&c).apply_collect(|x, y| x + y);
+
+        assert_abs_diff_eq!(a, &b + &c, epsilon = 1e-6);
+        assert_eq!(a.strides(), b.strides());
+    }
+}
+
 #[test]
 fn test_azip_syntax_trailing_comma() {
     let mut b = Array::<i32, _>::zeros((5, 5));