mirascript-vm 0.1.105

Native Rust virtual machine for MiraScript
Documentation
mod all_any;
mod entries;
mod find;
mod flatten;
mod fold;
mod group;
mod len;
mod map_filter;
mod new;
mod repeat;
mod reverse;
mod sort;
mod unique;
mod with;
mod zip;

use indexmap::IndexMap;

use crate::standard_library::{callable, const_value, global_builtin, optional_callable, required};
use crate::{
    MiraError, MiraFunctionHandle, MiraValue, MiraValueKind, Result, Runtime, RuntimeErrorKind,
    operations,
};

use with::array_length;

pub(super) enum Data {
    Primitive(MiraValue),
    Array(MiraValue),
    Record(IndexMap<String, MiraValue>),
}

impl Data {
    pub(super) fn from_value(runtime: &mut Runtime, value: MiraValue) -> Result<Self> {
        match value.kind() {
            MiraValueKind::Nil
            | MiraValueKind::Boolean(_)
            | MiraValueKind::Number(_)
            | MiraValueKind::String(_)
            | MiraValueKind::StaticStr(_) => Ok(Self::Primitive(value)),
            MiraValueKind::Array(_) => Ok(Self::Array(value)),
            MiraValueKind::Record(_) => {
                let record = operations::iterable_record(runtime, value)?;
                Ok(Self::Record(record))
            }
            _ => Err(MiraError::runtime(RuntimeErrorKind::TypeMismatch {
                expected: "nil, number, boolean, string, array, or record",
                actual: value.value_type(),
            })),
        }
    }

    pub(super) fn original(&self, runtime: &mut Runtime) -> Result<MiraValue> {
        match self {
            Self::Primitive(value) => Ok(*value),
            Self::Array(value) => Ok(*value),
            Self::Record(value) => runtime.insert(value.clone()),
        }
    }
}

pub(super) fn install(context: &mut Runtime) {
    len::install(context);
    entries::install(context);
    map_filter::install(context);
    fold::install(context);
    group::install(context);
    flatten::install(context);
    find::install(context);
    all_any::install(context);
    reverse::install(context);
    sort::install(context);
    unique::install(context);
    repeat::install(context);
    new::install(context);
    zip::install(context);
    with::install(context);
}

pub(super) fn data_items(
    runtime: &mut Runtime,
    data: &Data,
) -> Result<Vec<(MiraValue, MiraValue)>> {
    iterate_data(
        runtime,
        data,
        |_, length| Ok(Vec::with_capacity(length)),
        |_, key, value, items| {
            items.push((key, value));
            Ok(true)
        },
    )
}

pub(super) fn iterate_data<T>(
    runtime: &mut Runtime,
    data: &Data,
    init: impl FnOnce(&mut Runtime, usize) -> Result<T>,
    mut body: impl FnMut(&mut Runtime, MiraValue, MiraValue, &mut T) -> Result<bool>,
) -> Result<T> {
    match data {
        Data::Primitive(value) => {
            let mut acc = init(runtime, 1)?;
            body(runtime, MiraValue::NIL, *value, &mut acc)?;
            Ok(acc)
        }
        Data::Array(value) => {
            let iter = operations::iterate_array(runtime, *value)?;
            let mut acc = init(runtime, iter.len())?;
            for entry in iter {
                let index = entry.index();
                let value = entry.get(runtime)?;
                if !body(runtime, MiraValue::number(index as f64), value, &mut acc)? {
                    break;
                }
            }
            Ok(acc)
        }
        Data::Record(values) => {
            let mut acc = init(runtime, values.len())?;
            for (key, value) in values {
                let key = runtime.insert(key.clone())?;
                if !body(runtime, key, *value, &mut acc)? {
                    break;
                }
            }
            Ok(acc)
        }
    }
}

pub(super) fn array_value(runtime: &mut Runtime, value: MiraValue) -> Result<Vec<MiraValue>> {
    operations::iterable_array(runtime, value)
}

pub(super) fn pair(
    runtime: &mut Runtime,
    first: MiraValue,
    second: MiraValue,
) -> Result<MiraValue> {
    runtime.insert(IndexMap::from([("0".into(), first), ("1".into(), second)]))
}