From a489c34820bfde60422bb9f4f94a865bae4f6c8c Mon Sep 17 00:00:00 2001 From: Tony Arcieri Date: Tue, 23 Sep 2025 08:49:27 -0600 Subject: [PATCH] DRY out `as_flattened` impls The `as_flattened(_mut)` methods can be impl'd in terms of `slice_as_flattened(_mut)` --- src/lib.rs | 78 ++++++++++++++++++++---------------------------------- 1 file changed, 29 insertions(+), 49 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 1c6e766..c1382cb 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -363,7 +363,7 @@ where U: ArraySize, V: ArraySize, { - /// Takes a `&mut Array,M>`, and flattens it to a `&mut [T]`. + /// Takes a `&Array, >>`, and flattens it to a `&[T]`. /// /// # Panics /// @@ -376,33 +376,28 @@ where /// # Examples /// /// ``` - /// use hybrid_array::{Array, typenum::U3}; + /// use hybrid_array::{Array, typenum::{U0, U2, U3, U5, U10}}; /// - /// fn add_5_to_all(slice: &mut [i32]) { - /// for i in slice { - /// *i += 5; - /// } - /// } + /// let a: Array, U2> = Array([Array([1, 2, 3]), Array([4, 5, 6])]); + /// assert_eq!(a.as_flattened(), &[1, 2, 3, 4, 5, 6]); /// - /// let mut array: Array, U3> = Array([Array([1_i32, 2, 3]), Array([4, 5, 6]), Array([7, 8, 9])]); - /// add_5_to_all(array.as_flattened_mut()); - /// assert_eq!(array, Array([Array([6, 7, 8]), Array([9, 10, 11]), Array([12, 13, 14])])); + /// let b: Array, U3> = Array([Array([1, 2]), Array([3, 4]), Array([5, 6])]); + /// assert_eq!(a.as_flattened(), b.as_flattened()); + /// + /// let c: Array<[usize; 2], U3> = Array([[1, 2], [3, 4], [5, 6]]); + /// assert_eq!(a.as_flattened(), c.as_flattened()); + /// + /// let slice_of_empty_arrays: &Array, U0> = &Array::from_fn(|_| Array([1, 2, 3, 4, 5])); + /// assert!(slice_of_empty_arrays.as_flattened().is_empty()); + /// + /// let empty_slice_of_arrays: &Array, U0> = &Array([]); + /// assert!(empty_slice_of_arrays.as_flattened().is_empty()); /// ``` - pub fn as_flattened_mut(&mut self) -> &mut [T] { - let len = if size_of::() == 0 { - self.len() - .checked_mul(U::USIZE) - .expect("slice len overflow") - } else { - // SAFETY: `self.len() * N` cannot overflow because `self` is - // already in the address space. - unsafe { self.len().unchecked_mul(U::USIZE) } - }; - // SAFETY: `[T]` is layout-identical to `[T; U]` - unsafe { slice::from_raw_parts_mut(self.as_mut_ptr().cast(), len) } + pub fn as_flattened(&self) -> &[T] { + Array::slice_as_flattened(self.as_slice()) } - /// Takes a `&Array, >>`, and flattens it to a `&[T]`. + /// Takes a `&mut Array,M>`, and flattens it to a `&mut [T]`. /// /// # Panics /// @@ -415,35 +410,20 @@ where /// # Examples /// /// ``` - /// use hybrid_array::{Array, typenum::{U0, U2, U3, U5, U10}}; - /// - /// let a: Array, U2> = Array([Array([1, 2, 3]), Array([4, 5, 6])]); - /// assert_eq!(a.as_flattened(), &[1, 2, 3, 4, 5, 6]); - /// - /// let b: Array, U3> = Array([Array([1, 2]), Array([3, 4]), Array([5, 6])]); - /// assert_eq!(a.as_flattened(), b.as_flattened()); - /// - /// let c: Array<[usize; 2], U3> = Array([[1, 2], [3, 4], [5, 6]]); - /// assert_eq!(a.as_flattened(), c.as_flattened()); + /// use hybrid_array::{Array, typenum::U3}; /// - /// let slice_of_empty_arrays: &Array, U0> = &Array::from_fn(|_| Array([1, 2, 3, 4, 5])); - /// assert!(slice_of_empty_arrays.as_flattened().is_empty()); + /// fn add_5_to_all(slice: &mut [i32]) { + /// for i in slice { + /// *i += 5; + /// } + /// } /// - /// let empty_slice_of_arrays: &Array, U0> = &Array([]); - /// assert!(empty_slice_of_arrays.as_flattened().is_empty()); + /// let mut array: Array, U3> = Array([Array([1_i32, 2, 3]), Array([4, 5, 6]), Array([7, 8, 9])]); + /// add_5_to_all(array.as_flattened_mut()); + /// assert_eq!(array, Array([Array([6, 7, 8]), Array([9, 10, 11]), Array([12, 13, 14])])); /// ``` - pub fn as_flattened(&self) -> &[T] { - let len = if size_of::() == 0 { - self.len() - .checked_mul(U::USIZE) - .expect("slice len overflow") - } else { - // SAFETY: `self.len() * N` cannot overflow because `self` is - // already in the address space. - unsafe { self.len().unchecked_mul(U::USIZE) } - }; - // SAFETY: `[T]` is layout-identical to `[T; U]` - unsafe { slice::from_raw_parts(self.as_ptr().cast(), len) } + pub fn as_flattened_mut(&mut self) -> &mut [T] { + Array::slice_as_flattened_mut(self.as_mut_slice()) } }