cadd 0.2.0

Painless checked arithmetics and conversions
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use {
    crate::{convert::Cfrom, convert_impls::LimitedSliceDebug},
    alloc::{boxed::Box, rc::Rc, sync::Arc, vec::Vec},
    core::fmt::Debug,
};

impl<'a, T: Debug, const N: usize> Cfrom<&'a [T]> for &'a [T; N] {
    type Error = crate::Error;

    #[inline]
    fn cfrom(from: &'a [T]) -> Result<Self, Self::Error> {
        from.try_into()
            .map_err(|_err| slice_to_array_error(N, from))
    }
}

impl<'a, T: Debug, const N: usize> Cfrom<&'a mut [T]> for &'a mut [T; N] {
    type Error = crate::Error;

    #[inline]
    fn cfrom(from: &'a mut [T]) -> Result<Self, Self::Error> {
        // We have to do it with an extra check because of borrow checker.
        if from.len() == N {
            #[expect(
                clippy::unwrap_used,
                clippy::unwrap_in_result,
                reason = "always succeeds after length check"
            )]
            Ok(from.try_into().unwrap())
        } else {
            Err(slice_to_array_error(N, from))
        }
    }
}

impl<'a, T: Copy + Debug, const N: usize> Cfrom<&'a [T]> for [T; N] {
    type Error = crate::Error;

    #[inline]
    fn cfrom(from: &'a [T]) -> Result<Self, Self::Error> {
        from.try_into()
            .map_err(|_err| slice_to_array_error(N, from))
    }
}

impl<'a, T: Copy + Debug, const N: usize> Cfrom<&'a mut [T]> for [T; N] {
    type Error = crate::Error;

    #[inline]
    fn cfrom(from: &'a mut [T]) -> Result<Self, Self::Error> {
        from.try_into()
            .map_err(|_err| slice_to_array_error(N, from))
    }
}

macro_rules! impl_cfrom_owned_to_array {
    ($(($from:ty, $to:ty),)*) => {
        $(
            impl<T: Debug, const N: usize> Cfrom<$from> for $to {
                type Error = crate::Error;

                #[inline]
                fn cfrom(from: $from) -> Result<Self, Self::Error> {
                    if from.len() == N {
                        Ok(from.try_into().unwrap())
                    } else {
                        Err(slice_to_array_error(N, &from))
                    }
                }
            }
        )*
    };
}

fn slice_to_array_error<T: Debug>(target_len: usize, value: &[T]) -> crate::Error {
    crate::Error::new(alloc::format!(
        "expected {} items, got {:?}",
        target_len,
        LimitedSliceDebug {
            data: value,
            items_text: "items"
        },
    ))
}

impl_cfrom_owned_to_array!(
    (Rc<[T]>, Rc<[T; N]>),
    (Arc<[T]>, Arc<[T; N]>),
    (Vec<T>, [T; N]),
    (Box<[T]>, Box<[T; N]>),
    (Vec<T>, Box<[T; N]>),
);