From 06dc8da359d7ca33b2d6c38c7eb4c883b13d7a14 Mon Sep 17 00:00:00 2001
From: Benjamin Kay <benjamin@benkay.net>
Date: Wed, 3 May 2023 12:15:03 -0500
Subject: [PATCH] Make mapv_into_any() work for ArcArray, resolves #1280

---
 src/impl_methods.rs | 25 ++++++++++++++++++-------
 tests/array.rs      | 22 ++++++++++++++++++++--
 2 files changed, 38 insertions(+), 9 deletions(-)

diff --git a/src/impl_methods.rs b/src/impl_methods.rs
index 115cd2d71..c51bebe44 100644
--- a/src/impl_methods.rs
+++ b/src/impl_methods.rs
@@ -2586,15 +2586,27 @@ where
     /// map is performed as in [`mapv`].
     ///
     /// Elements are visited in arbitrary order.
-    ///
+    /// 
+    /// Note that the compiler will need some hint about the return type, which
+    /// is generic over [`DataOwned`], and can thus be an [`Array`] or
+    /// [`ArcArray`]. Example:
+    /// 
+    /// ```rust
+    /// # use ndarray::{array, Array};
+    /// let a = array![[1., 2., 3.]];
+    /// let a_plus_one: Array<_, _> = a.mapv_into_any(|a| a + 1.);
+    /// ```
+    /// 
     /// [`mapv_into`]: ArrayBase::mapv_into
     /// [`mapv`]: ArrayBase::mapv
-    pub fn mapv_into_any<B, F>(self, mut f: F) -> Array<B, D>
+    pub fn mapv_into_any<B, F, T>(self, mut f: F) -> ArrayBase<T, D>
     where
         S: DataMut,
         F: FnMut(A) -> B,
         A: Clone + 'static,
         B: 'static,
+        T: DataOwned<Elem = B>,
+        ArrayBase<T, D>: From<Array<B, D>>,
     {
         if core::any::TypeId::of::<A>() == core::any::TypeId::of::<B>() {
             // A and B are the same type.
@@ -2605,15 +2617,14 @@ where
                 unsafe { unlimited_transmute::<B, A>(b) }
             };
             // Delegate to mapv_into() using the wrapped closure.
-            // Convert output to a uniquely owned array of type Array<A, D>.
-            let output = self.mapv_into(f).into_owned();
-            // Change the return type from Array<A, D> to Array<B, D>.
+            let output = self.mapv_into(f);
+            // Change the return type of the data from A to B.
             // Again, safe because A and B are the same type.
-            unsafe { unlimited_transmute::<Array<A, D>, Array<B, D>>(output) }
+            unsafe { unlimited_transmute::<ArrayBase<S, D>, ArrayBase<T, D>>(output) }
         } else {
             // A and B are not the same type.
             // Fallback to mapv().
-            self.mapv(f)
+            self.mapv(f).into()
         }
     }
 
diff --git a/tests/array.rs b/tests/array.rs
index e3922ea8d..ec7f374ae 100644
--- a/tests/array.rs
+++ b/tests/array.rs
@@ -995,14 +995,32 @@ fn map1() {
 fn mapv_into_any_same_type() {
     let a: Array<f64, _> = array![[1., 2., 3.], [4., 5., 6.]];
     let a_plus_one: Array<f64, _> = array![[2., 3., 4.], [5., 6., 7.]];
-    assert_eq!(a.mapv_into_any(|a| a + 1.), a_plus_one);
+    let b: Array<_, _> = a.mapv_into_any(|a| a + 1.);
+    assert_eq!(b, a_plus_one);
 }
 
 #[test]
 fn mapv_into_any_diff_types() {
     let a: Array<f64, _> = array![[1., 2., 3.], [4., 5., 6.]];
     let a_even: Array<bool, _> = array![[false, true, false], [true, false, true]];
-    assert_eq!(a.mapv_into_any(|a| a.round() as i32 % 2 == 0), a_even);
+    let b: Array<_, _> = a.mapv_into_any(|a| a.round() as i32 % 2 == 0);
+    assert_eq!(b, a_even);
+}
+
+#[test]
+fn mapv_into_any_arcarray_same_type() {
+    let a: ArcArray<f64, _> = array![[1., 2., 3.], [4., 5., 6.]].into_shared();
+    let a_plus_one: Array<f64, _> = array![[2., 3., 4.], [5., 6., 7.]];
+    let b: ArcArray<_, _> = a.mapv_into(|a| a + 1.);
+    assert_eq!(b, a_plus_one);
+}
+
+#[test]
+fn mapv_into_any_arcarray_diff_types() {
+    let a: ArcArray<f64, _> = array![[1., 2., 3.], [4., 5., 6.]].into_shared();
+    let a_even: Array<bool, _> = array![[false, true, false], [true, false, true]];
+    let b: ArcArray<_, _> = a.mapv_into_any(|a| a.round() as i32 % 2 == 0);
+    assert_eq!(b, a_even);
 }
 
 #[test]