Skip to main content

mirascript_vm/value/types/
number.rs

1use super::MiraValue;
2use crate::value::arena::MiraManageable;
3use crate::{MiraError, Result};
4
5impl MiraValue {
6    /// Create a `MiraValue` representing a numeric value.
7    #[inline]
8    pub fn number(value: f64) -> Self {
9        Self::boxed_number(value)
10    }
11
12    /// Check whether this value is a numeric value.
13    #[inline]
14    pub fn is_number(&self) -> bool {
15        self.is_float()
16    }
17
18    /// Return the inline numeric payload, or `None` for another value type.
19    #[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}