const_map_array/

lib.rs

/// Create an array of uninitialized elements.
#[inline]
#[doc(hidden)]
pub const fn __array_uninit<T, const N: usize>() -> [::core::mem::MaybeUninit<T>; N] {
    [const { ::core::mem::MaybeUninit::uninit() }; N] // <- is the const { ... } here necessary?
}

// TODO: Replace with stable version when stabilized.
#[inline]
#[doc(hidden)]
pub const unsafe fn __array_assume_init<T, const N: usize>(
    array: [::core::mem::MaybeUninit<T>; N],
) -> [T; N] {
    // SAFETY: MaybeUninit<T> and T are guaranteed to have the same layout
    unsafe { ::core::mem::transmute_copy(&array) }
}

/// Provides access to the inner value of a ManuallyDrop<T>.
#[inline]
#[doc(hidden)]
pub const fn __manually_drop_inner_ref<T>(slot: &::core::mem::ManuallyDrop<T>) -> &T {
    // SAFETY: ManuallyDrop<T> and T are guaranteed to have the same layout
    unsafe { ::core::mem::transmute(slot) }
}

/// Asserts that two arrays are of the same length at compile-time.
#[inline]
#[doc(hidden)]
pub const fn __same_len<A, B, const N: usize>(_: &[A; N], _: &[B; N]) {}

/// Asserts that any number of arrays are of the same length at compile-time and returns the length as a value.
#[doc(hidden)]
#[macro_export]
macro_rules! __same_len {
    ($a:expr, $($rest:tt)*) => {{
        $crate::__same_len!(@impl $a, $($rest)*);
        $a.len()
    }};
    (@impl $a:expr, $b:expr $(,)?) => {
        $crate::__same_len($a, $b);
    };
    (@impl $a:expr, $b:expr, $($rest:tt)*) => {
        $crate::__same_len($a, $b);
        $crate::__same_len!(@impl $b, $($rest)*);
    };
}

#[macro_export]
macro_rules! const_map_array {
    (let ($($oa_pat:pat_param),+ $(,)?) = $($rest:tt)*) => {
        $crate::const_map_array!(@zip_outputs (($($oa_pat),*) ((o0a, o0), (o1a, o1), (o2a, o2), (o3a, o3), (o4a, o4), (o5a, o5), (o6a, o6), (o7a, o7), (o8a, o8), (o9a, o9), (o10a, o10), (o11a, o11)) => ()) ($($rest)*) => (multi_output) );
    };
    (let $oa_pat:pat_param = $($rest:tt)*) => {
        $crate::const_map_array!(@zip_outputs (($oa_pat) ((o0a, o0)) => ()) ($($rest)*) => (single_output) );
    };
    (@zip_outputs (() ($($_:tt),*) => ($($arg:tt)*)) ($($rest:tt)*) => $($args:tt)*) => {
        $crate::const_map_array!(@parse_inputs ($($rest)*) => $($args)* ($($arg)*));
    };
    (@zip_outputs (($($oa_pat:pat_param),+) () => ($($arg:tt)*)) ($($rest:tt)*) => $($args:tt)*) => {
        compile_error!("const_map_array only supports up to 12 outputs");
    };
    (@zip_outputs (($oa_pat_head:pat_param $(,$oa_pat_tail:pat_param)*) (($oa_head:ident, $o_head:ident) $(,($oa_tail:ident, $o_tail:ident))*) => ($(($oa_pat:pat_param, $oa:ident, $o:ident)),*)) ($($rest:tt)*) => $($args:tt)*) => {
        $crate::const_map_array!(@zip_outputs (($($oa_pat_tail),*) ($(($oa_tail, $o_tail)),*) => ($(($oa_pat, $oa, $o),)* ($oa_pat_head, $oa_head, $o_head))) ($($rest)*) => $($args)*);
    };
    (@parse_inputs (map($ia_expr:expr, |($($i_pat:pat_param),+ $(,)?)| $body:expr)) => $($args:tt)*) => {
        $crate::const_map_array!(@zip_inputs (($($i_pat),*) ((i0, i0a), (i1, i1a), (i2, i2a), (i3, i3a), (i4, i4a), (i5, i5a), (i6, i6a), (i7, i7a), (i8, i8a), (i9, i9a), (i10, i10a), (i11, i11a)) => ()) => $($args)* (multi_input) ($ia_expr) ($body));
    };
    (@parse_inputs (map($ia_expr:expr, |$i_pat:pat_param| $body:expr)) => $($args:tt)*) => {
        $crate::const_map_array!(@zip_inputs (($i_pat) ((i0, i0a)) => ()) => $($args)* (single_input) ($ia_expr) ($body));
    };
    (@zip_inputs (() ($($_:tt),*) => ($($arg:tt)*)) => $($args:tt)*) => {
        $crate::const_map_array!(@call $($args)* ($($arg)*));
    };
    (@zip_inputs (($($i_pat:pat_param),+) () => ($($arg:tt)*)) => $($args:tt)*) => {
        compile_error!("const_map_array only supports up to 12 inputs");
    };
    (@zip_inputs (($i_pat_head:pat_param $(,$i_pat_tail:pat_param)*) (($i_head:ident, $ia_head:ident) $(,($i_tail:ident, $ia_tail:ident))*) => ($(($i_pat:pat_param, $i:ident, $ia:ident)),*)) => $($args:tt)*) => {
        $crate::const_map_array!(@zip_inputs (($($i_pat_tail),*) ($(($i_tail, $ia_tail)),*) => ($(($i_pat, $i, $ia),)* ($i_pat_head, $i_head, $ia_head))) => $($args)*);
    };
    (@call ($output:tt) ($(($oa_pat:pat_param, $oa:ident, $o:ident)),*) ($input:tt) ($ia_expr:expr) ($body:expr) ($(($i_pat:pat_param, $i:ident, $ia:ident)),*)) => {
        $(
            let mut $oa = $crate::__array_uninit();
        )*

        $crate::const_map_array!(@destructure_input $input ($ia_expr) ($($ia),*));
        $(
            let $ia = ::core::mem::ManuallyDrop::<[_; _]>::new($ia);
            let $ia = $crate::__manually_drop_inner_ref(&$ia);
        )*

        let end = $crate::__same_len!($(&$oa,)* $(&$ia),*);
        let mut index = 0;
        #[allow(unreachable_code)] // hide noise when breaking (which you shouldn't)
        while index < end {
            $(
                let $i_pat = unsafe { ::core::ptr::addr_of!($ia[index]).read() };
            )*

            let item = $body;
            $crate::const_map_array!(@write_outputs $output ($(($oa, $o)),*) (index) (item));
            index += 1;
        };

        assert!(index == end, "break is not allowed because a value must be written into every array element");

        $(
            let $oa_pat = unsafe { $crate::__array_assume_init($oa) };
        )*
    };
    (@destructure_input single_input ($ia_expr:expr) ($ia:ident)) => {
        let $ia = $ia_expr;
    };
    (@destructure_input multi_input ($ia_expr:expr) ($($ia:ident),*)) => {
        ::const_destructure::const_destructure!(let ($($ia),*) = $ia_expr);
    };
    // TODO: $o is only used here, so we can zip the $o idents here in principle.
    (@write_outputs single_output (($oa:ident, $o:ident)) ($index:ident) ($item:ident)) => {
        $oa[$index].write($item);
    };
    (@write_outputs multi_output ($(($oa:ident, $o:ident)),*) ($index:ident) ($item:ident)) => {
        ::const_destructure::const_destructure!(let ($($o),*) = $item);
        $(
            $oa[$index].write($o);
        )*
    };
}