mirascript_vm/value/types/
number.rs1use super::{MiraValue, value::RawValue};
2use crate::{MiraError, Result, Runtime, TryFromMira};
3
4impl MiraValue {
5 #[inline]
7 pub const fn number(value: f64) -> Self {
8 Self::from_raw(RawValue::from_number(value))
9 }
10
11 pub const ZERO: MiraValue = MiraValue::number(0.0);
13 pub const ONE: MiraValue = MiraValue::number(1.0);
15 pub const NEGATIVE_ONE: MiraValue = MiraValue::number(-1.0);
17 pub const NAN: MiraValue = MiraValue::number(f64::NAN);
19
20 #[inline]
22 pub const fn is_number(&self) -> bool {
23 self.tag().is_none()
24 }
25
26 #[inline]
28 pub const fn as_number(&self) -> Option<f64> {
29 if self.is_number() {
30 Some(self.as_number_unchecked())
31 } else {
32 None
33 }
34 }
35 #[inline]
37 pub const fn as_number_unchecked(self) -> f64 {
38 debug_assert!(self.is_number(), "MiraValue is not a number");
39 self.raw().number()
40 }
41}
42
43macro_rules! number_from {
44 ($($ty:ty),* $(,)?) => {$ (
45 impl From<$ty> for MiraValue {
46 fn from(value: $ty) -> Self {
47 Self::number(value as f64)
48 }
49 }
50 )* };
51}
52
53number_from!(
54 u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize, f32, f64
55);
56
57macro_rules! integer_try_from {
58 ($($ty:ty),* $(,)?) => {$ (
59 impl TryFrom<MiraValue> for $ty {
60 type Error = Box<MiraError>;
61
62 fn try_from(value: MiraValue) -> Result<Self> {
63 let Some(number) = value.as_number() else {
64 return Err(MiraError::conversion_type(stringify!($ty), value.value_type()));
65 };
66 if !number.is_finite()
67 || number.trunc() != number
68 || number < (<$ty>::MIN as f64)
69 || number > (<$ty>::MAX as f64)
70 {
71 return Err(MiraError::conversion_number(stringify!($ty), number));
72 }
73 Ok(number as $ty)
74 }
75 }
76
77 impl TryFromMira<'_> for $ty {
78 fn from_mira(_runtime: &Runtime, value: MiraValue) -> Result<Self> {
79 Self::try_from(value)
80 }
81 }
82 )* };
83}
84integer_try_from!(
85 u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize
86);
87
88impl TryFrom<MiraValue> for f64 {
89 type Error = Box<MiraError>;
90
91 fn try_from(value: MiraValue) -> Result<Self> {
92 value
93 .as_number()
94 .ok_or_else(|| MiraError::conversion_type("f64", value.value_type()))
95 }
96}
97
98impl TryFromMira<'_> for f64 {
99 fn from_mira(_runtime: &Runtime, value: MiraValue) -> Result<Self> {
100 f64::try_from(value)
101 }
102}
103
104impl TryFrom<MiraValue> for f32 {
105 type Error = Box<MiraError>;
106
107 fn try_from(value: MiraValue) -> Result<Self> {
108 let value = f64::try_from(value)?;
109 if value.is_finite() && (value < f32::MIN as f64 || value > f32::MAX as f64) {
110 return Err(MiraError::conversion_number("f32", value));
111 }
112 Ok(value as f32)
113 }
114}
115
116impl TryFromMira<'_> for f32 {
117 fn from_mira(_runtime: &Runtime, value: MiraValue) -> Result<Self> {
118 f32::try_from(value)
119 }
120}
121
122#[cfg(test)]
123mod tests {
124
125 use super::*;
126
127 #[test]
128 fn test_number() {
129 assert_eq!(MiraValue::number(42.0), MiraValue::number(42.0));
130 }
131
132 #[test]
133 fn test_number_is_number() {
134 assert!(MiraValue::number(42.0).is_number());
135 assert!(!MiraValue::NIL.is_number());
136 }
137
138 #[test]
139 fn test_number_as_number() {
140 assert_eq!(MiraValue::number(42.0).as_number(), Some(42.0));
141 assert_eq!(MiraValue::NIL.as_number(), None);
142 }
143
144 #[test]
145 fn test_number_try_from() {
146 let value = MiraValue::number(42.0);
147 assert_eq!(u8::try_from(value).unwrap(), 42u8);
148 assert_eq!(i32::try_from(value).unwrap(), 42i32);
149 assert_eq!(u128::try_from(value).unwrap(), 42u128);
150 assert_eq!(f32::try_from(value).unwrap(), 42f32);
151 assert_eq!(f64::try_from(value).unwrap(), 42f64);
152 }
153 #[test]
154 fn test_number_from_mira() {
155 let runtime = Runtime::new();
156 let value = MiraValue::number(42.0);
157 assert_eq!(u8::from_mira(&runtime, value).unwrap(), 42u8);
158 assert_eq!(i32::from_mira(&runtime, value).unwrap(), 42i32);
159 assert_eq!(u128::from_mira(&runtime, value).unwrap(), 42u128);
160 assert_eq!(f32::from_mira(&runtime, value).unwrap(), 42f32);
161 assert_eq!(f64::from_mira(&runtime, value).unwrap(), 42f64);
162 }
163 #[test]
164 fn test_number_try_from_underflow() {
165 let value = MiraValue::number(-1.0);
166 assert!(u8::try_from(value).is_err());
167 assert!(u32::try_from(value).is_err());
168 assert!(u128::try_from(value).is_err());
169 }
170
171 #[test]
172 fn test_number_try_from_overflow() {
173 let value = MiraValue::number(256.0);
174
175 assert!(dbg!(u8::try_from(value)).is_err());
176 let value = MiraValue::number(u32::MAX as f64 * 1.1);
177 assert!(dbg!(u32::try_from(value)).is_err());
178 let value = MiraValue::number(u128::MAX as f64 * 1.1);
179 assert!(dbg!(u128::try_from(value)).is_err());
180 let value = MiraValue::number(f32::MAX as f64 * 1.1);
181 assert!(f32::try_from(value).is_err());
182 }
183
184 #[test]
185 fn test_number_try_from_non_integer() {
186 let value = MiraValue::number(42.5);
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
192 #[test]
193 fn test_number_try_from_non_finite() {
194 let value = MiraValue::number(f64::INFINITY);
195 assert!(u8::try_from(value).is_err());
196 assert!(i32::try_from(value).is_err());
197 assert!(u128::try_from(value).is_err());
198 let value = MiraValue::number(f64::NAN);
199 assert!(u8::try_from(value).is_err());
200 assert!(i32::try_from(value).is_err());
201 assert!(u128::try_from(value).is_err());
202 }
203
204 #[test]
205 fn test_number_try_from_non_number() {
206 assert!(f64::try_from(MiraValue::NIL).is_err());
207
208 let value = MiraValue::boolean(true);
209 assert!(u8::try_from(value).is_err());
210 assert!(i32::try_from(value).is_err());
211 assert!(u128::try_from(value).is_err());
212
213 let value = MiraValue::str(&"42");
214 assert!(u8::try_from(value).is_err());
215 assert!(f64::try_from(value).is_err());
216 }
217
218 #[test]
219 fn test_number_try_from_negative_zero() {
220 let value = MiraValue::number(-0.0);
221 assert_eq!(u8::try_from(value).unwrap(), 0u8);
222 assert_eq!(i32::try_from(value).unwrap(), 0i32);
223 assert_eq!(u128::try_from(value).unwrap(), 0u128);
224 assert_eq!(f32::try_from(value).unwrap(), -0.0f32);
225 assert_eq!(f64::try_from(value).unwrap(), -0.0f64);
226 }
227
228 #[test]
229 fn test_number_into() {
230 assert_eq!(MiraValue::from(42u8), MiraValue::number(42.0));
231 assert_eq!(MiraValue::from(42i32), MiraValue::number(42.0));
232 assert_eq!(MiraValue::from(42u128), MiraValue::number(42.0));
233 assert_eq!(MiraValue::from(42f32), MiraValue::number(42.0));
234 assert_eq!(MiraValue::from(42f64), MiraValue::number(42.0));
235 }
236}