ndvec 0.1.0

Simple low-dimensional vectors
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

use std::mem::ManuallyDrop;
use std::mem::MaybeUninit;

#[inline]
fn transpose_array_of_uninit<T, const N: usize>(arr: [MaybeUninit<T>; N]) -> MaybeUninit<[T; N]> {
    debug_assert_eq!(
        std::mem::size_of::<ManuallyDrop<[MaybeUninit<T>; N]>>(),
        std::mem::size_of::<MaybeUninit<[T; N]>>()
    );
    let arr: ManuallyDrop<[MaybeUninit<T>; N]> = ManuallyDrop::new(arr);
    // SAFETY: MaybeUninit<[T; N]> and ManuallyDrop<[MaybeUninit<T>; N]> have the same layout
    unsafe { std::mem::transmute_copy(&arr) }
}

#[inline]
pub(crate) fn arr_zip_map<T, S, O, F: Fn(T, S) -> O, const N: usize>(
    a: [T; N],
    b: [S; N],
    map: F,
) -> [O; N] {
    // SAFETY: creating completely not initialized array
    let mut data: [MaybeUninit<O>; N] = unsafe { MaybeUninit::uninit().assume_init() };
    for ((v, a), b) in data.iter_mut().zip(a).zip(b) {
        v.write(map(a, b));
    }
    let data = transpose_array_of_uninit(data);
    // SAFETY: all elements has been initialized
    unsafe { data.assume_init() }
}

#[cfg(test)]
mod tests {
    use std::convert::Infallible;

    use super::arr_zip_map;

    #[test]
    fn test_arr_zip_map() {
        assert_eq!(
            arr_zip_map([5i8, 8i8], [3u16, 2u16], |a, b| a as i32 + b as i32),
            [8i32, 10i32]
        );

        assert_eq!(
            arr_zip_map(
                [(6f64, "abc".to_string()), (-12345f64, "rust".to_string())],
                [1u8, 100u8],
                |(a1, a2), b| a1 + a2.len() as f64 + b as f64
            ),
            [10f64, -12241f64]
        );

        assert_eq!(
            arr_zip_map([5i32; 0], [12f64; 0], |a, b| a as f64 + b),
            [],
            "empty case"
        );

        let never_arr: [Infallible; 0] = [];
        assert_eq!(
            arr_zip_map([12usize; 0], never_arr, |a, b| a + never_to_num(b)),
            []
        );
        assert_eq!(
            arr_zip_map(never_arr, [12usize; 0], |a, b| number_to_never(b, a)),
            []
        );
    }

    fn never_to_num(_: Infallible) -> usize {
        12
    }

    fn number_to_never(_: usize, _: Infallible) -> Infallible {
        unreachable!()
    }
}