1//! Internal `#[repr(simd)]` types
2
3#![allow(non_camel_case_types)]
4
5#[inline(always)]
6#[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
7pub(crate) const unsafe fn simd_imax<T: Copy>(a: T, b: T) -> T {
8 let mask: T = crate::intrinsics::simd::simd_gt(x:a, y:b);
9 crate::intrinsics::simd::simd_select(mask, if_true:a, if_false:b)
10}
11
12#[inline(always)]
13#[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
14pub(crate) const unsafe fn simd_imin<T: Copy>(a: T, b: T) -> T {
15 let mask: T = crate::intrinsics::simd::simd_lt(x:a, y:b);
16 crate::intrinsics::simd::simd_select(mask, if_true:a, if_false:b)
17}
18
19/// SAFETY: All bits patterns must be valid
20pub(crate) unsafe trait SimdElement:
21 Copy + const PartialEq + crate::fmt::Debug
22{
23}
24
25unsafe impl SimdElement for u8 {}
26unsafe impl SimdElement for u16 {}
27unsafe impl SimdElement for u32 {}
28unsafe impl SimdElement for u64 {}
29
30unsafe impl SimdElement for i8 {}
31unsafe impl SimdElement for i16 {}
32unsafe impl SimdElement for i32 {}
33unsafe impl SimdElement for i64 {}
34
35unsafe impl SimdElement for f16 {}
36unsafe impl SimdElement for f32 {}
37unsafe impl SimdElement for f64 {}
38
39#[repr(simd)]
40#[derive(Copy)]
41pub(crate) struct Simd<T: SimdElement, const N: usize>([T; N]);
42
43impl<T: SimdElement, const N: usize> Simd<T, N> {
44 /// A value of this type where all elements are zeroed out.
45 // SAFETY: `T` implements `SimdElement`, so it is zeroable.
46 pub(crate) const ZERO: Self = unsafe { crate::mem::zeroed() };
47
48 #[inline(always)]
49 pub(crate) const fn from_array(elements: [T; N]) -> Self {
50 Self(elements)
51 }
52
53 #[inline]
54 #[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
55 pub(crate) const fn splat(value: T) -> Self {
56 unsafe { crate::intrinsics::simd::simd_splat(value) }
57 }
58
59 /// Extract the element at position `index`. Note that `index` is not a constant so this
60 /// operation is not efficient on most platforms. Use for testing only.
61 #[inline]
62 #[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
63 pub(crate) const fn extract_dyn(&self, index: usize) -> T {
64 assert!(index < N);
65 // SAFETY: self is a vector, T its element type.
66 unsafe { crate::intrinsics::simd::simd_extract_dyn(*self, index as u32) }
67 }
68
69 #[inline]
70 pub(crate) const fn as_array(&self) -> &[T; N] {
71 let simd_ptr: *const Self = self;
72 let array_ptr: *const [T; N] = simd_ptr.cast();
73 // SAFETY: We can always read the prefix of a simd type as an array.
74 // There might be more padding afterwards for some widths, but
75 // that's not a problem for reading less than that.
76 unsafe { &*array_ptr }
77 }
78}
79
80// `#[derive(Clone)]` causes ICE "Projecting into SIMD type core_arch::simd::Simd is banned by MCP#838"
81impl<T: SimdElement, const N: usize> Clone for Simd<T, N> {
82 #[inline]
83 fn clone(&self) -> Self {
84 *self
85 }
86}
87
88#[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
89impl<T: SimdElement, const N: usize> const crate::cmp::PartialEq for Simd<T, N> {
90 #[inline]
91 fn eq(&self, other: &Self) -> bool {
92 self.as_array() == other.as_array()
93 }
94}
95
96impl<T: SimdElement, const N: usize> crate::fmt::Debug for Simd<T, N> {
97 #[inline]
98 fn fmt(&self, f: &mut crate::fmt::Formatter<'_>) -> crate::fmt::Result {
99 debug_simd_finish(formatter:f, type_name:"Simd", self.as_array())
100 }
101}
102
103impl<const N: usize> Simd<f16, N> {
104 #[inline]
105 pub(crate) const fn to_bits(self) -> Simd<u16, N> {
106 assert!(size_of::<Self>() == size_of::<Simd<u16, N>>());
107 unsafe { crate::mem::transmute_copy(&self) }
108 }
109
110 #[inline]
111 pub(crate) const fn from_bits(bits: Simd<u16, N>) -> Self {
112 assert!(size_of::<Self>() == size_of::<Simd<u16, N>>());
113 unsafe { crate::mem::transmute_copy(&bits) }
114 }
115}
116
117impl<const N: usize> Simd<f32, N> {
118 #[inline]
119 pub(crate) const fn to_bits(self) -> Simd<u32, N> {
120 assert!(size_of::<Self>() == size_of::<Simd<u32, N>>());
121 unsafe { crate::mem::transmute_copy(&self) }
122 }
123
124 #[inline]
125 pub(crate) const fn from_bits(bits: Simd<u32, N>) -> Self {
126 assert!(size_of::<Self>() == size_of::<Simd<u32, N>>());
127 unsafe { crate::mem::transmute_copy(&bits) }
128 }
129}
130
131impl<const N: usize> Simd<f64, N> {
132 #[inline]
133 pub(crate) const fn to_bits(self) -> Simd<u64, N> {
134 assert!(size_of::<Self>() == size_of::<Simd<u64, N>>());
135 unsafe { crate::mem::transmute_copy(&self) }
136 }
137
138 #[inline]
139 pub(crate) const fn from_bits(bits: Simd<u64, N>) -> Self {
140 assert!(size_of::<Self>() == size_of::<Simd<u64, N>>());
141 unsafe { crate::mem::transmute_copy(&bits) }
142 }
143}
144
145macro_rules! simd_ty {
146 ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
147 pub(crate) type $id = Simd<$elem_type, $len>;
148
149 impl $id {
150 #[inline(always)]
151 pub(crate) const fn new($($param_name: $elem_type),*) -> Self {
152 Self([$($param_name),*])
153 }
154 }
155 }
156}
157
158#[repr(simd)]
159#[derive(Copy)]
160pub(crate) struct SimdM<T: SimdElement, const N: usize>([T; N]);
161
162impl<T: SimdElement, const N: usize> SimdM<T, N> {
163 #[inline(always)]
164 const fn bool_to_internal(x: bool) -> T {
165 // SAFETY: `T` implements `SimdElement`, so all bit patterns are valid.
166 let zeros = const { unsafe { crate::mem::zeroed::<T>() } };
167 let ones = const {
168 // Ideally, this would be `transmute([0xFFu8; size_of::<T>()])`, but
169 // `size_of::<T>()` is not allowed to use a generic parameter there.
170 let mut r = crate::mem::MaybeUninit::<T>::uninit();
171 let mut i = 0;
172 while i < crate::mem::size_of::<T>() {
173 r.as_bytes_mut()[i] = crate::mem::MaybeUninit::new(0xFF);
174 i += 1;
175 }
176 unsafe { r.assume_init() }
177 };
178 [zeros, ones][x as usize]
179 }
180
181 #[inline]
182 #[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
183 pub(crate) const fn splat(value: bool) -> Self {
184 unsafe { crate::intrinsics::simd::simd_splat(value) }
185 }
186
187 #[inline]
188 pub(crate) const fn as_array(&self) -> &[T; N] {
189 let simd_ptr: *const Self = self;
190 let array_ptr: *const [T; N] = simd_ptr.cast();
191 // SAFETY: We can always read the prefix of a simd type as an array.
192 // There might be more padding afterwards for some widths, but
193 // that's not a problem for reading less than that.
194 unsafe { &*array_ptr }
195 }
196}
197
198// `#[derive(Clone)]` causes ICE "Projecting into SIMD type core_arch::simd::SimdM is banned by MCP#838"
199impl<T: SimdElement, const N: usize> Clone for SimdM<T, N> {
200 #[inline]
201 fn clone(&self) -> Self {
202 *self
203 }
204}
205
206#[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
207impl<T: SimdElement, const N: usize> const crate::cmp::PartialEq for SimdM<T, N> {
208 #[inline]
209 fn eq(&self, other: &Self) -> bool {
210 self.as_array() == other.as_array()
211 }
212}
213
214impl<T: SimdElement, const N: usize> crate::fmt::Debug for SimdM<T, N> {
215 #[inline]
216 fn fmt(&self, f: &mut crate::fmt::Formatter<'_>) -> crate::fmt::Result {
217 debug_simd_finish(formatter:f, type_name:"SimdM", self.as_array())
218 }
219}
220
221macro_rules! simd_m_ty {
222 ($id:ident [$elem_type:ident ; $len:literal]: $($param_name:ident),*) => {
223 pub(crate) type $id = SimdM<$elem_type, $len>;
224
225 impl $id {
226 #[inline(always)]
227 pub(crate) const fn new($($param_name: bool),*) -> Self {
228 Self([$(Self::bool_to_internal($param_name)),*])
229 }
230 }
231 }
232}
233
234// 16-bit wide types:
235
236simd_ty!(u8x2[u8;2]: x0, x1);
237simd_ty!(i8x2[i8;2]: x0, x1);
238
239// 32-bit wide types:
240
241simd_ty!(u8x4[u8;4]: x0, x1, x2, x3);
242simd_ty!(u16x2[u16;2]: x0, x1);
243
244simd_ty!(i8x4[i8;4]: x0, x1, x2, x3);
245simd_ty!(i16x2[i16;2]: x0, x1);
246
247// 64-bit wide types:
248
249simd_ty!(
250 u8x8[u8;8]:
251 x0,
252 x1,
253 x2,
254 x3,
255 x4,
256 x5,
257 x6,
258 x7
259);
260simd_ty!(u16x4[u16;4]: x0, x1, x2, x3);
261simd_ty!(u32x2[u32;2]: x0, x1);
262simd_ty!(u64x1[u64;1]: x1);
263
264simd_ty!(
265 i8x8[i8;8]:
266 x0,
267 x1,
268 x2,
269 x3,
270 x4,
271 x5,
272 x6,
273 x7
274);
275simd_ty!(i16x4[i16;4]: x0, x1, x2, x3);
276simd_ty!(i32x2[i32;2]: x0, x1);
277simd_ty!(i64x1[i64;1]: x1);
278
279simd_ty!(f32x2[f32;2]: x0, x1);
280simd_ty!(f64x1[f64;1]: x1);
281
282// 128-bit wide types:
283
284simd_ty!(
285 u8x16[u8;16]:
286 x0,
287 x1,
288 x2,
289 x3,
290 x4,
291 x5,
292 x6,
293 x7,
294 x8,
295 x9,
296 x10,
297 x11,
298 x12,
299 x13,
300 x14,
301 x15
302);
303simd_ty!(
304 u16x8[u16;8]:
305 x0,
306 x1,
307 x2,
308 x3,
309 x4,
310 x5,
311 x6,
312 x7
313);
314simd_ty!(u32x4[u32;4]: x0, x1, x2, x3);
315simd_ty!(u64x2[u64;2]: x0, x1);
316
317simd_ty!(
318 i8x16[i8;16]:
319 x0,
320 x1,
321 x2,
322 x3,
323 x4,
324 x5,
325 x6,
326 x7,
327 x8,
328 x9,
329 x10,
330 x11,
331 x12,
332 x13,
333 x14,
334 x15
335);
336simd_ty!(
337 i16x8[i16;8]:
338 x0,
339 x1,
340 x2,
341 x3,
342 x4,
343 x5,
344 x6,
345 x7
346);
347simd_ty!(i32x4[i32;4]: x0, x1, x2, x3);
348simd_ty!(i64x2[i64;2]: x0, x1);
349
350simd_ty!(f16x4[f16;4]: x0, x1, x2, x3);
351
352simd_ty!(
353 f16x8[f16;8]:
354 x0,
355 x1,
356 x2,
357 x3,
358 x4,
359 x5,
360 x6,
361 x7
362);
363simd_ty!(f32x4[f32;4]: x0, x1, x2, x3);
364simd_ty!(f64x2[f64;2]: x0, x1);
365
366simd_m_ty!(
367 m8x16[i8;16]:
368 x0,
369 x1,
370 x2,
371 x3,
372 x4,
373 x5,
374 x6,
375 x7,
376 x8,
377 x9,
378 x10,
379 x11,
380 x12,
381 x13,
382 x14,
383 x15
384);
385simd_m_ty!(
386 m16x8[i16;8]:
387 x0,
388 x1,
389 x2,
390 x3,
391 x4,
392 x5,
393 x6,
394 x7
395);
396simd_m_ty!(m32x4[i32;4]: x0, x1, x2, x3);
397simd_m_ty!(m64x2[i64;2]: x0, x1);
398
399// 256-bit wide types:
400
401simd_ty!(
402 u8x32[u8;32]:
403 x0,
404 x1,
405 x2,
406 x3,
407 x4,
408 x5,
409 x6,
410 x7,
411 x8,
412 x9,
413 x10,
414 x11,
415 x12,
416 x13,
417 x14,
418 x15,
419 x16,
420 x17,
421 x18,
422 x19,
423 x20,
424 x21,
425 x22,
426 x23,
427 x24,
428 x25,
429 x26,
430 x27,
431 x28,
432 x29,
433 x30,
434 x31
435);
436simd_ty!(
437 u16x16[u16;16]:
438 x0,
439 x1,
440 x2,
441 x3,
442 x4,
443 x5,
444 x6,
445 x7,
446 x8,
447 x9,
448 x10,
449 x11,
450 x12,
451 x13,
452 x14,
453 x15
454);
455simd_ty!(
456 u32x8[u32;8]:
457 x0,
458 x1,
459 x2,
460 x3,
461 x4,
462 x5,
463 x6,
464 x7
465);
466simd_ty!(u64x4[u64;4]: x0, x1, x2, x3);
467
468simd_ty!(
469 i8x32[i8;32]:
470 x0,
471 x1,
472 x2,
473 x3,
474 x4,
475 x5,
476 x6,
477 x7,
478 x8,
479 x9,
480 x10,
481 x11,
482 x12,
483 x13,
484 x14,
485 x15,
486 x16,
487 x17,
488 x18,
489 x19,
490 x20,
491 x21,
492 x22,
493 x23,
494 x24,
495 x25,
496 x26,
497 x27,
498 x28,
499 x29,
500 x30,
501 x31
502);
503simd_ty!(
504 i16x16[i16;16]:
505 x0,
506 x1,
507 x2,
508 x3,
509 x4,
510 x5,
511 x6,
512 x7,
513 x8,
514 x9,
515 x10,
516 x11,
517 x12,
518 x13,
519 x14,
520 x15
521);
522simd_ty!(
523 i32x8[i32;8]:
524 x0,
525 x1,
526 x2,
527 x3,
528 x4,
529 x5,
530 x6,
531 x7
532);
533simd_ty!(i64x4[i64;4]: x0, x1, x2, x3);
534
535simd_ty!(
536 f16x16[f16;16]:
537 x0,
538 x1,
539 x2,
540 x3,
541 x4,
542 x5,
543 x6,
544 x7,
545 x8,
546 x9,
547 x10,
548 x11,
549 x12,
550 x13,
551 x14,
552 x15
553);
554simd_ty!(
555 f32x8[f32;8]:
556 x0,
557 x1,
558 x2,
559 x3,
560 x4,
561 x5,
562 x6,
563 x7
564);
565simd_ty!(f64x4[f64;4]: x0, x1, x2, x3);
566
567simd_m_ty!(
568 m8x32[i8;32]:
569 x0,
570 x1,
571 x2,
572 x3,
573 x4,
574 x5,
575 x6,
576 x7,
577 x8,
578 x9,
579 x10,
580 x11,
581 x12,
582 x13,
583 x14,
584 x15,
585 x16,
586 x17,
587 x18,
588 x19,
589 x20,
590 x21,
591 x22,
592 x23,
593 x24,
594 x25,
595 x26,
596 x27,
597 x28,
598 x29,
599 x30,
600 x31
601);
602simd_m_ty!(
603 m16x16[i16;16]:
604 x0,
605 x1,
606 x2,
607 x3,
608 x4,
609 x5,
610 x6,
611 x7,
612 x8,
613 x9,
614 x10,
615 x11,
616 x12,
617 x13,
618 x14,
619 x15
620);
621simd_m_ty!(
622 m32x8[i32;8]:
623 x0,
624 x1,
625 x2,
626 x3,
627 x4,
628 x5,
629 x6,
630 x7
631);
632
633// 512-bit wide types:
634
635simd_ty!(
636 i8x64[i8;64]:
637 x0,
638 x1,
639 x2,
640 x3,
641 x4,
642 x5,
643 x6,
644 x7,
645 x8,
646 x9,
647 x10,
648 x11,
649 x12,
650 x13,
651 x14,
652 x15,
653 x16,
654 x17,
655 x18,
656 x19,
657 x20,
658 x21,
659 x22,
660 x23,
661 x24,
662 x25,
663 x26,
664 x27,
665 x28,
666 x29,
667 x30,
668 x31,
669 x32,
670 x33,
671 x34,
672 x35,
673 x36,
674 x37,
675 x38,
676 x39,
677 x40,
678 x41,
679 x42,
680 x43,
681 x44,
682 x45,
683 x46,
684 x47,
685 x48,
686 x49,
687 x50,
688 x51,
689 x52,
690 x53,
691 x54,
692 x55,
693 x56,
694 x57,
695 x58,
696 x59,
697 x60,
698 x61,
699 x62,
700 x63
701);
702
703simd_ty!(
704 u8x64[u8;64]:
705 x0,
706 x1,
707 x2,
708 x3,
709 x4,
710 x5,
711 x6,
712 x7,
713 x8,
714 x9,
715 x10,
716 x11,
717 x12,
718 x13,
719 x14,
720 x15,
721 x16,
722 x17,
723 x18,
724 x19,
725 x20,
726 x21,
727 x22,
728 x23,
729 x24,
730 x25,
731 x26,
732 x27,
733 x28,
734 x29,
735 x30,
736 x31,
737 x32,
738 x33,
739 x34,
740 x35,
741 x36,
742 x37,
743 x38,
744 x39,
745 x40,
746 x41,
747 x42,
748 x43,
749 x44,
750 x45,
751 x46,
752 x47,
753 x48,
754 x49,
755 x50,
756 x51,
757 x52,
758 x53,
759 x54,
760 x55,
761 x56,
762 x57,
763 x58,
764 x59,
765 x60,
766 x61,
767 x62,
768 x63
769);
770
771simd_ty!(
772 i16x32[i16;32]:
773 x0,
774 x1,
775 x2,
776 x3,
777 x4,
778 x5,
779 x6,
780 x7,
781 x8,
782 x9,
783 x10,
784 x11,
785 x12,
786 x13,
787 x14,
788 x15,
789 x16,
790 x17,
791 x18,
792 x19,
793 x20,
794 x21,
795 x22,
796 x23,
797 x24,
798 x25,
799 x26,
800 x27,
801 x28,
802 x29,
803 x30,
804 x31
805);
806
807simd_ty!(
808 u16x32[u16;32]:
809 x0,
810 x1,
811 x2,
812 x3,
813 x4,
814 x5,
815 x6,
816 x7,
817 x8,
818 x9,
819 x10,
820 x11,
821 x12,
822 x13,
823 x14,
824 x15,
825 x16,
826 x17,
827 x18,
828 x19,
829 x20,
830 x21,
831 x22,
832 x23,
833 x24,
834 x25,
835 x26,
836 x27,
837 x28,
838 x29,
839 x30,
840 x31
841);
842
843simd_ty!(
844 i32x16[i32;16]:
845 x0,
846 x1,
847 x2,
848 x3,
849 x4,
850 x5,
851 x6,
852 x7,
853 x8,
854 x9,
855 x10,
856 x11,
857 x12,
858 x13,
859 x14,
860 x15
861);
862
863simd_ty!(
864 u32x16[u32;16]:
865 x0,
866 x1,
867 x2,
868 x3,
869 x4,
870 x5,
871 x6,
872 x7,
873 x8,
874 x9,
875 x10,
876 x11,
877 x12,
878 x13,
879 x14,
880 x15
881);
882
883simd_ty!(
884 f16x32[f16;32]:
885 x0,
886 x1,
887 x2,
888 x3,
889 x4,
890 x5,
891 x6,
892 x7,
893 x8,
894 x9,
895 x10,
896 x11,
897 x12,
898 x13,
899 x14,
900 x15,
901 x16,
902 x17,
903 x18,
904 x19,
905 x20,
906 x21,
907 x22,
908 x23,
909 x24,
910 x25,
911 x26,
912 x27,
913 x28,
914 x29,
915 x30,
916 x31
917);
918simd_ty!(
919 f32x16[f32;16]:
920 x0,
921 x1,
922 x2,
923 x3,
924 x4,
925 x5,
926 x6,
927 x7,
928 x8,
929 x9,
930 x10,
931 x11,
932 x12,
933 x13,
934 x14,
935 x15
936);
937
938simd_ty!(
939 i64x8[i64;8]:
940 x0,
941 x1,
942 x2,
943 x3,
944 x4,
945 x5,
946 x6,
947 x7
948);
949
950simd_ty!(
951 u64x8[u64;8]:
952 x0,
953 x1,
954 x2,
955 x3,
956 x4,
957 x5,
958 x6,
959 x7
960);
961
962simd_ty!(
963 f64x8[f64;8]:
964 x0,
965 x1,
966 x2,
967 x3,
968 x4,
969 x5,
970 x6,
971 x7
972);
973
974// 1024-bit wide types:
975simd_ty!(
976 u16x64[u16;64]:
977 x0,
978 x1,
979 x2,
980 x3,
981 x4,
982 x5,
983 x6,
984 x7,
985 x8,
986 x9,
987 x10,
988 x11,
989 x12,
990 x13,
991 x14,
992 x15,
993 x16,
994 x17,
995 x18,
996 x19,
997 x20,
998 x21,
999 x22,
1000 x23,
1001 x24,
1002 x25,
1003 x26,
1004 x27,
1005 x28,
1006 x29,
1007 x30,
1008 x31,
1009 x32,
1010 x33,
1011 x34,
1012 x35,
1013 x36,
1014 x37,
1015 x38,
1016 x39,
1017 x40,
1018 x41,
1019 x42,
1020 x43,
1021 x44,
1022 x45,
1023 x46,
1024 x47,
1025 x48,
1026 x49,
1027 x50,
1028 x51,
1029 x52,
1030 x53,
1031 x54,
1032 x55,
1033 x56,
1034 x57,
1035 x58,
1036 x59,
1037 x60,
1038 x61,
1039 x62,
1040 x63
1041);
1042simd_ty!(
1043 i32x32[i32;32]:
1044 x0,
1045 x1,
1046 x2,
1047 x3,
1048 x4,
1049 x5,
1050 x6,
1051 x7,
1052 x8,
1053 x9,
1054 x10,
1055 x11,
1056 x12,
1057 x13,
1058 x14,
1059 x15,
1060 x16,
1061 x17,
1062 x18,
1063 x19,
1064 x20,
1065 x21,
1066 x22,
1067 x23,
1068 x24,
1069 x25,
1070 x26,
1071 x27,
1072 x28,
1073 x29,
1074 x30,
1075 x31
1076);
1077simd_ty!(
1078 u32x32[u32;32]:
1079 x0,
1080 x1,
1081 x2,
1082 x3,
1083 x4,
1084 x5,
1085 x6,
1086 x7,
1087 x8,
1088 x9,
1089 x10,
1090 x11,
1091 x12,
1092 x13,
1093 x14,
1094 x15,
1095 x16,
1096 x17,
1097 x18,
1098 x19,
1099 x20,
1100 x21,
1101 x22,
1102 x23,
1103 x24,
1104 x25,
1105 x26,
1106 x27,
1107 x28,
1108 x29,
1109 x30,
1110 x31
1111);
1112
1113/// Used to continue `Debug`ging SIMD types as `MySimd(1, 2, 3, 4)`, as they
1114/// were before moving to array-based simd.
1115#[inline]
1116pub(crate) fn debug_simd_finish<T: crate::fmt::Debug, const N: usize>(
1117 formatter: &mut crate::fmt::Formatter<'_>,
1118 type_name: &str,
1119 array: &[T; N],
1120) -> crate::fmt::Result {
1121 crate::fmt::Formatter::debug_tuple_fields_finish(
1122 self:formatter,
1123 type_name,
1124 &crate::array::from_fn::<&dyn crate::fmt::Debug, N, _>(|i: usize| &array[i]),
1125 )
1126}
1127