rune/core/object/
convert.rs

Help
1//! This module holds implementation of conversion functions. Much of
2//! this code could be replaced with macros or specialized generics if
3//! those are ever stabalized.
4
5use crate::data::LispError;
6
7use super::{
8    super::error::{Type, TypeError},
9    ByteString, CharTable, LispHashTable, LispString, LispVec, NIL, OptionalFlag, TRUE,
10};
11use super::{Gc, LispFloat, Object, ObjectType, Symbol};
12use anyhow::Context;
13
14impl<'ob> TryFrom<Object<'ob>> for &'ob str {
15    type Error = anyhow::Error;
16    fn try_from(obj: Object<'ob>) -> Result<Self, Self::Error> {
17        match obj.untag() {
18            ObjectType::String(x) => Ok(x),
19            x => Err(TypeError::new(Type::String, x).into()),
20        }
21    }
22}
23
24impl TryFrom<Object<'_>> for f64 {
25    type Error = TypeError;
26    fn try_from(obj: Object) -> Result<Self, Self::Error> {
27        match obj.untag() {
28            ObjectType::Int(x) => Ok(x as f64),
29            ObjectType::Float(x) => Ok(**x),
30            x => Err(TypeError::new(Type::Number, x)),
31        }
32    }
33}
34
35impl<'ob> TryFrom<Object<'ob>> for Option<&'ob str> {
36    type Error = TypeError;
37    fn try_from(obj: Object<'ob>) -> Result<Self, Self::Error> {
38        match obj.untag() {
39            ObjectType::NIL => Ok(None),
40            ObjectType::String(x) => Ok(Some(x)),
41            x => Err(TypeError::new(Type::String, x)),
42        }
43    }
44}
45
46impl<'ob> TryFrom<Object<'ob>> for usize {
47    type Error = anyhow::Error;
48    fn try_from(obj: Object<'ob>) -> Result<Self, Self::Error> {
49        match obj.untag() {
50            ObjectType::Int(x) => {
51                x.try_into().with_context(|| format!("Integer must be positive, but was {x}"))
52            }
53            x => Err(TypeError::new(Type::Int, x).into()),
54        }
55    }
56}
57
58impl<'ob> TryFrom<Object<'ob>> for char {
59    type Error = TypeError;
60    fn try_from(obj: Object<'ob>) -> Result<Self, Self::Error> {
61        let err = || TypeError::new(Type::Char, obj);
62        let ObjectType::Int(x) = obj.untag() else { Err(err())? };
63        let Ok(x) = u32::try_from(x) else { Err(err())? };
64        std::char::from_u32(x).ok_or_else(err)
65    }
66}
67
68impl<'ob> TryFrom<Object<'ob>> for Option<usize> {
69    type Error = anyhow::Error;
70    fn try_from(obj: Object<'ob>) -> Result<Self, Self::Error> {
71        match obj.untag() {
72            ObjectType::Int(x) => match x.try_into() {
73                Ok(x) => Ok(Some(x)),
74                Err(e) => Err(e).with_context(|| format!("Integer must be positive, but was {x}")),
75            },
76            ObjectType::NIL => Ok(None),
77            _ => Err(TypeError::new(Type::Int, obj).into()),
78        }
79    }
80}
81
82impl TryFrom<Object<'_>> for bool {
83    type Error = LispError;
84    fn try_from(obj: Object) -> Result<Self, Self::Error> {
85        Ok(obj.is_nil())
86    }
87}
88
89impl TryFrom<Object<'_>> for OptionalFlag {
90    type Error = LispError;
91    fn try_from(obj: Object) -> Result<Self, Self::Error> {
92        Ok(obj.is_nil().then_some(()))
93    }
94}
95
96/// This function is required because we have no specialization yet.
97/// Essentially this let's us convert one type to another "in place"
98/// without the need to allocate a new slice. We ensure that the two
99/// types have the exact same representation, so that no writes
100/// actually need to be performed.
101pub(crate) fn try_from_slice<'brw, 'ob, T, E>(
102    slice: &'brw [Object<'ob>],
103) -> Result<&'brw [Gc<T>], E>
104where
105    Gc<T>: TryFrom<Object<'ob>, Error = E> + 'ob,
106{
107    for x in slice {
108        let _new = Gc::<T>::try_from(*x)?;
109    }
110    let ptr = slice.as_ptr().cast::<Gc<T>>();
111    let len = slice.len();
112    Ok(unsafe { std::slice::from_raw_parts(ptr, len) })
113}
114
115impl From<bool> for Object<'_> {
116    fn from(b: bool) -> Self {
117        if b { TRUE } else { NIL }
118    }
119}
120
121define_unbox!(Int, i64);
122define_unbox!(Float, &'ob LispFloat);
123define_unbox!(HashTable, &'ob LispHashTable);
124define_unbox!(String, &'ob LispString);
125define_unbox!(ByteString, String, &'ob ByteString);
126define_unbox!(Vec, &'ob LispVec);
127define_unbox!(Symbol, Symbol<'ob>);
128define_unbox!(CharTable, &'ob CharTable);
129
130impl<'ob, T> From<Option<T>> for Object<'ob>
131where
132    T: Into<Object<'ob>>,
133{
134    fn from(t: Option<T>) -> Self {
135        match t {
136            Some(x) => x.into(),
137            None => NIL,
138        }
139    }
140}
141
142#[cfg(test)]
143mod test {
144    use crate::core::cons::Cons;
145
146    use super::super::super::gc::{Context, RootSet};
147
148    use super::*;
149
150    fn wrapper(args: &[Object]) -> Result<i64, TypeError> {
151        Ok(inner(
152            std::convert::TryFrom::try_from(args[0])?,
153            std::convert::TryFrom::try_from(args[1])?,
154        ))
155    }
156
157    fn inner(arg0: Option<i64>, arg1: &Cons) -> i64 {
158        let x: i64 = arg1.car().try_into().unwrap();
159        arg0.unwrap() + x
160    }
161
162    #[test]
163    fn test() {
164        let roots = &RootSet::default();
165        let cx = &Context::new(roots);
166        let obj0 = cx.add(5);
167        // SAFETY: We don't call garbage collect so references are valid
168        let obj1 = cx.add(Cons::new(1, 2, cx));
169        let vec = vec![obj0, obj1];
170        let res = wrapper(vec.as_slice());
171        assert_eq!(6, res.unwrap());
172    }
173}
rune/core/object/convert.rs

rune/core/object/
convert.rs
