#![no_std]
#![cfg_attr(feature = "const-trait", feature(const_trait_impl))]
use core::mem::ManuallyDrop;
use core::{mem, ptr};
#[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)]
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)
}
}
};
}
#[cfg(feature = "const-trait")]
define_traits!(const);
#[cfg(not(feature = "const-trait"))]
define_traits!();