nbyte-int 0.0.4

any byte sized increment of a number
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use super::types::*;
use core::num::TryFromIntError;

#[cold]
#[inline(always)]
fn neg_overflow() -> TryFromIntError {
    match u8::try_from(-1_i8) {
        Err(err) => err,
        // this runs at runtime, don't panic
        Ok(_) => unsafe { core::hint::unreachable_unchecked() },
    }
}

#[cold]
#[inline(always)]
fn pos_overflow() -> TryFromIntError {
    match u8::try_from(256_u16) {
        Err(err) => err,
        // this runs at runtime, don't panic
        Ok(_) => unsafe { core::hint::unreachable_unchecked() },
    }
}

// `P` = primitive, `C` = custom; the value of a custom int is its backing type
macro_rules! to_val {
    (P $x:expr) => {
        $x
    };
    (C $x:expr) => {
        $x.get()
    };
}

macro_rules! lossless {
    // primitive <-> primitive already exists in core
    (P $s:ident $sb:ident => P $d:ident $db:ident) => {};

    ($sk:ident $s:ident $sb:ident => P $d:ident $db:ident) => {
        impl From<$s> for $d {
            #[inline(always)]
            fn from(x: $s) -> Self {
                to_val!($sk x) as $d
            }
        }
    };

    ($sk:ident $s:ident $sb:ident => C $d:ident $db:ident) => {
        impl From<$s> for $d {
            #[inline(always)]
            fn from(x: $s) -> Self {
                // `as` sign/zero extends, and the value is known to fit
                unsafe { <$d>::new_unchecked(to_val!($sk x) as $db) }
            }
        }
    };
}

macro_rules! fallible {
    (P $s:ident $sb:ident => P $d:ident $db:ident) => {};

    ($sk:ident $s:ident $sb:ident => $dk:ident $d:ident $db:ident) => {
        impl TryFrom<$s> for $d {
            type Error = TryFromIntError;

            #[inline]
            fn try_from(x: $s) -> Result<Self, Self::Error> {
                // step 1: source value -> destination's backing primitive
                // (the error is `Infallible` when that step is lossless)
                match <$db as TryFrom<$sb>>::try_from(to_val!($sk x)) {
                    Ok(v) => fallible!(@finish $dk $d v; $db),
                    Err(err) => Err(TryFromIntError::from(err)),
                }
            }
        }
    };
    // step 2: backing primitive -> destination
    (@finish P $d:ident $v:ident; $db: ident) => { Ok($v) };

    (@finish C $d:ident $v:ident; $db: ident) => {{
        const MIN: $db = $d::MIN.get();
        const MAX: $db = $d::MAX.get();

        // Note: we can't use a match stmt in a neat way
        // because of unsigned values since
        // ..MIN is an invalid range (its empty) and emits a compile error

        let value = $v;
        if value < MIN {
            Err(neg_overflow())
        } else if value > MAX {
            Err(pos_overflow())
        } else {
            Ok(unsafe { $d::new_unchecked(value) })
        }
    }};
}

macro_rules! conv_pair {
    // `s` is strictly narrower than `b`
    (
        ($sk:ident $si:ident $su:ident as $sib:ident $sub:ident)
        ($bk:ident $bi:ident $bu:ident as $bib:ident $bub:ident)
    ) => {
        // widening
        lossless! { $sk $si $sib => $bk $bi $bib } // iN -> iM
        lossless! { $sk $su $sub => $bk $bu $bub } // uN -> uM
        lossless! { $sk $su $sub => $bk $bi $bib } // uN -> iM
        fallible! { $sk $si $sib => $bk $bu $bub } // iN -> uM (negatives)

        // narrowing
        fallible! { $bk $bi $bib => $sk $si $sib }
        fallible! { $bk $bi $bib => $sk $su $sub }
        fallible! { $bk $bu $bub => $sk $si $sib }
        fallible! { $bk $bu $bub => $sk $su $sub }
    };
}

macro_rules! conversions {
    () => {};
    (
        ($k:ident $i:ident $u:ident as $ib:ident $ub:ident)
        $($rest:tt)*
    ) => {
        // same width, different sign
        fallible! { $k $i $ib => $k $u $ub }
        fallible! { $k $u $ub => $k $i $ib }

        $(conv_pair! { ($k $i $u as $ib $ub) $rest })*

        conversions! { $($rest)* }
    };
}

// MUST be sorted by ascending bit-width
conversions! {
    (P i8   u8   as i8   u8)
    (P i16  u16  as i16  u16)
    (C i24  u24  as i32  u32)
    (P i32  u32  as i32  u32)
    (C i40  u40  as i64  u64)
    (C i48  u48  as i64  u64)
    (C i56  u56  as i64  u64)
    (P i64  u64  as i64  u64)
    (C i72  u72  as i128 u128)
    (C i80  u80  as i128 u128)
    (C i88  u88  as i128 u128)
    (C i96  u96  as i128 u128)
    (C i104 u104 as i128 u128)
    (C i112 u112 as i128 u128)
    (C i120 u120 as i128 u128)
    (P i128 u128 as i128 u128)
}