mirascript-vm 0.1.87

Native Rust virtual machine for MiraScript
Documentation
use std::cmp::Ordering;

use super::*;

pub(super) fn install(context: &mut MiraContext) {
    insert_native(context, "sort", |call, args| {
        let mut values = array_value(required(args, 0, "data")?)?;
        insertion_sort(call, &mut values, args.get(1))?;
        Ok(MiraAny::Array(values))
    });
    insert_native(context, "sort_by", |call, args| {
        let values = array_value(required(args, 0, "data")?)?;
        let key_function = required(args, 1, "key")?;
        if !is_callable(key_function)? {
            return Err(MiraError::runtime("Argument `key` is not callable"));
        }
        let original = MiraAny::Array(values.clone());
        let mut keyed = Vec::new();
        for (index, value) in values.into_iter().enumerate() {
            let key = call.call(
                key_function,
                &[
                    value.clone(),
                    MiraAny::Number(index as f64),
                    original.clone(),
                ],
            )?;
            keyed.push(pair(key, value));
        }
        insertion_sort_by(call, &mut keyed, args.get(2), |value| {
            value
                .record_get("0")
                .map(|value| value.unwrap_or(MiraAny::Nil))
        })?;
        Ok(MiraAny::Array(
            keyed
                .into_iter()
                .map(|value| {
                    value
                        .record_get("1")
                        .map(|item| item.unwrap_or(MiraAny::Nil))
                })
                .collect::<Result<Vec<_>>>()?,
        ))
    });
}

fn insertion_sort(
    call: &mut MiraCallContext<'_>,
    values: &mut [MiraAny],
    comparator: Option<&MiraAny>,
) -> Result<()> {
    insertion_sort_by(call, values, comparator, |value| Ok(value.clone()))
}

fn insertion_sort_by<T>(
    call: &mut MiraCallContext<'_>,
    values: &mut [T],
    comparator: Option<&MiraAny>,
    key: impl Fn(&T) -> Result<MiraAny>,
) -> Result<()> {
    if let Some(value) = comparator.filter(|value| **value != MiraAny::Nil)
        && !is_callable(value)?
    {
        return Err(MiraError::runtime("Argument `comparator` is not callable"));
    }
    for index in 1..values.len() {
        let mut position = index;
        while position > 0 {
            let left = key(&values[position - 1])?;
            let right = key(&values[position])?;
            let ordering =
                if let Some(comparator) = comparator.filter(|value| **value != MiraAny::Nil) {
                    operations::to_number(&call.call(comparator, &[left, right])?)?
                        .partial_cmp(&0.0)
                        .unwrap_or(Ordering::Equal)
                } else {
                    default_compare(&left, &right)
                };
            if ordering != Ordering::Greater {
                break;
            }
            values.swap(position - 1, position);
            position -= 1;
        }
    }
    Ok(())
}

fn default_compare(left: &MiraAny, right: &MiraAny) -> Ordering {
    if left == right {
        return Ordering::Equal;
    }
    if matches!(left, MiraAny::Nil | MiraAny::String(_))
        && matches!(right, MiraAny::Nil | MiraAny::String(_))
    {
        return operations::to_string(left)
            .unwrap_or_default()
            .cmp(&operations::to_string(right).unwrap_or_default());
    }
    let left = operations::to_number(left).unwrap_or(0.0);
    let right = operations::to_number(right).unwrap_or(0.0);
    let left = if left == 0.0 || left.is_nan() {
        0.0
    } else {
        left
    };
    let right = if right == 0.0 || right.is_nan() {
        0.0
    } else {
        right
    };
    left.partial_cmp(&right).unwrap_or(Ordering::Equal)
}