FEAT: Rename maybe_uninit to Array::uninit and move to base type

Old type situation: `Array<MaybeUninit<i32>, D>::maybe_uninit()`

New type situation: `Array<i32, D>::uninit()`

The link between the regular array storage type and the maybeuninit
version of it is made explicit in the DataOwned trait and this makes
it much easier to work with this constructor in generic code.

The new name is "uninit", just like many types in std (likej
`Box::uninit`).

The old name is deprecated. Because of the unfortunate generics
situation of the old name, the implementation is a copy & paste (short
allegory - inside ArrayBase::uninit we have types S and S::MaybeUninit
"available" as known type, inside ArrayBase::maybe_uninit we only have a
`DataOwned<Elem = MaybeUninit<_>>` type "avaialable" and no way to find the
corresponding "plain" storage type.)

Author: bluss

benches/bench1.rs

@@ -271,7 +271,7 @@ fn add_2d_alloc_zip_uninit(bench: &mut test::Bencher) {
     let a = Array::<i32, _>::zeros((ADD2DSZ, ADD2DSZ));
     let b = Array::<i32, _>::zeros((ADD2DSZ, ADD2DSZ));
     bench.iter(|| unsafe {
-        let mut c = Array::<MaybeUninit<i32>, _>::maybe_uninit(a.dim());
+        let mut c = Array::<i32, _>::uninit(a.dim());
         azip!((&a in &a, &b in &b, c in c.raw_view_mut().cast::<i32>())
             c.write(a + b)
         );

examples/sort-axis.rs

@@ -102,7 +102,7 @@ where
         assert_eq!(axis_len, perm.indices.len());
         debug_assert!(perm.correct());
 
-        let mut result = Array::maybe_uninit(self.dim());
+        let mut result = Array::uninit(self.dim());
 
         unsafe {
             // logically move ownership of all elements from self into result

src/data_traits.rs

@@ -9,7 +9,9 @@
 //! The data (inner representation) traits for ndarray
 
 use rawpointer::PointerExt;
+
 use std::mem::{self, size_of};
+use std::mem::MaybeUninit;
 use std::ptr::NonNull;
 use alloc::sync::Arc;
 use alloc::vec::Vec;
@@ -401,6 +403,10 @@ unsafe impl<'a, A> DataMut for ViewRepr<&'a mut A> {}
 ///
 /// ***Internal trait, see `Data`.***
 pub unsafe trait DataOwned: Data {
+    /// Corresponding owned data with MaybeUninit elements
+    type MaybeUninit: DataOwned<Elem = MaybeUninit<Self::Elem>>
+        + RawDataSubst<Self::Elem, Output=Self>;
+
     #[doc(hidden)]
     fn new(elements: Vec<Self::Elem>) -> Self;
 
@@ -421,6 +427,8 @@ unsafe impl<A> DataShared for OwnedArcRepr<A> {}
 unsafe impl<'a, A> DataShared for ViewRepr<&'a A> {}
 
 unsafe impl<A> DataOwned for OwnedRepr<A> {
+    type MaybeUninit = OwnedRepr<MaybeUninit<A>>;
+
     fn new(elements: Vec<A>) -> Self {
         OwnedRepr::from(elements)
     }
@@ -430,6 +438,8 @@ unsafe impl<A> DataOwned for OwnedRepr<A> {
 }
 
 unsafe impl<A> DataOwned for OwnedArcRepr<A> {
+    type MaybeUninit = OwnedArcRepr<MaybeUninit<A>>;
+
     fn new(elements: Vec<A>) -> Self {
         OwnedArcRepr(Arc::new(OwnedRepr::from(elements)))
     }

src/impl_constructors.rs

@@ -480,7 +480,7 @@ where
 
     /// Create an array with uninitalized elements, shape `shape`.
     ///
-    /// Prefer to use [`maybe_uninit()`](ArrayBase::maybe_uninit) if possible, because it is
+    /// Prefer to use [`uninit()`](ArrayBase::uninit) if possible, because it is
     /// easier to use correctly.
     ///
     /// **Panics** if the number of elements in `shape` would overflow isize.
@@ -512,13 +512,7 @@ where
         v.set_len(size);
         Self::from_shape_vec_unchecked(shape, v)
     }
-}
 
-impl<S, A, D> ArrayBase<S, D>
-where
-    S: DataOwned<Elem = MaybeUninit<A>>,
-    D: Dimension,
-{
     /// Create an array with uninitalized elements, shape `shape`.
     ///
     /// The uninitialized elements of type `A` are represented by the type `MaybeUninit<A>`,
@@ -550,7 +544,7 @@ where
     ///
     /// fn shift_by_two(a: &Array2<f32>) -> Array2<f32> {
     ///     // create an uninitialized array
-    ///     let mut b = Array2::maybe_uninit(a.dim());
+    ///     let mut b = Array2::uninit(a.dim());
     ///
     ///     // two first columns in b are two last in a
     ///     // rest of columns in b are the initial columns in a
@@ -580,6 +574,29 @@ where
     ///
     /// # shift_by_two(&Array2::zeros((8, 8)));
     /// ```
+    pub fn uninit<Sh>(shape: Sh) -> ArrayBase<S::MaybeUninit, D>
+    where
+        Sh: ShapeBuilder<Dim = D>,
+    {
+        unsafe {
+            let shape = shape.into_shape();
+            let size = size_of_shape_checked_unwrap!(&shape.dim);
+            let mut v = Vec::with_capacity(size);
+            v.set_len(size);
+            ArrayBase::from_shape_vec_unchecked(shape, v)
+        }
+    }
+}
+
+impl<S, A, D> ArrayBase<S, D>
+where
+    S: DataOwned<Elem = MaybeUninit<A>>,
+    D: Dimension,
+{
+    /// Create an array with uninitalized elements, shape `shape`.
+    ///
+    /// This method has been renamed to `uninit`
+    #[deprecated(note = "Renamed to `uninit`", since = "0.15.0")]
     pub fn maybe_uninit<Sh>(shape: Sh) -> Self
     where
         Sh: ShapeBuilder<Dim = D>,

src/linalg/impl_linalg.rs

@@ -326,7 +326,7 @@ where
 
         // Avoid initializing the memory in vec -- set it during iteration
         unsafe {
-            let mut c = Array1::maybe_uninit(m);
+            let mut c = Array1::uninit(m);
             general_mat_vec_mul_impl(A::one(), self, rhs, A::zero(), c.raw_view_mut().cast::<A>());
             c.assume_init()
         }

src/stacking.rs

@@ -91,7 +91,7 @@ where
 
     // we can safely use uninitialized values here because we will
     // overwrite every one of them.
-    let mut res = Array::maybe_uninit(res_dim);
+    let mut res = Array::uninit(res_dim);
 
     {
         let mut assign_view = res.view_mut();
@@ -159,7 +159,7 @@ where
 
     // we can safely use uninitialized values here because we will
     // overwrite every one of them.
-    let mut res = Array::maybe_uninit(res_dim);
+    let mut res = Array::uninit(res_dim);
 
     res.axis_iter_mut(axis)
         .zip(arrays.iter())

src/zip/mod.rs

@@ -814,7 +814,7 @@ where
     pub(crate) fn uninitalized_for_current_layout<T>(&self) -> Array<MaybeUninit<T>, D>
     {
         let is_f = self.prefer_f();
-        Array::maybe_uninit(self.dimension.clone().set_f(is_f))
+        Array::uninit(self.dimension.clone().set_f(is_f))
     }
 }
 

tests/array-construct.rs

@@ -205,18 +205,18 @@ fn maybe_uninit_1() {
 
     unsafe {
         // Array
-        type Mat<D> = Array<MaybeUninit<f32>, D>;
+        type Mat<D> = Array<f32, D>;
 
-        let mut a = Mat::maybe_uninit((10, 10));
+        let mut a = Mat::uninit((10, 10));
         a.mapv_inplace(|_| MaybeUninit::new(1.));
 
         let a_init = a.assume_init();
         assert_eq!(a_init, Array2::from_elem(a_init.dim(), 1.));
 
         // ArcArray
-        type ArcMat<D> = ArcArray<MaybeUninit<f32>, D>;
+        type ArcMat<D> = ArcArray<f32, D>;
 
-        let mut a = ArcMat::maybe_uninit((10, 10));
+        let mut a = ArcMat::uninit((10, 10));
         a.mapv_inplace(|_| MaybeUninit::new(1.));
         let a2 = a.clone();
 
@@ -228,7 +228,7 @@ fn maybe_uninit_1() {
         assert_eq!(av_init, Array2::from_elem(a_init.dim(), 1.));
 
         // RawArrayViewMut
-        let mut a = Mat::maybe_uninit((10, 10));
+        let mut a = Mat::uninit((10, 10));
         let v = a.raw_view_mut();
         Zip::from(v)
             .for_each(|ptr| *(*ptr).as_mut_ptr() = 1.);