Add A: Clone bound to into_shared

Author: jturner314

src/arraytraits.rs

@@ -12,14 +12,12 @@ use std::iter::IntoIterator;
 use std::mem;
 use std::ops::{Index, IndexMut};
 use alloc::boxed::Box;
+use alloc::sync::Arc;
 use alloc::vec::Vec;
 
 use crate::imp_prelude::*;
 use crate::iter::{Iter, IterMut};
-use crate::NdIndex;
-
-use crate::numeric_util;
-use crate::{FoldWhile, Zip};
+use crate::{numeric_util, FoldWhile, NdIndex, OwnedArcRepr, Zip};
 
 #[cold]
 #[inline(never)]
@@ -372,7 +370,9 @@ where
     D: Dimension,
 {
     fn from(arr: Array<A, D>) -> ArcArray<A, D> {
-        arr.into_shared()
+        let data = OwnedArcRepr(Arc::new(arr.data));
+        // safe because: equivalent unmoved data, ptr and dims remain valid
+        unsafe { ArrayBase::from_data_ptr(data, arr.ptr).with_strides_dim(arr.strides, arr.dim) }
     }
 }
 

src/data_traits.rs

@@ -16,7 +16,9 @@ use std::ptr::NonNull;
 use alloc::sync::Arc;
 use alloc::vec::Vec;
 
-use crate::{ArrayBase, CowRepr, Dimension, OwnedArcRepr, OwnedRepr, RawViewRepr, ViewRepr};
+use crate::{
+    ArcArray, ArrayBase, CowRepr, Dimension, OwnedArcRepr, OwnedRepr, RawViewRepr, ViewRepr,
+};
 
 /// Array representation trait.
 ///
@@ -457,9 +459,13 @@ pub unsafe trait DataOwned: Data {
     fn new(elements: Vec<Self::Elem>) -> Self;
 
     /// Converts the data representation to a shared (copy on write)
-    /// representation, without any copying.
+    /// representation, cloning the array elements if necessary.
     #[doc(hidden)]
-    fn into_shared(self) -> OwnedArcRepr<Self::Elem>;
+    #[allow(clippy::wrong_self_convention)]
+    fn into_shared<D>(self_: ArrayBase<Self, D>) -> ArcArray<Self::Elem, D>
+    where
+        Self::Elem: Clone,
+        D: Dimension;
 }
 
 /// Array representation trait.
@@ -479,8 +485,12 @@ unsafe impl<A> DataOwned for OwnedRepr<A> {
         OwnedRepr::from(elements)
     }
 
-    fn into_shared(self) -> OwnedArcRepr<A> {
-        OwnedArcRepr(Arc::new(self))
+    fn into_shared<D>(self_: ArrayBase<Self, D>) -> ArcArray<A, D>
+    where
+        A: Clone,
+        D: Dimension,
+    {
+        ArcArray::from(self_)
     }
 }
 
@@ -491,8 +501,12 @@ unsafe impl<A> DataOwned for OwnedArcRepr<A> {
         OwnedArcRepr(Arc::new(OwnedRepr::from(elements)))
     }
 
-    fn into_shared(self) -> OwnedArcRepr<A> {
-        self
+    fn into_shared<D>(self_: ArrayBase<Self, D>) -> ArcArray<A, D>
+    where
+        A: Clone,
+        D: Dimension,
+    {
+        self_
     }
 }
 

src/impl_methods.rs

@@ -242,16 +242,17 @@ where
     }
 
     /// Turn the array into a shared ownership (copy on write) array,
-    /// without any copying.
+    /// cloning the array elements if necessary.
+    ///
+    /// If you want to generalize over `Array` and `ArcArray` inputs but avoid
+    /// an `A: Clone` bound, use `Into::<ArcArray<A, D>>::into` instead of this
+    /// method.
     pub fn into_shared(self) -> ArcArray<A, D>
     where
+        A: Clone,
         S: DataOwned,
     {
-        let data = self.data.into_shared();
-        // safe because: equivalent unmoved data, ptr and dims remain valid
-        unsafe {
-            ArrayBase::from_data_ptr(data, self.ptr).with_strides_dim(self.strides, self.dim)
-        }
+        S::into_shared(self)
     }
 
     /// Returns a reference to the first element of the array, or `None` if it