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