newnum 0.13.1

Deprecated: General-purpose number traits
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

use std::fmt::{Debug, Display};

use crate::*;

mod float;
mod int;
mod signed;
mod sint;
mod uint;
mod unsigned;
pub use float::*;
pub use int::*;
pub use signed::*;
pub use sint::*;
pub use uint::*;
pub use unsigned::*;

/// Trait for number primitives (```u8```, ```i32```, ```f64```...).
///
/// Can be implemented by non ```std``` types that follow the primitive rules:
/// * Can represent 0..=127
/// * ```Default``` returns ```0```
/// * implements ```Send + Sync + Debug + Display + Copy```
/// * Can be failibly converted to any std primitive
pub trait Prim:
    Num
    + Positive
    + Zero
    + Signum
    + AsPrim
    + WholeEquivalent
    + TruncRoot
    + Send
    + Sync
    + Debug
    + Display
    + Clone
    + Copy
    + Default
{
    fn from_num<T: Prim>(value: T) -> Self;
}

macro_rules! code_for_prims {
    ($($type:ident($as_fn:ident),)*) => {
        code_for_prims!($ident $($type($as_fn),)*);
    };
    ($dollar:tt $_:ident $($type:ident($as_fn:ident),)*) => {
        pub trait AsPrim: Sized {
            $(
                fn $as_fn(self) -> $type;
            )*

            fn as_num<T: Prim>(self) -> T where Self: Prim {
                T::from_num(self)
            }
        }

        $(
            impl Prim for $type {
                #[inline(always)]
                fn from_num<T: AsPrim>(value: T) -> Self {
                    value.$as_fn()
                }
            }
        )*

        macro_rules! impl_as_Prims {
            ($dollar($type2:ident($as_fn2:ident),)*) => {$(
                impl AsPrim for $type {
                    $dollar(
                        fn $as_fn2(self) -> $type2 {
                            self as _
                        }
                    )*
                }
            )*}
        }
        impl_as_Prims!($($type($as_fn),)*);
    };
}
code_for_prims!(
    u8(as_u8),
    u16(as_u16),
    u32(as_u32),
    u64(as_u64),
    u128(as_u128),
    usize(as_usize),
    i8(as_i8),
    i16(as_i16),
    i32(as_i32),
    i64(as_i64),
    i128(as_i128),
    isize(as_isize),
    f32(as_f32),
    f64(as_f64),
);