Introduce an Iterator type to deal with the iterator interfaces

Author: udoprog

crates/rune/tests/test_all/iterator.rs

@@ -0,0 +1,68 @@
+use rune::testing::*;
+
+#[test]
+fn test_range_iter() {
+    let values = rune!(Vec<i64> =>
+        use std::iter::range;
+
+        pub fn main() {
+            range(0, 100).map(|n| n * 2).filter(|n| n % 3 == 0).collect_vec()
+        }
+    );
+
+    assert_eq!(
+        values,
+        (0..100)
+            .map(|n| n * 2)
+            .filter(|n| n % 3 == 0)
+            .collect::<Vec<i64>>()
+    );
+}
+
+#[test]
+fn test_rev() {
+    let values = rune!(Vec<i64> =>
+        use std::iter::range;
+
+        pub fn main() {
+            range(0, 100).map(|n| n * 2).filter(|n| n % 3 == 0).rev().collect_vec()
+        }
+    );
+
+    assert_eq!(
+        values,
+        (0..100)
+            .map(|n| n * 2)
+            .filter(|n| n % 3 == 0)
+            .rev()
+            .collect::<Vec<i64>>()
+    );
+}
+
+#[test]
+fn test_next_back() {
+    rune! {() =>
+        const SOURCE = [1, 2, 3, "foo"];
+
+        pub fn main() {
+            let it = SOURCE.iter().rev();
+            let v = Vec::new();
+
+            while let Some(n) = it.next_back() {
+                v.push(n);
+            }
+
+            assert_eq!(v, SOURCE);
+        }
+    };
+}
+
+#[test]
+fn test_object_rev_error() {
+    assert_vm_error!(
+        r#"pub fn main() { #{}.iter().rev() }"#,
+        Panic { reason } => {
+            assert_eq!(reason.to_string(), "`std::object::Iter` is not a double-ended iterator");
+        }
+    );
+}

crates/rune/tests/test_all/mod.rs

@@ -9,6 +9,7 @@ mod compiler_use;
 mod compiler_visibility;
 mod compiler_warnings;
 mod core_macros;
+mod iterator;
 mod moved;
 mod vm_arithmetic;
 mod vm_assign_exprs;

crates/runestick/src/iterator.rs

@@ -0,0 +1,280 @@
+use crate::{FromValue, Function, ToValue, Value, VmError};
+use std::iter;
+use std::vec;
+
+/// An owning iterator.
+pub struct Iterator {
+    inner: Inner,
+}
+
+crate::__internal_impl_any!(Iterator);
+
+impl Iterator {
+    /// Construct a new owning iterator.
+    ///
+    /// The name is only intended to identify the iterator in case of errors.
+    pub fn from<T>(name: &'static str, iter: T) -> Self
+    where
+        T: IteratorTrait,
+    {
+        Self {
+            inner: Inner::Iterator(Box::new(IteratorObj { name, iter })),
+        }
+    }
+
+    /// Construct a new double-ended owning iterator, with a human-readable
+    /// name.
+    ///
+    /// The name is only intended to identify the iterator in case of errors.
+    pub fn from_double_ended<T>(name: &'static str, iter: T) -> Self
+    where
+        T: DoubleEndedIteratorTrait,
+    {
+        Self {
+            inner: Inner::DoubleEndedIterator(Box::new(IteratorObj { name, iter })),
+        }
+    }
+
+    /// Get the size hint for the iterator.
+    pub fn size_hint(&self) -> (usize, Option<usize>) {
+        self.inner.size_hint()
+    }
+
+    /// Get the next value out of the iterator.
+    pub fn next(&mut self) -> Result<Option<Value>, VmError> {
+        self.inner.next()
+    }
+
+    /// Get the next back value out of the iterator.
+    pub fn next_back(&mut self) -> Result<Option<Value>, VmError> {
+        self.inner.next_back()
+    }
+
+    /// Map the iterator using the given function.
+    pub fn map(self, map: Function) -> Self {
+        Self {
+            inner: Inner::Map(Box::new(Map {
+                inner: self.inner,
+                map,
+            })),
+        }
+    }
+
+    /// Filter the iterator using the given function.
+    pub fn filter(self, filter: Function) -> Self {
+        Self {
+            inner: Inner::Filter(Box::new(Filter {
+                inner: self.inner,
+                filter,
+            })),
+        }
+    }
+
+    /// Map the iterator using the given function.
+    pub fn rev(self) -> Result<Self, VmError> {
+        if !self.inner.is_double_ended() {
+            let name = self.inner.name();
+
+            return Err(VmError::panic(format!(
+                "`{}` is not a double-ended iterator",
+                name
+            )));
+        }
+
+        Ok(Self {
+            inner: match self.inner {
+                // NB: reversing a reversed iterator restores the original
+                // iterator.
+                Inner::Rev(inner) => *inner,
+                inner => Inner::Rev(Box::new(inner)),
+            },
+        })
+    }
+
+    /// Collect results from the iterator.
+    pub fn collect<T>(mut self) -> Result<vec::Vec<T>, VmError>
+    where
+        T: FromValue,
+    {
+        let (cap, _) = self.inner.size_hint();
+        let mut vec = vec::Vec::with_capacity(cap);
+
+        while let Some(value) = self.next()? {
+            vec.push(T::from_value(value)?);
+        }
+
+        Ok(vec)
+    }
+}
+
+enum Inner {
+    Iterator(Box<IteratorObj<dyn IteratorTrait>>),
+    DoubleEndedIterator(Box<IteratorObj<dyn DoubleEndedIteratorTrait>>),
+    Map(Box<Map>),
+    Filter(Box<Filter>),
+    Rev(Box<Inner>),
+}
+
+impl Inner {
+    /// Test if this iterator is double-ended.
+    fn name(&self) -> &'static str {
+        match self {
+            Inner::Iterator(iter) => iter.name,
+            Inner::DoubleEndedIterator(iter) => iter.name,
+            Inner::Map(map) => map.inner.name(),
+            Inner::Filter(filter) => filter.inner.name(),
+            Inner::Rev(inner) => inner.name(),
+        }
+    }
+
+    /// Test if this iterator is double-ended.
+    fn is_double_ended(&self) -> bool {
+        match self {
+            Inner::Iterator(..) => false,
+            Inner::DoubleEndedIterator(..) => true,
+            Inner::Map(map) => map.inner.is_double_ended(),
+            Inner::Filter(filter) => filter.inner.is_double_ended(),
+            Inner::Rev(..) => true,
+        }
+    }
+
+    /// The length of the remaining iterator.
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match self {
+            Inner::Iterator(iter) => iter.iter.size_hint(),
+            Inner::DoubleEndedIterator(iter) => iter.iter.size_hint(),
+            Inner::Map(map) => map.inner.size_hint(),
+            Inner::Filter(filter) => filter.inner.size_hint(),
+            Inner::Rev(inner) => inner.size_hint(),
+        }
+    }
+
+    fn next(&mut self) -> Result<Option<Value>, VmError> {
+        match self {
+            Self::Iterator(owned) => owned.iter.next(),
+            Self::DoubleEndedIterator(owned) => owned.iter.next(),
+            Self::Map(map) => map.advance(Self::next),
+            Self::Filter(filter) => filter.advance(Self::next),
+            Self::Rev(rev) => rev.next_back(),
+        }
+    }
+
+    fn next_back(&mut self) -> Result<Option<Value>, VmError> {
+        match self {
+            Self::Iterator(iter) => {
+                return Err(VmError::panic(format!(
+                    "`{}` is not a double-ended iterator",
+                    iter.name
+                )));
+            }
+            Self::DoubleEndedIterator(owned) => owned.iter.next_back(),
+            Self::Map(map) => map.advance(Self::next_back),
+            Self::Filter(filter) => filter.advance(Self::next_back),
+            Self::Rev(rev) => rev.next(),
+        }
+    }
+}
+
+struct Map {
+    inner: Inner,
+    map: Function,
+}
+
+impl Map {
+    fn advance(
+        &mut self,
+        advance: impl FnOnce(&mut Inner) -> Result<Option<Value>, VmError>,
+    ) -> Result<Option<Value>, VmError> {
+        if let Some(value) = advance(&mut self.inner)? {
+            let out = self.map.call::<_, Value>((value,))?;
+            return Ok(Some(out));
+        }
+
+        Ok(None)
+    }
+}
+
+struct Filter {
+    inner: Inner,
+    filter: Function,
+}
+
+impl Filter {
+    fn advance(
+        &mut self,
+        advance: impl Fn(&mut Inner) -> Result<Option<Value>, VmError>,
+    ) -> Result<Option<Value>, VmError> {
+        while let Some(value) = advance(&mut self.inner)? {
+            if self.filter.call::<_, bool>((value.clone(),))? {
+                return Ok(Some(value));
+            }
+        }
+
+        Ok(None)
+    }
+}
+
+/// The trait for interacting with an iterator.
+///
+/// This has a blanket implementation, and is primarily used to restrict the
+/// arguments that can be used in [Iterator::from_iterator].
+pub trait IteratorTrait: 'static {
+    /// Size hint of the iterator.
+    fn size_hint(&self) -> (usize, Option<usize>);
+
+    /// Get the next value out of the iterator.
+    fn next(&mut self) -> Result<Option<Value>, VmError>;
+}
+
+impl<T> IteratorTrait for T
+where
+    T: 'static,
+    T: iter::Iterator,
+    T::Item: ToValue,
+{
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        iter::Iterator::size_hint(self)
+    }
+
+    fn next(&mut self) -> Result<Option<Value>, VmError> {
+        let value = match iter::Iterator::next(self) {
+            Some(value) => value,
+            None => return Ok(None),
+        };
+
+        Ok(Some(value.to_value()?))
+    }
+}
+
+/// The trait for interacting with an iterator.
+///
+/// This has a blanket implementation, and is primarily used to restrict the
+/// arguments that can be used in [Iterator::from_double_ended].
+pub trait DoubleEndedIteratorTrait: IteratorTrait {
+    /// Get the next back value out of the iterator.
+    fn next_back(&mut self) -> Result<Option<Value>, VmError>;
+}
+
+impl<T> DoubleEndedIteratorTrait for T
+where
+    T: 'static,
+    T: iter::DoubleEndedIterator,
+    T::Item: ToValue,
+{
+    fn next_back(&mut self) -> Result<Option<Value>, VmError> {
+        let value = match iter::DoubleEndedIterator::next_back(self) {
+            Some(value) => value,
+            None => return Ok(None),
+        };
+
+        Ok(Some(value.to_value()?))
+    }
+}
+
+struct IteratorObj<T>
+where
+    T: ?Sized,
+{
+    name: &'static str,
+    iter: T,
+}

crates/runestick/src/lib.rs

@@ -75,6 +75,7 @@ mod hash;
 mod id;
 mod inst;
 mod item;
+mod iterator;
 mod label;
 pub mod module;
 pub mod modules;
@@ -153,6 +154,7 @@ pub use self::generator::Generator;
 pub use self::generator_state::GeneratorState;
 pub use self::guarded_args::GuardedArgs;
 pub use self::id::Id;
+pub use self::iterator::Iterator;
 pub use self::label::{DebugLabel, Label};
 pub use self::module::{InstFnNameHash, Module};
 pub use self::named::Named;