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}