Add 'core::array::try_from_slice' constructor;

Author: bjoernager

library/core/src/array/mod.rs

@@ -16,7 +16,7 @@ use crate::mem::{self, MaybeUninit};
 use crate::ops::{
  ChangeOutputType, ControlFlow, FromResidual, Index, IndexMut, NeverShortCircuit, Residual, Try,
 };
-use crate::ptr::{null, null_mut};
+use crate::ptr::{copy_nonoverlapping, null, null_mut};
 use crate::slice::{Iter, IterMut};
 
 mod ascii;
@@ -154,6 +154,42 @@ pub const fn from_mut<T>(s: &mut T) -> &mut [T; 1] {
  unsafe { &mut *(s as *mut T).cast::<[T; 1]>() }
 }
 
+/// Tries to create an array `[T; N]` by copying from a slice `&[T]`.
+/// Succeeds if `slice.len() == N`.
+///
+/// # Example
+///
+/// ```
+/// use core::array;
+///
+/// let data = array::try_from_slice(&[255, 127, 63, 31]).unwrap();
+///
+/// let value = u32::from_le_bytes(data);
+/// assert_eq!(value, 0x1F3F7FFF);
+/// ```
+#[inline]
+#[unstable(feature = "array_try_from_slice", issue = "133440")]
+#[rustc_const_unstable(feature = "array_try_from_slice", issue = "133440")]
+pub const fn try_from_slice<T, const N: usize>(slice: &[T]) -> Result<[T; N], TryFromSliceError>
+where
+ T: Copy,
+{
+ if slice.len() == N {
+ // SAFETY: `MaybeUninit` always supports being in an unitialised state, even as an array.
+ let mut me: [MaybeUninit<T>; N] = unsafe { MaybeUninit::uninit().assume_init() };
+
+ // SAFETY: `me` and `slice` are both exclusive as the former is a mutable reference. They also both contain `N` elements. `T` additionally implements `Copy`.
+ unsafe { copy_nonoverlapping(slice.as_ptr(), me.as_mut_ptr() as *mut T, N) };
+
+ // SAFETY: `MaybeUninit<T>` is transparent to `T`, and every item has also been initialised.
+ let me = unsafe { transmute_unchecked(me) };
+
+ Ok(me)
+ } else {
+ Err(TryFromSliceError(()))
+ }
+}
+
 /// The error type returned when a conversion from a slice to an array fails.
 #[stable(feature = "try_from", since = "1.34.0")]
 #[rustc_allowed_through_unstable_modules]
@@ -214,8 +250,8 @@ impl<T, const N: usize> BorrowMut<[T]> for [T; N] {
  }
 }
 
-/// Tries to create an array `[T; N]` by copying from a slice `&[T]`. Succeeds if
-/// `slice.len() == N`.
+/// Tries to create an array `[T; N]` by copying from a slice `&[T]`.
+/// Succeeds if `slice.len() == N`.
 ///
 /// ```
 /// let bytes: [u8; 3] = [1, 0, 2];
@@ -235,7 +271,7 @@ where
 
  #[inline]
  fn try_from(slice: &[T]) -> Result<[T; N], TryFromSliceError> {
- <&Self>::try_from(slice).copied()
+ try_from_slice(slice)
  }
 }
 
@@ -260,7 +296,7 @@ where
 
  #[inline]
  fn try_from(slice: &mut [T]) -> Result<[T; N], TryFromSliceError> {
- <Self>::try_from(&*slice)
+ try_from_slice(slice)
  }
 }