Skip to main content

mirascript_vm/value/
convert.rs

1use std::collections::{BTreeMap, HashMap};
2use std::hash::{BuildHasher, Hash};
3
4use indexmap::IndexMap;
5
6use crate::{MiraError, Result};
7
8use super::{MiraAny, MiraBridge, MiraFunction, MiraModule, MiraNativeFn, MiraShared};
9
10impl From<()> for MiraAny {
11    fn from(_: ()) -> Self {
12        Self::Nil
13    }
14}
15
16impl From<bool> for MiraAny {
17    fn from(value: bool) -> Self {
18        Self::Boolean(value)
19    }
20}
21
22impl From<String> for MiraAny {
23    fn from(value: String) -> Self {
24        Self::String(value)
25    }
26}
27
28impl From<&str> for MiraAny {
29    fn from(value: &str) -> Self {
30        Self::String(value.to_owned())
31    }
32}
33
34macro_rules! number_from {
35    ($($ty:ty),* $(,)?) => {$ (
36        impl From<$ty> for MiraAny {
37            fn from(value: $ty) -> Self {
38                Self::Number(value as f64)
39            }
40        }
41    )* };
42}
43
44number_from!(u8, u16, u32, u64, usize, i8, i16, i32, i64, isize, f32, f64);
45
46impl<T: Into<MiraAny>> From<Option<T>> for MiraAny {
47    fn from(value: Option<T>) -> Self {
48        value.map(Into::into).unwrap_or(Self::Nil)
49    }
50}
51
52impl<T: Into<MiraAny>> From<Vec<T>> for MiraAny {
53    fn from(value: Vec<T>) -> Self {
54        Self::Array(value.into_iter().map(Into::into).collect())
55    }
56}
57
58impl<T: Into<MiraAny>, const N: usize> From<[T; N]> for MiraAny {
59    fn from(value: [T; N]) -> Self {
60        Self::Array(value.into_iter().map(Into::into).collect())
61    }
62}
63
64impl<T: Into<MiraAny>> From<IndexMap<String, T>> for MiraAny {
65    fn from(value: IndexMap<String, T>) -> Self {
66        Self::Record(
67            value
68                .into_iter()
69                .map(|(key, value)| (key, value.into()))
70                .collect(),
71        )
72    }
73}
74
75impl<K, T, S> From<HashMap<K, T, S>> for MiraAny
76where
77    K: Into<String> + Eq + Hash,
78    T: Into<MiraAny>,
79    S: BuildHasher,
80{
81    fn from(value: HashMap<K, T, S>) -> Self {
82        let mut entries: Vec<_> = value
83            .into_iter()
84            .map(|(key, value)| (key.into(), value.into()))
85            .collect();
86        entries.sort_by(|a, b| a.0.cmp(&b.0));
87        Self::Record(entries.into_iter().collect())
88    }
89}
90
91impl<K, T> From<BTreeMap<K, T>> for MiraAny
92where
93    K: Into<String> + Ord,
94    T: Into<MiraAny>,
95{
96    fn from(value: BTreeMap<K, T>) -> Self {
97        Self::Record(
98            value
99                .into_iter()
100                .map(|(key, value)| (key.into(), value.into()))
101                .collect(),
102        )
103    }
104}
105
106impl From<MiraNativeFn> for MiraAny {
107    fn from(value: MiraNativeFn) -> Self {
108        Self::Function(MiraFunction::Native(value))
109    }
110}
111
112impl From<MiraModule> for MiraAny {
113    fn from(value: MiraModule) -> Self {
114        Self::Module(value)
115    }
116}
117
118impl<T: MiraBridge> From<MiraShared<T>> for MiraAny {
119    fn from(value: MiraShared<T>) -> Self {
120        T::into_mira_shared(value)
121    }
122}
123
124impl TryFrom<MiraAny> for bool {
125    type Error = MiraError;
126
127    fn try_from(value: MiraAny) -> Result<Self> {
128        match value {
129            MiraAny::Boolean(value) => Ok(value),
130            value => Err(MiraError::conversion("bool", &value)),
131        }
132    }
133}
134
135impl TryFrom<MiraAny> for String {
136    type Error = MiraError;
137
138    fn try_from(value: MiraAny) -> Result<Self> {
139        match value {
140            MiraAny::String(value) => Ok(value),
141            value => Err(MiraError::conversion("String", &value)),
142        }
143    }
144}
145
146impl<T> TryFrom<MiraAny> for Option<T>
147where
148    T: TryFrom<MiraAny, Error = MiraError>,
149{
150    type Error = MiraError;
151
152    fn try_from(value: MiraAny) -> Result<Self> {
153        if value == MiraAny::Nil {
154            Ok(None)
155        } else {
156            T::try_from(value).map(Some)
157        }
158    }
159}
160
161impl<T> TryFrom<MiraAny> for Vec<T>
162where
163    T: TryFrom<MiraAny, Error = MiraError>,
164{
165    type Error = MiraError;
166
167    fn try_from(value: MiraAny) -> Result<Self> {
168        let MiraAny::Array(values) = value else {
169            return Err(MiraError::conversion("Vec", &value));
170        };
171        values
172            .into_iter()
173            .enumerate()
174            .map(|(index, value)| {
175                T::try_from(value).map_err(|error| error.at_path(index.to_string()))
176            })
177            .collect()
178    }
179}
180
181impl<T, const N: usize> TryFrom<MiraAny> for [T; N]
182where
183    T: TryFrom<MiraAny, Error = MiraError>,
184{
185    type Error = MiraError;
186
187    fn try_from(value: MiraAny) -> Result<Self> {
188        let values = Vec::<T>::try_from(value)?;
189        let actual = values.len();
190        values.try_into().map_err(|_| MiraError::Conversion {
191            expected: format!("array of length {N}"),
192            actual: format!("array of length {actual}"),
193            path: None,
194        })
195    }
196}
197
198impl<T> TryFrom<MiraAny> for IndexMap<String, T>
199where
200    T: TryFrom<MiraAny, Error = MiraError>,
201{
202    type Error = MiraError;
203
204    fn try_from(value: MiraAny) -> Result<Self> {
205        let MiraAny::Record(values) = value else {
206            return Err(MiraError::conversion("record", &value));
207        };
208        values
209            .into_iter()
210            .map(|(key, value)| {
211                T::try_from(value)
212                    .map(|value| (key.clone(), value))
213                    .map_err(|error| error.at_path(key))
214            })
215            .collect()
216    }
217}
218
219macro_rules! unsigned_integer_try_from {
220    ($($ty:ty),* $(,)?) => {$ (
221        impl TryFrom<MiraAny> for $ty {
222            type Error = MiraError;
223
224            fn try_from(value: MiraAny) -> Result<Self> {
225                let MiraAny::Number(number) = value else {
226                    return Err(MiraError::conversion(stringify!($ty), &value));
227                };
228                if !number.is_finite()
229                    || number.trunc() != number
230                    || number < 0.0
231                    || number >= 2_f64.powi(<$ty>::BITS as i32)
232                {
233                    return Err(MiraError::Conversion {
234                        expected: stringify!($ty).into(),
235                        actual: format!("number {number}"),
236                        path: None,
237                    });
238                }
239                Ok(number as $ty)
240            }
241        }
242    )* };
243}
244
245macro_rules! signed_integer_try_from {
246    ($($ty:ty),* $(,)?) => {$ (
247        impl TryFrom<MiraAny> for $ty {
248            type Error = MiraError;
249
250            fn try_from(value: MiraAny) -> Result<Self> {
251                let MiraAny::Number(number) = value else {
252                    return Err(MiraError::conversion(stringify!($ty), &value));
253                };
254                let limit = 2_f64.powi(<$ty>::BITS as i32 - 1);
255                if !number.is_finite()
256                    || number.trunc() != number
257                    || number < -limit
258                    || number >= limit
259                {
260                    return Err(MiraError::Conversion {
261                        expected: stringify!($ty).into(),
262                        actual: format!("number {number}"),
263                        path: None,
264                    });
265                }
266                Ok(number as $ty)
267            }
268        }
269    )* };
270}
271
272unsigned_integer_try_from!(u8, u16, u32, u64, usize);
273signed_integer_try_from!(i8, i16, i32, i64, isize);
274
275impl TryFrom<MiraAny> for f64 {
276    type Error = MiraError;
277
278    fn try_from(value: MiraAny) -> Result<Self> {
279        match value {
280            MiraAny::Number(value) => Ok(value),
281            value => Err(MiraError::conversion("f64", &value)),
282        }
283    }
284}
285
286impl TryFrom<MiraAny> for f32 {
287    type Error = MiraError;
288
289    fn try_from(value: MiraAny) -> Result<Self> {
290        let value = f64::try_from(value)?;
291        if value.is_finite() && (value < f32::MIN as f64 || value > f32::MAX as f64) {
292            return Err(MiraError::Conversion {
293                expected: "f32".into(),
294                actual: format!("number {value}"),
295                path: None,
296            });
297        }
298        Ok(value as f32)
299    }
300}