mirascript-vm 0.1.105

Native Rust virtual machine for MiraScript
Documentation
use std::{iter::FusedIterator, ops::Range, vec};

use crate::{
    MiraArrayHandle, MiraError, MiraManageable, MiraValue, Result, Runtime, RuntimeErrorKind,
};

enum ArrayEntryValue {
    Indexed(MiraArrayHandle),
    Iterated(Result<MiraManageable>),
}

pub(crate) struct ArrayEntry {
    index: usize,
    value: ArrayEntryValue,
}

impl ArrayEntry {
    pub(crate) const fn index(&self) -> usize {
        self.index
    }

    pub(crate) fn get(self, runtime: &mut Runtime) -> Result<MiraValue> {
        match self.value {
            ArrayEntryValue::Indexed(handle) => handle.get(runtime, self.index),
            ArrayEntryValue::Iterated(value) => runtime.insert(value?),
        }
    }
}

pub(crate) struct ArrayIter {
    handle: MiraArrayHandle,
    indices: Range<usize>,
    entries: Option<vec::IntoIter<ArrayEntry>>,
}

impl Iterator for ArrayIter {
    type Item = ArrayEntry;

    fn next(&mut self) -> Option<Self::Item> {
        match &mut self.entries {
            Some(entries) => entries.next(),
            None => self.indices.next().map(|index| ArrayEntry {
                index,
                value: ArrayEntryValue::Indexed(self.handle),
            }),
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        match &self.entries {
            Some(entries) => entries.size_hint(),
            None => self.indices.size_hint(),
        }
    }
}

impl DoubleEndedIterator for ArrayIter {
    fn next_back(&mut self) -> Option<Self::Item> {
        match &mut self.entries {
            Some(entries) => entries.next_back(),
            None => self.indices.next_back().map(|index| ArrayEntry {
                index,
                value: ArrayEntryValue::Indexed(self.handle),
            }),
        }
    }
}

impl ExactSizeIterator for ArrayIter {}
impl FusedIterator for ArrayIter {}

pub(crate) fn iterate_array(runtime: &Runtime, value: MiraValue) -> Result<ArrayIter> {
    let Some(handle) = value.as_array() else {
        return Err(MiraError::runtime(RuntimeErrorKind::TypeMismatch {
            expected: "array",
            actual: value.value_type(),
        }));
    };
    let (length, entries) = {
        let array = runtime.get_array_dyn(handle)?;
        let length = array.len();
        let entries = array.iter(handle, runtime).map(|iter| {
            iter.enumerate()
                .map(|(index, entry)| match entry {
                    Ok(entry) => ArrayEntry {
                        index: entry.index(),
                        value: ArrayEntryValue::Iterated(Ok(entry.into_value())),
                    },
                    Err(error) => ArrayEntry {
                        index,
                        value: ArrayEntryValue::Iterated(Err(error)),
                    },
                })
                .collect::<Vec<_>>()
                .into_iter()
        });
        (length, entries)
    };
    Ok(ArrayIter {
        handle,
        indices: 0..length,
        entries,
    })
}

pub(crate) fn iterable_array(runtime: &mut Runtime, value: MiraValue) -> Result<Vec<MiraValue>> {
    iterate_array(runtime, value)?
        .map(|entry| entry.get(runtime))
        .collect()
}

#[cfg(test)]
mod tests {
    use std::{cell::Cell, rc::Rc};

    use crate::{MiraArray, MiraArrayEntry, MiraArrayIter, MiraManageable};

    use super::*;

    struct CountingArray {
        reads: Rc<Cell<usize>>,
    }

    struct SequentialArray {
        reads: Rc<Cell<usize>>,
    }

    impl MiraArray for SequentialArray {
        fn len(&self) -> usize {
            2
        }

        fn get(
            &self,
            _self_handle: MiraArrayHandle,
            _runtime: &Runtime,
            _index: usize,
        ) -> Result<MiraManageable> {
            panic!("indexed value access should not be used")
        }

        fn iter<'a>(
            &'a self,
            _self_handle: MiraArrayHandle,
            _runtime: &'a Runtime,
        ) -> Option<MiraArrayIter<'a>> {
            let reads = Rc::clone(&self.reads);
            Some(Box::new((0..2).map(move |index| {
                reads.set(reads.get() + 1);
                Ok(MiraArrayEntry::new(
                    index,
                    MiraValue::number(index as f64).into(),
                ))
            })))
        }
    }

    impl MiraArray for CountingArray {
        fn len(&self) -> usize {
            4
        }

        fn get(
            &self,
            _self_handle: MiraArrayHandle,
            _runtime: &Runtime,
            index: usize,
        ) -> Result<MiraManageable> {
            self.reads.set(self.reads.get() + 1);
            Ok(MiraValue::number(index as f64).into())
        }
    }

    #[test]
    fn iterator_does_not_borrow_runtime_and_only_resolves_visited_entries() {
        let reads = Rc::new(Cell::new(0));
        let mut runtime = Runtime::new();
        let value = runtime
            .insert(MiraManageable::from_array(CountingArray {
                reads: reads.clone(),
            }))
            .unwrap();

        let iter = iterate_array(&runtime, value).unwrap();
        assert_eq!(iter.len(), 4);
        let visited = iter
            .take(2)
            .map(|entry| {
                let index = entry.index();
                let value = entry.get(&mut runtime)?.as_number_unchecked();
                Ok((index, value))
            })
            .collect::<Result<Vec<_>>>()
            .unwrap();

        assert_eq!(visited, vec![(0, 0.0), (1, 1.0)]);
        assert_eq!(reads.get(), 2);
    }

    #[test]
    fn iterate_array_uses_the_trait_iterator_when_available() {
        let reads = Rc::new(Cell::new(0));
        let mut runtime = Runtime::new();
        let value = runtime
            .insert(MiraManageable::from_array(SequentialArray {
                reads: reads.clone(),
            }))
            .unwrap();

        let values = iterate_array(&runtime, value)
            .unwrap()
            .map(|entry| entry.get(&mut runtime))
            .collect::<Result<Vec<_>>>()
            .unwrap();

        assert_eq!(
            values
                .into_iter()
                .map(|value| value.as_number_unchecked())
                .collect::<Vec<_>>(),
            [0.0, 1.0]
        );
        assert_eq!(reads.get(), 2);
    }
}