1#![no_std]
2#![cfg_attr(feature = "const-trait", feature(const_trait_impl))]
3
4use core::mem::ManuallyDrop;
76use core::{mem, ptr, slice};
77
78#[inline(always)]
80const fn assert_len<const INNER: usize, const OUTER: usize, const LEN: usize>() {
81 const {
82 assert!(
83 matches!(INNER.checked_mul(OUTER), Some(len) if len == LEN),
84 "Arrays must have the same total number of elements"
85 );
86 }
87}
88
89#[inline(always)]
94const unsafe fn transmute_array<Src, Dst>(src: Src) -> Dst {
95 let src = ManuallyDrop::new(src);
96 unsafe { mem::transmute_copy::<ManuallyDrop<Src>, Dst>(&src) }
98}
99
100#[inline(always)]
102pub const fn flatten<T, const N: usize, const M: usize, const K: usize>(
103 array: [[T; N]; M],
104) -> [T; K] {
105 assert_len::<N, M, K>();
106 unsafe { transmute_array(array) }
108}
109
110#[inline(always)]
112pub const fn flatten_ref<T, const N: usize, const M: usize, const K: usize>(
113 array: &[[T; N]; M],
114) -> &[T; K] {
115 assert_len::<N, M, K>();
116 unsafe { &*ptr::from_ref(array).cast::<[T; K]>() }
118}
119
120#[inline(always)]
122pub const fn flatten_mut<T, const N: usize, const M: usize, const K: usize>(
123 array: &mut [[T; N]; M],
124) -> &mut [T; K] {
125 assert_len::<N, M, K>();
126 unsafe { &mut *ptr::from_mut(array).cast::<[T; K]>() }
128}
129
130#[inline(always)]
132pub const fn unflatten<T, const N: usize, const M: usize, const K: usize>(
133 array: [T; K],
134) -> [[T; N]; M] {
135 assert_len::<N, M, K>();
136 unsafe { transmute_array(array) }
138}
139
140#[inline(always)]
142pub const fn unflatten_ref<T, const N: usize, const M: usize, const K: usize>(
143 array: &[T; K],
144) -> &[[T; N]; M] {
145 assert_len::<N, M, K>();
146 unsafe { &*ptr::from_ref(array).cast::<[[T; N]; M]>() }
148}
149
150#[inline(always)]
152pub const fn unflatten_mut<T, const N: usize, const M: usize, const K: usize>(
153 array: &mut [T; K],
154) -> &mut [[T; N]; M] {
155 assert_len::<N, M, K>();
156 unsafe { &mut *ptr::from_mut(array).cast::<[[T; N]; M]>() }
158}
159
160#[inline(always)]
162pub const fn rechunk<T, const A: usize, const B: usize, const C: usize, const D: usize>(
163 array: [[T; A]; B],
164) -> [[T; C]; D] {
165 assert_same_total_len::<A, B, C, D>();
166 unsafe { transmute_array(array) }
168}
169
170#[inline(always)]
172pub const fn rechunk_ref<T, const A: usize, const B: usize, const C: usize, const D: usize>(
173 array: &[[T; A]; B],
174) -> &[[T; C]; D] {
175 assert_same_total_len::<A, B, C, D>();
176 unsafe { &*ptr::from_ref(array).cast::<[[T; C]; D]>() }
178}
179
180#[inline(always)]
182pub const fn rechunk_mut<T, const A: usize, const B: usize, const C: usize, const D: usize>(
183 array: &mut [[T; A]; B],
184) -> &mut [[T; C]; D] {
185 assert_same_total_len::<A, B, C, D>();
186 unsafe { &mut *ptr::from_mut(array).cast::<[[T; C]; D]>() }
188}
189
190#[inline(always)]
192pub const fn flatten_each_ref<T, const N: usize, const M: usize, const K: usize>(
193 slice: &[[[T; N]; M]],
194) -> &[[T; K]] {
195 assert_len::<N, M, K>();
196 unsafe { slice::from_raw_parts(slice.as_ptr().cast::<[T; K]>(), slice.len()) }
199}
200
201#[inline(always)]
203pub const fn flatten_each_mut<T, const N: usize, const M: usize, const K: usize>(
204 slice: &mut [[[T; N]; M]],
205) -> &mut [[T; K]] {
206 assert_len::<N, M, K>();
207 unsafe { slice::from_raw_parts_mut(slice.as_mut_ptr().cast::<[T; K]>(), slice.len()) }
210}
211
212#[inline(always)]
214pub const fn unflatten_each_ref<T, const N: usize, const M: usize, const K: usize>(
215 slice: &[[T; K]],
216) -> &[[[T; N]; M]] {
217 assert_len::<N, M, K>();
218 unsafe { slice::from_raw_parts(slice.as_ptr().cast::<[[T; N]; M]>(), slice.len()) }
221}
222
223#[inline(always)]
225pub const fn unflatten_each_mut<T, const N: usize, const M: usize, const K: usize>(
226 slice: &mut [[T; K]],
227) -> &mut [[[T; N]; M]] {
228 assert_len::<N, M, K>();
229 unsafe { slice::from_raw_parts_mut(slice.as_mut_ptr().cast::<[[T; N]; M]>(), slice.len()) }
232}
233
234#[inline(always)]
237pub const fn rechunk_each_ref<T, const A: usize, const B: usize, const C: usize, const D: usize>(
238 slice: &[[[T; A]; B]],
239) -> &[[[T; C]; D]] {
240 assert_same_total_len::<A, B, C, D>();
241 unsafe { slice::from_raw_parts(slice.as_ptr().cast::<[[T; C]; D]>(), slice.len()) }
244}
245
246#[inline(always)]
249pub const fn rechunk_each_mut<T, const A: usize, const B: usize, const C: usize, const D: usize>(
250 slice: &mut [[[T; A]; B]],
251) -> &mut [[[T; C]; D]] {
252 assert_same_total_len::<A, B, C, D>();
253 unsafe { slice::from_raw_parts_mut(slice.as_mut_ptr().cast::<[[T; C]; D]>(), slice.len()) }
256}
257
258#[inline(always)]
260pub const fn flatten_each_array_ref<
261 T,
262 const N: usize,
263 const M: usize,
264 const K: usize,
265 const L: usize,
266>(
267 array: &[[[T; N]; M]; L],
268) -> &[[T; K]; L] {
269 assert_len::<N, M, K>();
270 unsafe { &*ptr::from_ref(array).cast::<[[T; K]; L]>() }
273}
274
275#[inline(always)]
277pub const fn flatten_each_array_mut<
278 T,
279 const N: usize,
280 const M: usize,
281 const K: usize,
282 const L: usize,
283>(
284 array: &mut [[[T; N]; M]; L],
285) -> &mut [[T; K]; L] {
286 assert_len::<N, M, K>();
287 unsafe { &mut *ptr::from_mut(array).cast::<[[T; K]; L]>() }
290}
291
292#[inline(always)]
294pub const fn unflatten_each_array_ref<
295 T,
296 const N: usize,
297 const M: usize,
298 const K: usize,
299 const L: usize,
300>(
301 array: &[[T; K]; L],
302) -> &[[[T; N]; M]; L] {
303 assert_len::<N, M, K>();
304 unsafe { &*ptr::from_ref(array).cast::<[[[T; N]; M]; L]>() }
307}
308
309#[inline(always)]
311pub const fn unflatten_each_array_mut<
312 T,
313 const N: usize,
314 const M: usize,
315 const K: usize,
316 const L: usize,
317>(
318 array: &mut [[T; K]; L],
319) -> &mut [[[T; N]; M]; L] {
320 assert_len::<N, M, K>();
321 unsafe { &mut *ptr::from_mut(array).cast::<[[[T; N]; M]; L]>() }
324}
325
326#[inline(always)]
329pub const fn rechunk_each_array_ref<
330 T,
331 const A: usize,
332 const B: usize,
333 const C: usize,
334 const D: usize,
335 const L: usize,
336>(
337 array: &[[[T; A]; B]; L],
338) -> &[[[T; C]; D]; L] {
339 assert_same_total_len::<A, B, C, D>();
340 unsafe { &*ptr::from_ref(array).cast::<[[[T; C]; D]; L]>() }
343}
344
345#[inline(always)]
348pub const fn rechunk_each_array_mut<
349 T,
350 const A: usize,
351 const B: usize,
352 const C: usize,
353 const D: usize,
354 const L: usize,
355>(
356 array: &mut [[[T; A]; B]; L],
357) -> &mut [[[T; C]; D]; L] {
358 assert_same_total_len::<A, B, C, D>();
359 unsafe { &mut *ptr::from_mut(array).cast::<[[[T; C]; D]; L]>() }
362}
363
364#[inline(always)]
366const fn assert_same_total_len<const A: usize, const B: usize, const C: usize, const D: usize>() {
367 const {
368 assert!(
369 matches!(
370 (A.checked_mul(B), C.checked_mul(D)),
371 (Some(input_len), Some(output_len)) if input_len == output_len
372 ),
373 "Arrays must have the same total number of elements"
374 );
375 }
376}
377
378macro_rules! define_traits {
383 ($($const:ident)?) => {
384 pub $($const)? trait Flatten<T, const N: usize, const M: usize>: Sized {
388 fn flatten<const K: usize>(self) -> [T; K];
390
391 fn flatten_ref<const K: usize>(&self) -> &[T; K];
393
394 fn flatten_mut<const K: usize>(&mut self) -> &mut [T; K];
396 }
397
398 $($const)? impl<T, const N: usize, const M: usize> Flatten<T, N, M> for [[T; N]; M] {
399 #[inline(always)]
400 fn flatten<const K: usize>(self) -> [T; K] {
401 flatten(self)
402 }
403
404 #[inline(always)]
405 fn flatten_ref<const K: usize>(&self) -> &[T; K] {
406 flatten_ref(self)
407 }
408
409 #[inline(always)]
410 fn flatten_mut<const K: usize>(&mut self) -> &mut [T; K] {
411 flatten_mut(self)
412 }
413 }
414
415 pub $($const)? trait Rechunk<T, const N: usize, const M: usize>: Sized {
419 fn rechunk<const C: usize, const D: usize>(self) -> [[T; C]; D];
421
422 fn rechunk_ref<const C: usize, const D: usize>(&self) -> &[[T; C]; D];
424
425 fn rechunk_mut<const C: usize, const D: usize>(&mut self) -> &mut [[T; C]; D];
427 }
428
429 $($const)? impl<T, const N: usize, const M: usize> Rechunk<T, N, M> for [[T; N]; M] {
430 #[inline(always)]
431 fn rechunk<const C: usize, const D: usize>(self) -> [[T; C]; D] {
432 rechunk(self)
433 }
434
435 #[inline(always)]
436 fn rechunk_ref<const C: usize, const D: usize>(&self) -> &[[T; C]; D] {
437 rechunk_ref(self)
438 }
439
440 #[inline(always)]
441 fn rechunk_mut<const C: usize, const D: usize>(&mut self) -> &mut [[T; C]; D] {
442 rechunk_mut(self)
443 }
444 }
445
446 pub $($const)? trait Unflatten<T, const K: usize>: Sized {
450 fn unflatten<const N: usize, const M: usize>(self) -> [[T; N]; M];
452
453 fn unflatten_ref<const N: usize, const M: usize>(&self) -> &[[T; N]; M];
455
456 fn unflatten_mut<const N: usize, const M: usize>(&mut self) -> &mut [[T; N]; M];
458 }
459
460 $($const)? impl<T, const K: usize> Unflatten<T, K> for [T; K] {
461 #[inline(always)]
462 fn unflatten<const N: usize, const M: usize>(self) -> [[T; N]; M] {
463 unflatten(self)
464 }
465
466 #[inline(always)]
467 fn unflatten_ref<const N: usize, const M: usize>(&self) -> &[[T; N]; M] {
468 unflatten_ref(self)
469 }
470
471 #[inline(always)]
472 fn unflatten_mut<const N: usize, const M: usize>(&mut self) -> &mut [[T; N]; M] {
473 unflatten_mut(self)
474 }
475 }
476 pub $($const)? trait FlattenEach<T, const N: usize, const M: usize> {
482 type Flattened<const K: usize>: ?Sized;
484
485 fn flatten_each_ref<const K: usize>(&self) -> &Self::Flattened<K>;
487
488 fn flatten_each_mut<const K: usize>(&mut self) -> &mut Self::Flattened<K>;
491 }
492
493 $($const)? impl<T, const N: usize, const M: usize> FlattenEach<T, N, M> for [[[T; N]; M]] {
494 type Flattened<const K: usize> = [[T; K]];
495
496 #[inline(always)]
497 fn flatten_each_ref<const K: usize>(&self) -> &[[T; K]] {
498 flatten_each_ref(self)
499 }
500
501 #[inline(always)]
502 fn flatten_each_mut<const K: usize>(&mut self) -> &mut [[T; K]] {
503 flatten_each_mut(self)
504 }
505 }
506
507 $($const)? impl<T, const N: usize, const M: usize, const L: usize> FlattenEach<T, N, M>
508 for [[[T; N]; M]; L]
509 {
510 type Flattened<const K: usize> = [[T; K]; L];
511
512 #[inline(always)]
513 fn flatten_each_ref<const K: usize>(&self) -> &[[T; K]; L] {
514 flatten_each_array_ref(self)
515 }
516
517 #[inline(always)]
518 fn flatten_each_mut<const K: usize>(&mut self) -> &mut [[T; K]; L] {
519 flatten_each_array_mut(self)
520 }
521 }
522
523 pub $($const)? trait UnflattenEach<T, const K: usize> {
530 type Unflattened<const N: usize, const M: usize>: ?Sized;
532
533 fn unflatten_each_ref<const N: usize, const M: usize>(&self)
536 -> &Self::Unflattened<N, M>;
537
538 fn unflatten_each_mut<const N: usize, const M: usize>(
541 &mut self,
542 ) -> &mut Self::Unflattened<N, M>;
543 }
544
545 $($const)? impl<T, const K: usize> UnflattenEach<T, K> for [[T; K]] {
546 type Unflattened<const N: usize, const M: usize> = [[[T; N]; M]];
547
548 #[inline(always)]
549 fn unflatten_each_ref<const N: usize, const M: usize>(&self) -> &[[[T; N]; M]] {
550 unflatten_each_ref(self)
551 }
552
553 #[inline(always)]
554 fn unflatten_each_mut<const N: usize, const M: usize>(&mut self) -> &mut [[[T; N]; M]] {
555 unflatten_each_mut(self)
556 }
557 }
558
559 $($const)? impl<T, const K: usize, const L: usize> UnflattenEach<T, K> for [[T; K]; L] {
560 type Unflattened<const N: usize, const M: usize> = [[[T; N]; M]; L];
561
562 #[inline(always)]
563 fn unflatten_each_ref<const N: usize, const M: usize>(&self) -> &[[[T; N]; M]; L] {
564 unflatten_each_array_ref(self)
565 }
566
567 #[inline(always)]
568 fn unflatten_each_mut<const N: usize, const M: usize>(
569 &mut self,
570 ) -> &mut [[[T; N]; M]; L] {
571 unflatten_each_array_mut(self)
572 }
573 }
574
575 pub $($const)? trait RechunkEach<T, const N: usize, const M: usize> {
581 type Rechunked<const C: usize, const D: usize>: ?Sized;
583
584 fn rechunk_each_ref<const C: usize, const D: usize>(&self) -> &Self::Rechunked<C, D>;
587
588 fn rechunk_each_mut<const C: usize, const D: usize>(
591 &mut self,
592 ) -> &mut Self::Rechunked<C, D>;
593 }
594
595 $($const)? impl<T, const N: usize, const M: usize> RechunkEach<T, N, M> for [[[T; N]; M]] {
596 type Rechunked<const C: usize, const D: usize> = [[[T; C]; D]];
597
598 #[inline(always)]
599 fn rechunk_each_ref<const C: usize, const D: usize>(&self) -> &[[[T; C]; D]] {
600 rechunk_each_ref(self)
601 }
602
603 #[inline(always)]
604 fn rechunk_each_mut<const C: usize, const D: usize>(&mut self) -> &mut [[[T; C]; D]] {
605 rechunk_each_mut(self)
606 }
607 }
608
609 $($const)? impl<T, const N: usize, const M: usize, const L: usize> RechunkEach<T, N, M>
610 for [[[T; N]; M]; L]
611 {
612 type Rechunked<const C: usize, const D: usize> = [[[T; C]; D]; L];
613
614 #[inline(always)]
615 fn rechunk_each_ref<const C: usize, const D: usize>(&self) -> &[[[T; C]; D]; L] {
616 rechunk_each_array_ref(self)
617 }
618
619 #[inline(always)]
620 fn rechunk_each_mut<const C: usize, const D: usize>(
621 &mut self,
622 ) -> &mut [[[T; C]; D]; L] {
623 rechunk_each_array_mut(self)
624 }
625 }
626 };
627}
628
629#[cfg(feature = "const-trait")]
630define_traits!(const);
631#[cfg(not(feature = "const-trait"))]
632define_traits!();