nummap 0.5.1

Defines a wrapper around a `HashMap` of number values which behaves as if **ALL** keys are mapped but `0` values are not stored.
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

//! Author --- daniel.bechaz@gmail.com  
//! Last Moddified --- 2020-06-03

use super::*;

/// A marker trait for types which are `NonZero` numbers.
pub trait NonZero<Num,>: ToNumber<Num,> + Copy + Sized
  where Num: Number, {
  /// The optional equivelant of this
  type Optional = Option<Self>;

  /// Constructs a new value returning `None` for `0`.
  fn new(num: Num,) -> Option<Self>;
  /// Constructs a new value assuming it is not `0`.
  unsafe fn new_unchecked(num: Num,) -> Self;
}

impl NonZero<usize> for NonZeroUsize {
  #[inline]
  fn new(num: usize,) -> Option<Self> { Self::new(num,) }
  #[inline]
  unsafe fn new_unchecked(num: usize,) -> Self { Self::new_unchecked(num,) }
}

impl NonZero<u8> for NonZeroU8 {
  #[inline]
  fn new(num: u8,) -> Option<Self> { Self::new(num,) }
  #[inline]
  unsafe fn new_unchecked(num: u8,) -> Self { Self::new_unchecked(num,) }
}

impl NonZero<u16> for NonZeroU16 {
  #[inline]
  fn new(num: u16,) -> Option<Self> { Self::new(num,) }
  #[inline]
  unsafe fn new_unchecked(num: u16,) -> Self { Self::new_unchecked(num,) }
}

impl NonZero<u32> for NonZeroU32 {
  #[inline]
  fn new(num: u32,) -> Option<Self> { Self::new(num,) }
  #[inline]
  unsafe fn new_unchecked(num: u32,) -> Self { Self::new_unchecked(num,) }
}

impl NonZero<u64> for NonZeroU64 {
  #[inline]
  fn new(num: u64,) -> Option<Self> { Self::new(num,) }
  #[inline]
  unsafe fn new_unchecked(num: u64,) -> Self { Self::new_unchecked(num,) }
}

impl NonZero<u128> for NonZeroU128 {
  #[inline]
  fn new(num: u128,) -> Option<Self> { Self::new(num,) }
  #[inline]
  unsafe fn new_unchecked(num: u128,) -> Self { Self::new_unchecked(num,) }
}

impl NonZero<isize> for NonZeroIsize {
  #[inline]
  fn new(num: isize,) -> Option<Self> { Self::new(unsafe { mem::transmute(num,) },) }
  #[inline]
  unsafe fn new_unchecked(num: isize,) -> Self { mem::transmute(num,) }
}

impl NonZero<i8> for NonZeroI8 {
  #[inline]
  fn new(num: i8,) -> Option<Self> { Self::new(unsafe { mem::transmute(num,) },) }
  #[inline]
  unsafe fn new_unchecked(num: i8,) -> Self { mem::transmute(num,) }
}

impl NonZero<i16> for NonZeroI16 {
  #[inline]
  fn new(num: i16,) -> Option<Self> { Self::new(unsafe { mem::transmute(num,) },) }
  #[inline]
  unsafe fn new_unchecked(num: i16,) -> Self { mem::transmute(num,) }
}

impl NonZero<i32> for NonZeroI32 {
  #[inline]
  fn new(num: i32,) -> Option<Self> { Self::new(unsafe { mem::transmute(num,) },) }
  #[inline]
  unsafe fn new_unchecked(num: i32,) -> Self { mem::transmute(num,) }
}

impl NonZero<i64> for NonZeroI64 {
  #[inline]
  fn new(num: i64,) -> Option<Self> { Self::new(unsafe { mem::transmute(num,) },) }
  #[inline]
  unsafe fn new_unchecked(num: i64,) -> Self { mem::transmute(num,) }
}

impl NonZero<i128> for NonZeroI128 {
  #[inline]
  fn new(num: i128,) -> Option<Self> { Self::new(unsafe { mem::transmute(num,) },) }
  #[inline]
  unsafe fn new_unchecked(num: i128,) -> Self { mem::transmute(num,) }
}

impl NonZero<f32> for NonZeroU32 {
  #[inline]
  fn new(num: f32,) -> Option<Self> { Self::new(unsafe { mem::transmute(num,) },) }
  #[inline]
  unsafe fn new_unchecked(num: f32,) -> Self { mem::transmute(num,) }
}

impl NonZero<f64> for NonZeroU64 {
  #[inline]
  fn new(num: f64,) -> Option<Self> { Self::new(unsafe { mem::transmute(num,) },) }
  #[inline]
  unsafe fn new_unchecked(num: f64,) -> Self { mem::transmute(num,) }
}