#![no_std]
#![cfg_attr(feature = "const-trait", feature(const_trait_impl))]
use core::mem::ManuallyDrop;
use core::{mem, ptr, slice};
#[inline(always)]
const fn assert_len<const INNER: usize, const OUTER: usize, const LEN: usize>() {
const {
assert!(
matches!(INNER.checked_mul(OUTER), Some(len) if len == LEN),
"Arrays must have the same total number of elements"
);
}
}
#[inline(always)]
const unsafe fn transmute_array<Src, Dst>(src: Src) -> Dst {
let src = ManuallyDrop::new(src);
unsafe { mem::transmute_copy::<ManuallyDrop<Src>, Dst>(&src) }
}
#[inline(always)]
pub const fn flatten<T, const N: usize, const M: usize, const K: usize>(
array: [[T; N]; M],
) -> [T; K] {
assert_len::<N, M, K>();
unsafe { transmute_array(array) }
}
#[inline(always)]
pub const fn flatten_ref<T, const N: usize, const M: usize, const K: usize>(
array: &[[T; N]; M],
) -> &[T; K] {
assert_len::<N, M, K>();
unsafe { &*ptr::from_ref(array).cast::<[T; K]>() }
}
#[inline(always)]
pub const fn flatten_mut<T, const N: usize, const M: usize, const K: usize>(
array: &mut [[T; N]; M],
) -> &mut [T; K] {
assert_len::<N, M, K>();
unsafe { &mut *ptr::from_mut(array).cast::<[T; K]>() }
}
#[inline(always)]
pub const fn unflatten<T, const N: usize, const M: usize, const K: usize>(
array: [T; K],
) -> [[T; N]; M] {
assert_len::<N, M, K>();
unsafe { transmute_array(array) }
}
#[inline(always)]
pub const fn unflatten_ref<T, const N: usize, const M: usize, const K: usize>(
array: &[T; K],
) -> &[[T; N]; M] {
assert_len::<N, M, K>();
unsafe { &*ptr::from_ref(array).cast::<[[T; N]; M]>() }
}
#[inline(always)]
pub const fn unflatten_mut<T, const N: usize, const M: usize, const K: usize>(
array: &mut [T; K],
) -> &mut [[T; N]; M] {
assert_len::<N, M, K>();
unsafe { &mut *ptr::from_mut(array).cast::<[[T; N]; M]>() }
}
#[inline(always)]
pub const fn rechunk<T, const A: usize, const B: usize, const C: usize, const D: usize>(
array: [[T; A]; B],
) -> [[T; C]; D] {
assert_same_total_len::<A, B, C, D>();
unsafe { transmute_array(array) }
}
#[inline(always)]
pub const fn rechunk_ref<T, const A: usize, const B: usize, const C: usize, const D: usize>(
array: &[[T; A]; B],
) -> &[[T; C]; D] {
assert_same_total_len::<A, B, C, D>();
unsafe { &*ptr::from_ref(array).cast::<[[T; C]; D]>() }
}
#[inline(always)]
pub const fn rechunk_mut<T, const A: usize, const B: usize, const C: usize, const D: usize>(
array: &mut [[T; A]; B],
) -> &mut [[T; C]; D] {
assert_same_total_len::<A, B, C, D>();
unsafe { &mut *ptr::from_mut(array).cast::<[[T; C]; D]>() }
}
#[inline(always)]
pub const fn flatten_each_ref<T, const N: usize, const M: usize, const K: usize>(
slice: &[[[T; N]; M]],
) -> &[[T; K]] {
assert_len::<N, M, K>();
unsafe { slice::from_raw_parts(slice.as_ptr().cast::<[T; K]>(), slice.len()) }
}
#[inline(always)]
pub const fn flatten_each_mut<T, const N: usize, const M: usize, const K: usize>(
slice: &mut [[[T; N]; M]],
) -> &mut [[T; K]] {
assert_len::<N, M, K>();
unsafe { slice::from_raw_parts_mut(slice.as_mut_ptr().cast::<[T; K]>(), slice.len()) }
}
#[inline(always)]
pub const fn unflatten_each_ref<T, const N: usize, const M: usize, const K: usize>(
slice: &[[T; K]],
) -> &[[[T; N]; M]] {
assert_len::<N, M, K>();
unsafe { slice::from_raw_parts(slice.as_ptr().cast::<[[T; N]; M]>(), slice.len()) }
}
#[inline(always)]
pub const fn unflatten_each_mut<T, const N: usize, const M: usize, const K: usize>(
slice: &mut [[T; K]],
) -> &mut [[[T; N]; M]] {
assert_len::<N, M, K>();
unsafe { slice::from_raw_parts_mut(slice.as_mut_ptr().cast::<[[T; N]; M]>(), slice.len()) }
}
#[inline(always)]
pub const fn rechunk_each_ref<T, const A: usize, const B: usize, const C: usize, const D: usize>(
slice: &[[[T; A]; B]],
) -> &[[[T; C]; D]] {
assert_same_total_len::<A, B, C, D>();
unsafe { slice::from_raw_parts(slice.as_ptr().cast::<[[T; C]; D]>(), slice.len()) }
}
#[inline(always)]
pub const fn rechunk_each_mut<T, const A: usize, const B: usize, const C: usize, const D: usize>(
slice: &mut [[[T; A]; B]],
) -> &mut [[[T; C]; D]] {
assert_same_total_len::<A, B, C, D>();
unsafe { slice::from_raw_parts_mut(slice.as_mut_ptr().cast::<[[T; C]; D]>(), slice.len()) }
}
#[inline(always)]
pub const fn flatten_each_array_ref<
T,
const N: usize,
const M: usize,
const K: usize,
const L: usize,
>(
array: &[[[T; N]; M]; L],
) -> &[[T; K]; L] {
assert_len::<N, M, K>();
unsafe { &*ptr::from_ref(array).cast::<[[T; K]; L]>() }
}
#[inline(always)]
pub const fn flatten_each_array_mut<
T,
const N: usize,
const M: usize,
const K: usize,
const L: usize,
>(
array: &mut [[[T; N]; M]; L],
) -> &mut [[T; K]; L] {
assert_len::<N, M, K>();
unsafe { &mut *ptr::from_mut(array).cast::<[[T; K]; L]>() }
}
#[inline(always)]
pub const fn unflatten_each_array_ref<
T,
const N: usize,
const M: usize,
const K: usize,
const L: usize,
>(
array: &[[T; K]; L],
) -> &[[[T; N]; M]; L] {
assert_len::<N, M, K>();
unsafe { &*ptr::from_ref(array).cast::<[[[T; N]; M]; L]>() }
}
#[inline(always)]
pub const fn unflatten_each_array_mut<
T,
const N: usize,
const M: usize,
const K: usize,
const L: usize,
>(
array: &mut [[T; K]; L],
) -> &mut [[[T; N]; M]; L] {
assert_len::<N, M, K>();
unsafe { &mut *ptr::from_mut(array).cast::<[[[T; N]; M]; L]>() }
}
#[inline(always)]
pub const fn rechunk_each_array_ref<
T,
const A: usize,
const B: usize,
const C: usize,
const D: usize,
const L: usize,
>(
array: &[[[T; A]; B]; L],
) -> &[[[T; C]; D]; L] {
assert_same_total_len::<A, B, C, D>();
unsafe { &*ptr::from_ref(array).cast::<[[[T; C]; D]; L]>() }
}
#[inline(always)]
pub const fn rechunk_each_array_mut<
T,
const A: usize,
const B: usize,
const C: usize,
const D: usize,
const L: usize,
>(
array: &mut [[[T; A]; B]; L],
) -> &mut [[[T; C]; D]; L] {
assert_same_total_len::<A, B, C, D>();
unsafe { &mut *ptr::from_mut(array).cast::<[[[T; C]; D]; L]>() }
}
#[inline(always)]
const fn assert_same_total_len<const A: usize, const B: usize, const C: usize, const D: usize>() {
const {
assert!(
matches!(
(A.checked_mul(B), C.checked_mul(D)),
(Some(input_len), Some(output_len)) if input_len == output_len
),
"Arrays must have the same total number of elements"
);
}
}
macro_rules! define_traits {
($($const:ident)?) => {
pub $($const)? trait Flatten<T, const N: usize, const M: usize>: Sized {
fn flatten<const K: usize>(self) -> [T; K];
fn flatten_ref<const K: usize>(&self) -> &[T; K];
fn flatten_mut<const K: usize>(&mut self) -> &mut [T; K];
}
$($const)? impl<T, const N: usize, const M: usize> Flatten<T, N, M> for [[T; N]; M] {
#[inline(always)]
fn flatten<const K: usize>(self) -> [T; K] {
flatten(self)
}
#[inline(always)]
fn flatten_ref<const K: usize>(&self) -> &[T; K] {
flatten_ref(self)
}
#[inline(always)]
fn flatten_mut<const K: usize>(&mut self) -> &mut [T; K] {
flatten_mut(self)
}
}
pub $($const)? trait Rechunk<T, const N: usize, const M: usize>: Sized {
fn rechunk<const C: usize, const D: usize>(self) -> [[T; C]; D];
fn rechunk_ref<const C: usize, const D: usize>(&self) -> &[[T; C]; D];
fn rechunk_mut<const C: usize, const D: usize>(&mut self) -> &mut [[T; C]; D];
}
$($const)? impl<T, const N: usize, const M: usize> Rechunk<T, N, M> for [[T; N]; M] {
#[inline(always)]
fn rechunk<const C: usize, const D: usize>(self) -> [[T; C]; D] {
rechunk(self)
}
#[inline(always)]
fn rechunk_ref<const C: usize, const D: usize>(&self) -> &[[T; C]; D] {
rechunk_ref(self)
}
#[inline(always)]
fn rechunk_mut<const C: usize, const D: usize>(&mut self) -> &mut [[T; C]; D] {
rechunk_mut(self)
}
}
pub $($const)? trait Unflatten<T, const K: usize>: Sized {
fn unflatten<const N: usize, const M: usize>(self) -> [[T; N]; M];
fn unflatten_ref<const N: usize, const M: usize>(&self) -> &[[T; N]; M];
fn unflatten_mut<const N: usize, const M: usize>(&mut self) -> &mut [[T; N]; M];
}
$($const)? impl<T, const K: usize> Unflatten<T, K> for [T; K] {
#[inline(always)]
fn unflatten<const N: usize, const M: usize>(self) -> [[T; N]; M] {
unflatten(self)
}
#[inline(always)]
fn unflatten_ref<const N: usize, const M: usize>(&self) -> &[[T; N]; M] {
unflatten_ref(self)
}
#[inline(always)]
fn unflatten_mut<const N: usize, const M: usize>(&mut self) -> &mut [[T; N]; M] {
unflatten_mut(self)
}
}
pub $($const)? trait FlattenEach<T, const N: usize, const M: usize> {
type Flattened<const K: usize>: ?Sized;
fn flatten_each_ref<const K: usize>(&self) -> &Self::Flattened<K>;
fn flatten_each_mut<const K: usize>(&mut self) -> &mut Self::Flattened<K>;
}
$($const)? impl<T, const N: usize, const M: usize> FlattenEach<T, N, M> for [[[T; N]; M]] {
type Flattened<const K: usize> = [[T; K]];
#[inline(always)]
fn flatten_each_ref<const K: usize>(&self) -> &[[T; K]] {
flatten_each_ref(self)
}
#[inline(always)]
fn flatten_each_mut<const K: usize>(&mut self) -> &mut [[T; K]] {
flatten_each_mut(self)
}
}
$($const)? impl<T, const N: usize, const M: usize, const L: usize> FlattenEach<T, N, M>
for [[[T; N]; M]; L]
{
type Flattened<const K: usize> = [[T; K]; L];
#[inline(always)]
fn flatten_each_ref<const K: usize>(&self) -> &[[T; K]; L] {
flatten_each_array_ref(self)
}
#[inline(always)]
fn flatten_each_mut<const K: usize>(&mut self) -> &mut [[T; K]; L] {
flatten_each_array_mut(self)
}
}
pub $($const)? trait UnflattenEach<T, const K: usize> {
type Unflattened<const N: usize, const M: usize>: ?Sized;
fn unflatten_each_ref<const N: usize, const M: usize>(&self)
-> &Self::Unflattened<N, M>;
fn unflatten_each_mut<const N: usize, const M: usize>(
&mut self,
) -> &mut Self::Unflattened<N, M>;
}
$($const)? impl<T, const K: usize> UnflattenEach<T, K> for [[T; K]] {
type Unflattened<const N: usize, const M: usize> = [[[T; N]; M]];
#[inline(always)]
fn unflatten_each_ref<const N: usize, const M: usize>(&self) -> &[[[T; N]; M]] {
unflatten_each_ref(self)
}
#[inline(always)]
fn unflatten_each_mut<const N: usize, const M: usize>(&mut self) -> &mut [[[T; N]; M]] {
unflatten_each_mut(self)
}
}
$($const)? impl<T, const K: usize, const L: usize> UnflattenEach<T, K> for [[T; K]; L] {
type Unflattened<const N: usize, const M: usize> = [[[T; N]; M]; L];
#[inline(always)]
fn unflatten_each_ref<const N: usize, const M: usize>(&self) -> &[[[T; N]; M]; L] {
unflatten_each_array_ref(self)
}
#[inline(always)]
fn unflatten_each_mut<const N: usize, const M: usize>(
&mut self,
) -> &mut [[[T; N]; M]; L] {
unflatten_each_array_mut(self)
}
}
pub $($const)? trait RechunkEach<T, const N: usize, const M: usize> {
type Rechunked<const C: usize, const D: usize>: ?Sized;
fn rechunk_each_ref<const C: usize, const D: usize>(&self) -> &Self::Rechunked<C, D>;
fn rechunk_each_mut<const C: usize, const D: usize>(
&mut self,
) -> &mut Self::Rechunked<C, D>;
}
$($const)? impl<T, const N: usize, const M: usize> RechunkEach<T, N, M> for [[[T; N]; M]] {
type Rechunked<const C: usize, const D: usize> = [[[T; C]; D]];
#[inline(always)]
fn rechunk_each_ref<const C: usize, const D: usize>(&self) -> &[[[T; C]; D]] {
rechunk_each_ref(self)
}
#[inline(always)]
fn rechunk_each_mut<const C: usize, const D: usize>(&mut self) -> &mut [[[T; C]; D]] {
rechunk_each_mut(self)
}
}
$($const)? impl<T, const N: usize, const M: usize, const L: usize> RechunkEach<T, N, M>
for [[[T; N]; M]; L]
{
type Rechunked<const C: usize, const D: usize> = [[[T; C]; D]; L];
#[inline(always)]
fn rechunk_each_ref<const C: usize, const D: usize>(&self) -> &[[[T; C]; D]; L] {
rechunk_each_array_ref(self)
}
#[inline(always)]
fn rechunk_each_mut<const C: usize, const D: usize>(
&mut self,
) -> &mut [[[T; C]; D]; L] {
rechunk_each_array_mut(self)
}
}
};
}
#[cfg(feature = "const-trait")]
define_traits!(const);
#[cfg(not(feature = "const-trait"))]
define_traits!();