mirascript-vm 0.1.105

Native Rust virtual machine for MiraScript
Documentation
use super::*;

pub(super) fn install(context: &mut Runtime) {
    global_builtin!(context, fn keys(call, args) {
        let value = *required(args, 0, "data")?;
        let keys: Vec<MiraValue> = match value.kind() {
            MiraValueKind::Array(_) => (0..operations::array_len(call, value)?.unwrap_or(0))
                .map(|index| MiraValue::number(index as f64))
                .collect(),
            MiraValueKind::Record(_) => operations::iterate_record(call, value)?
                .map(|entry| call.insert(entry.key(call)?.to_owned()))
                .collect::<Result<Vec<_>>>()?,
            MiraValueKind::Module(_) => operations::iterate_module(call, value)?
                .map(|entry| call.insert(entry.key(call)?.to_owned()))
                .collect::<Result<Vec<_>>>()?,
            _ => {
                return Err(MiraError::runtime(RuntimeErrorKind::TypeMismatch {
                    expected: "compound value",
                    actual: value.value_type(),
                }));
            }
        };
        call.insert(keys)
    });
    global_builtin!(context, fn values(call, args) {
        let data = Data::from_value(call, *required(args, 0, "data")?)?;
        match data {
            Data::Array(value) => {
                let values = operations::iterable_array(call, value)?;
                call.insert(values)
            }
            Data::Record(values) => call.insert(values.into_values().collect::<Vec<_>>()),
            Data::Primitive(value) => Err(MiraError::runtime(RuntimeErrorKind::TypeMismatch {
                expected: "array or record",
                actual: value.value_type(),
            })),
        }
    });
    global_builtin!(context, fn entries(call, args) {
        let data = Data::from_value(call, *required(args, 0, "data")?)?;
        let mut entries = Vec::new();
        match data {
            Data::Array(value) => {
                let iter = operations::iterate_array(call, value)?;
                entries.reserve(iter.len());
                for entry in iter {
                    let index = entry.index();
                    let value = entry.get(call)?;
                    entries.push(pair(call, MiraValue::number(index as f64), value)?);
                }
            }
            Data::Record(values) => {
                for (key, value) in values {
                    let key = call.insert(key)?;
                    entries.push(pair(call, key, value)?);
                }
            }
            Data::Primitive(value) => {
                return Err(MiraError::runtime(RuntimeErrorKind::TypeMismatch {
                    expected: "array or record",
                    actual: value.value_type(),
                }));
            }
        }
        call.insert(entries)
    });
}