mirascript_vm/value/types/
number.rs1use super::MiraValue;
2use crate::value::arena::MiraManageable;
3use crate::{MiraError, Result};
4
5impl MiraValue {
6 #[inline]
8 pub fn number(value: f64) -> Self {
9 Self::boxed_number(value)
10 }
11
12 #[inline]
14 pub fn is_number(&self) -> bool {
15 self.is_float()
16 }
17
18 #[inline]
20 pub fn as_number(&self) -> Option<f64> {
21 self.boxed_number_value()
22 }
23}
24
25macro_rules! number_from {
26 ($($ty:ty),* $(,)?) => {$ (
27 impl From<$ty> for MiraValue {
28 fn from(value: $ty) -> Self {
29 Self::number(value as f64)
30 }
31 }
32 impl From<$ty> for MiraManageable {
33 fn from(value: $ty) -> Self {
34 std::convert::Into::<MiraValue>::into(value as f64).into()
35 }
36 }
37 )* };
38}
39
40number_from!(
41 u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize, f32, f64
42);
43
44macro_rules! unsigned_integer_try_from {
45 ($($ty:ty),* $(,)?) => {$ (
46 impl TryFrom<MiraValue> for $ty {
47 type Error = Box<MiraError>;
48
49 fn try_from(value: MiraValue) -> Result<Self> {
50 let number = value.as_number().ok_or_else(|| MiraError::conversion_type(stringify!($ty), value.value_type()))?;
51 if !number.is_finite()
52 || number.trunc() != number
53 || number < 0.0
54 || number >= 2_f64.powi(<$ty>::BITS as i32)
55 {
56 return Err(MiraError::conversion_number(stringify!($ty), number));
57 }
58 Ok(number as $ty)
59 }
60 }
61 )* };
62}
63
64macro_rules! signed_integer_try_from {
65 ($($ty:ty),* $(,)?) => {$ (
66 impl TryFrom<MiraValue> for $ty {
67 type Error = Box<MiraError>;
68
69 fn try_from(value: MiraValue) -> Result<Self> {
70 let Some(number) = value.as_number() else {
71 return Err(MiraError::conversion_type(stringify!($ty), value.value_type()));
72 };
73 let limit = 2_f64.powi(<$ty>::BITS as i32 - 1);
74 if !number.is_finite()
75 || number.trunc() != number
76 || number < -limit
77 || number >= limit
78 {
79 return Err(MiraError::conversion_number(stringify!($ty), number));
80 }
81 Ok(number as $ty)
82 }
83 }
84 )* };
85}
86
87unsigned_integer_try_from!(u8, u16, u32, u64, u128, usize);
88signed_integer_try_from!(i8, i16, i32, i64, i128, isize);
89
90impl TryFrom<MiraValue> for f64 {
91 type Error = Box<MiraError>;
92
93 fn try_from(value: MiraValue) -> Result<Self> {
94 value
95 .as_number()
96 .ok_or_else(|| MiraError::conversion_type("f64", value.value_type()))
97 }
98}
99
100impl TryFrom<MiraValue> for f32 {
101 type Error = Box<MiraError>;
102
103 fn try_from(value: MiraValue) -> Result<Self> {
104 let value = f64::try_from(value)?;
105 if value.is_finite() && (value < f32::MIN as f64 || value > f32::MAX as f64) {
106 return Err(MiraError::conversion_number("f32", value));
107 }
108 Ok(value as f32)
109 }
110}
111
112#[cfg(test)]
113mod tests {
114 use super::*;
115
116 #[test]
117 fn test_number() {
118 assert_eq!(MiraValue::number(42.0), MiraValue::number(42.0));
119 }
120
121 #[test]
122 fn test_number_is_number() {
123 assert!(MiraValue::number(42.0).is_number());
124 assert!(!MiraValue::nil().is_number());
125 }
126
127 #[test]
128 fn test_number_as_number() {
129 assert_eq!(MiraValue::number(42.0).as_number(), Some(42.0));
130 assert_eq!(MiraValue::nil().as_number(), None);
131 }
132
133 #[test]
134 fn test_number_try_from() {
135 let value = MiraValue::number(42.0);
136 assert_eq!(u8::try_from(value).unwrap(), 42u8);
137 assert_eq!(i32::try_from(value).unwrap(), 42i32);
138 assert_eq!(u128::try_from(value).unwrap(), 42u128);
139 assert_eq!(f32::try_from(value).unwrap(), 42f32);
140 assert_eq!(f64::try_from(value).unwrap(), 42f64);
141 }
142 #[test]
143 fn test_number_try_from_underflow() {
144 let value = MiraValue::number(-1.0);
145 assert!(u8::try_from(value).is_err());
146 assert!(u32::try_from(value).is_err());
147 assert!(u128::try_from(value).is_err());
148 }
149
150 #[test]
151 fn test_number_try_from_overflow() {
152 let value = MiraValue::number(256.0);
153 assert!(u8::try_from(value).is_err());
154 let value = MiraValue::number(2_f64.powi(32));
155 assert!(u32::try_from(value).is_err());
156 let value = MiraValue::number(2_f64.powi(128));
157 assert!(u128::try_from(value).is_err());
158 let value = MiraValue::number(f64::MAX);
159 assert!(f32::try_from(value).is_err());
160 }
161
162 #[test]
163 fn test_number_try_from_non_integer() {
164 let value = MiraValue::number(42.5);
165 assert!(u8::try_from(value).is_err());
166 assert!(i32::try_from(value).is_err());
167 assert!(u128::try_from(value).is_err());
168 }
169
170 #[test]
171 fn test_number_try_from_non_finite() {
172 let value = MiraValue::number(f64::INFINITY);
173 assert!(u8::try_from(value).is_err());
174 assert!(i32::try_from(value).is_err());
175 assert!(u128::try_from(value).is_err());
176 let value = MiraValue::number(f64::NAN);
177 assert!(u8::try_from(value).is_err());
178 assert!(i32::try_from(value).is_err());
179 assert!(u128::try_from(value).is_err());
180 }
181
182 #[test]
183 fn test_number_try_from_non_number() {
184 assert!(f64::try_from(MiraValue::nil()).is_err());
185
186 let value = MiraValue::boolean(true);
187 assert!(u8::try_from(value).is_err());
188 assert!(i32::try_from(value).is_err());
189 assert!(u128::try_from(value).is_err());
190
191 let value = MiraValue::str(&"42");
192 assert!(u8::try_from(value).is_err());
193 assert!(f64::try_from(value).is_err());
194 }
195
196 #[test]
197 fn test_number_try_from_negative_zero() {
198 let value = MiraValue::number(-0.0);
199 assert_eq!(u8::try_from(value).unwrap(), 0u8);
200 assert_eq!(i32::try_from(value).unwrap(), 0i32);
201 assert_eq!(u128::try_from(value).unwrap(), 0u128);
202 assert_eq!(f32::try_from(value).unwrap(), -0.0f32);
203 assert_eq!(f64::try_from(value).unwrap(), -0.0f64);
204 }
205
206 #[test]
207 fn test_number_into() {
208 assert_eq!(MiraValue::from(42u8), MiraValue::number(42.0));
209 assert_eq!(MiraValue::from(42i32), MiraValue::number(42.0));
210 assert_eq!(MiraValue::from(42u128), MiraValue::number(42.0));
211 assert_eq!(MiraValue::from(42f32), MiraValue::number(42.0));
212 assert_eq!(MiraValue::from(42f64), MiraValue::number(42.0));
213 }
214}