Replace Element::DATA_TYPE with IS_COPY

Author: aldanor

src/array.rs

@@ -15,7 +15,7 @@ use std::{
 use std::{iter::ExactSizeIterator, marker::PhantomData};
 
 use crate::convert::{ArrayExt, IntoPyArray, NpyIndex, ToNpyDims, ToPyArray};
-use crate::dtype::{DataType, Element};
+use crate::dtype::Element;
 use crate::error::{DimensionalityError, FromVecError, NotContiguousError, TypeError};
 use crate::slice_container::PySliceContainer;
 
@@ -852,7 +852,7 @@ impl<T: Element> PyArray<T, Ix1> {
     pub fn from_slice<'py>(py: Python<'py>, slice: &[T]) -> &'py Self {
         unsafe {
             let array = PyArray::new(py, [slice.len()], false);
-            if T::DATA_TYPE != DataType::Object {
+            if T::IS_COPY {
                 array.copy_ptr(slice.as_ptr(), slice.len());
             } else {
                 let data_ptr = array.data();

src/convert.rs

@@ -7,7 +7,7 @@ use std::{mem, os::raw::c_int};
 
 use crate::{
     npyffi::{self, npy_intp},
-    DataType, Element, PyArray,
+    Element, PyArray,
 };
 
 /// Conversion trait from some rust types to `PyArray`.
@@ -123,7 +123,7 @@ where
     fn to_pyarray<'py>(&self, py: Python<'py>) -> &'py PyArray<Self::Item, Self::Dim> {
         let len = self.len();
         match self.order() {
-            Some(order) if A::DATA_TYPE != DataType::Object => {
+            Some(order) if A::IS_COPY => {
                 // if the array is contiguous, copy it by `copy_ptr`.
                 let strides = self.npy_strides();
                 unsafe {

src/dtype.rs

@@ -257,7 +257,7 @@ impl DataType {
 /// pub struct Wrapper(pub Py<CustomElement>);
 ///
 /// unsafe impl Element for Wrapper {
-///     const DATA_TYPE: DataType = DataType::Object;
+///     const IS_COPY: bool = false;
 ///
 ///     fn get_dtype(py: Python) -> &PyArrayDescr {
 ///         PyArrayDescr::object(py)
@@ -273,17 +273,23 @@ impl DataType {
 /// });
 /// ```
 pub unsafe trait Element: Clone + Send {
-    /// `DataType` corresponding to this type.
-    const DATA_TYPE: DataType;
+    /// Flag that indicates whether this type is trivially copyable.
+    ///
+    /// It should be set to true for all trivially copyable types (like scalar types
+    /// and record/array types only containing trivially copyable fields and elements).
+    ///
+    /// This flag should *always* be set to `false` for object types or record types
+    /// that contain object-type fields.
+    const IS_COPY: bool;
 
-    /// Create `dtype`.
+    /// Returns the associated array descriptor ("dtype") for the given type.
     fn get_dtype(py: Python) -> &PyArrayDescr;
 }
 
 macro_rules! impl_num_element {
     ($ty:ty, $data_type:expr) => {
         unsafe impl Element for $ty {
-            const DATA_TYPE: DataType = $data_type;
+            const IS_COPY: bool = true;
 
             fn get_dtype(py: Python) -> &PyArrayDescr {
                 PyArrayDescr::from_npy_type(py, $data_type.into_npy_type())
@@ -315,7 +321,7 @@ cfg_if! {
 }
 
 unsafe impl Element for PyObject {
-    const DATA_TYPE: DataType = DataType::Object;
+    const IS_COPY: bool = false;
 
     fn get_dtype(py: Python) -> &PyArrayDescr {
         PyArrayDescr::object(py)