Add functions for casting from core references (#181)

- `Array::cast_from_core`: `const fn` equivalent of `From<[T; N]>`
- `Array::cast_from_core_mut`: `mut` equivalent of the above
- `Array::from_ref`: cast `&T` to `&Array<T; U1>`
- `Array::from_mut`: `mut` equivalent of the above

The latter are the equivalents of `core::array::{from_ref, from_mut}`
which I opted to put on `Array<T, U1>` for consistency with
`Array::from_fn` which is impl'd on the type instead of as a free
function.

Author: tarcieri

src/lib.rs

@@ -126,7 +126,7 @@ use core::{
     ptr,
     slice::{self, Iter, IterMut},
 };
-use typenum::{Diff, Sum};
+use typenum::{Diff, Sum, U1};
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::Arbitrary;
@@ -401,6 +401,19 @@ where
     }
 }
 
+impl<T> Array<T, U1> {
+    /// Convert a reference to `T` into a reference to an [`Array`] of length [`U1`].
+    pub const fn from_ref(r: &T) -> &Self {
+        Self::cast_from_core(core::array::from_ref(r))
+    }
+
+    /// Converts a mutable reference to `T` into a mutable reference to an [`Array`] of
+    /// length [`U1`].
+    pub const fn from_mut(r: &mut T) -> &mut Self {
+        Self::cast_from_core_mut(core::array::from_mut(r))
+    }
+}
+
 impl<T, U, V> Array<Array<T, U>, V>
 where
     U: ArraySize,
@@ -475,30 +488,44 @@ impl<T, U, const N: usize> Array<T, U>
 where
     U: ArraySize<ArrayType<T> = [T; N]>,
 {
+    /// Cast a reference to a core array to an [`Array`] reference.
+    #[inline]
+    pub const fn cast_from_core(array_ref: &[T; N]) -> &Self {
+        // SAFETY: `Self` is a `repr(transparent)` newtype for `[T; N]`
+        unsafe { &*array_ref.as_ptr().cast() }
+    }
+
+    /// Cast a mutable reference to a core array to an [`Array`] reference.
+    #[inline]
+    pub const fn cast_from_core_mut(array_ref: &mut [T; N]) -> &mut Self {
+        // SAFETY: `Self` is a `repr(transparent)` newtype for `[T; 1]`
+        unsafe { &mut *array_ref.as_mut_ptr().cast() }
+    }
+
     /// Transform slice to slice of core array type.
     #[inline]
-    pub const fn cast_slice_to_core(slice: &[Self]) -> &[[T; N]] {
+    pub const fn cast_slice_from_core(slice: &[[T; N]]) -> &[Self] {
         // SAFETY: `Self` is a `repr(transparent)` newtype for `[T; N]`
         unsafe { slice::from_raw_parts(slice.as_ptr().cast(), slice.len()) }
     }
 
     /// Transform mutable slice to mutable slice of core array type.
     #[inline]
-    pub const fn cast_slice_to_core_mut(slice: &mut [Self]) -> &mut [[T; N]] {
+    pub const fn cast_slice_from_core_mut(slice: &mut [[T; N]]) -> &mut [Self] {
         // SAFETY: `Self` is a `repr(transparent)` newtype for `[T; N]`
         unsafe { slice::from_raw_parts_mut(slice.as_mut_ptr().cast(), slice.len()) }
     }
 
     /// Transform slice to slice of core array type.
     #[inline]
-    pub const fn cast_slice_from_core(slice: &[[T; N]]) -> &[Self] {
+    pub const fn cast_slice_to_core(slice: &[Self]) -> &[[T; N]] {
         // SAFETY: `Self` is a `repr(transparent)` newtype for `[T; N]`
         unsafe { slice::from_raw_parts(slice.as_ptr().cast(), slice.len()) }
     }
 
     /// Transform mutable slice to mutable slice of core array type.
     #[inline]
-    pub const fn cast_slice_from_core_mut(slice: &mut [[T; N]]) -> &mut [Self] {
+    pub const fn cast_slice_to_core_mut(slice: &mut [Self]) -> &mut [[T; N]] {
         // SAFETY: `Self` is a `repr(transparent)` newtype for `[T; N]`
         unsafe { slice::from_raw_parts_mut(slice.as_mut_ptr().cast(), slice.len()) }
     }
@@ -733,8 +760,7 @@ where
 {
     #[inline]
     fn from(array_ref: &'a [T; N]) -> &'a Array<T, U> {
-        // SAFETY: `Self` is a `repr(transparent)` newtype for `[T; $len]`
-        unsafe { &*array_ref.as_ptr().cast() }
+        Array::cast_from_core(array_ref)
     }
 }
 
@@ -754,8 +780,7 @@ where
 {
     #[inline]
     fn from(array_ref: &'a mut [T; N]) -> &'a mut Array<T, U> {
-        // SAFETY: `Self` is a `repr(transparent)` newtype for `[T; $len]`
-        unsafe { &mut *array_ref.as_mut_ptr().cast() }
+        Array::cast_from_core_mut(array_ref)
     }
 }
 

tests/mod.rs

@@ -85,6 +85,21 @@ fn split_ref_mut() {
     assert_eq!(suffix.as_slice(), &EXAMPLE_SLICE[4..]);
 }
 
+#[test]
+fn from_ref() {
+    let n = 42u64;
+    let array = Array::from_ref(&n);
+    assert_eq!(array[0], n);
+}
+
+#[test]
+fn from_mut() {
+    let mut n = 42u64;
+    let array = Array::from_mut(&mut n);
+    array[0] = 43;
+    assert_eq!(n, 43);
+}
+
 #[test]
 fn from_fn() {
     let array = Array::<u8, U6>::from_fn(|n| (n + 1) as u8);