cadd 0.1.1

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
93
94
95
96
97
98
99
100
101
102
103
104

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

struct SliceLimitedDebug<'a, T>(&'a [T]);

impl<'a, T: Debug> Debug for SliceLimitedDebug<'a, T> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        const MAX_ITEMS: usize = 32;
        if self.0.len() > MAX_ITEMS {
            let mut list = f.debug_list();
            for item in &self.0[0..MAX_ITEMS / 2] {
                list.entry(item);
            }
            // TODO: avoid quotes in "..."
            list.entry(&"...");
            for item in &self.0[self.0.len() - MAX_ITEMS / 2..] {
                list.entry(item);
            }
            list.finish()
        } else {
            write!(f, "{:?}", self.0)
        }
    }
}

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(|_| 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 {
            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(|_| 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(|_| 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 slice of length {}, got length {}: {:?}",
        target_len,
        value.len(),
        SliceLimitedDebug(value),
    ))
}

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]>),
);