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 const fn number(value: f64) -> Self {
9        Self::Number(value)
10    }
11
12    /// Check whether this value is a numeric value.
13    #[inline]
14    pub const fn is_number(self) -> bool {
15        matches!(self, Self::Number(_))
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        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}