Use modules to implement packages.

src/packages/iter_basic.rs

@@ -1,8 +1,6 @@
-use super::{reg_binary, reg_trinary, PackageStore};
-
 use crate::any::{Dynamic, Variant};
 use crate::def_package;
-use crate::fn_register::map_dynamic as map;
+use crate::module::{FuncReturn, Module};
 use crate::parser::INT;
 
 use crate::stdlib::{
@@ -12,11 +10,11 @@ use crate::stdlib::{
 };
 
 // Register range function
-fn reg_range<T: Variant + Clone>(lib: &mut PackageStore)
+fn reg_range<T: Variant + Clone>(lib: &mut Module)
 where
     Range<T>: Iterator<Item = T>,
 {
-    lib.type_iterators.insert(
+    lib.set_iterator(
         TypeId::of::<Range<T>>(),
         Box::new(|source| {
             Box::new(source.cast::<Range<T>>().map(|x| x.into_dynamic()))
@@ -25,6 +23,10 @@ where
     );
 }
 
+fn get_range<T: Variant + Clone>(from: T, to: T) -> FuncReturn<Range<T>> {
+    Ok(from..to)
+}
+
 // Register range function with step
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 struct StepRange<T>(T, T, T)
@@ -50,13 +52,13 @@ where
     }
 }
 
-fn reg_step<T>(lib: &mut PackageStore)
+fn reg_step<T>(lib: &mut Module)
 where
     for<'a> &'a T: Add<&'a T, Output = T>,
     T: Variant + Clone + PartialOrd,
     StepRange<T>: Iterator<Item = T>,
 {
-    lib.type_iterators.insert(
+    lib.set_iterator(
         TypeId::of::<StepRange<T>>(),
         Box::new(|source| {
             Box::new(source.cast::<StepRange<T>>().map(|x| x.into_dynamic()))
@@ -65,22 +67,26 @@ where
     );
 }
 
-def_package!(crate:BasicIteratorPackage:"Basic range iterators.", lib, {
-    fn get_range<T>(from: T, to: T) -> Range<T> {
-        from..to
-    }
+fn get_step_range<T>(from: T, to: T, step: T) -> FuncReturn<StepRange<T>>
+where
+    for<'a> &'a T: Add<&'a T, Output = T>,
+    T: Variant + Clone + PartialOrd,
+{
+    Ok(StepRange::<T>(from, to, step))
+}
 
+def_package!(crate:BasicIteratorPackage:"Basic range iterators.", lib, {
     reg_range::<INT>(lib);
-    reg_binary(lib, "range", get_range::<INT>, map);
+    lib.set_fn_2("range", get_range::<INT>);
 
     #[cfg(not(feature = "only_i32"))]
     #[cfg(not(feature = "only_i64"))]
     {
         macro_rules! reg_range {
-            ($self:expr, $x:expr, $( $y:ty ),*) => (
+            ($lib:expr, $x:expr, $( $y:ty ),*) => (
                 $(
-                    reg_range::<$y>($self);
-                    reg_binary($self, $x, get_range::<$y>, map);
+                    reg_range::<$y>($lib);
+                    $lib.set_fn_2($x, get_range::<$y>);
                 )*
             )
         }
@@ -89,16 +95,16 @@ def_package!(crate:BasicIteratorPackage:"Basic range iterators.", lib, {
     }
 
     reg_step::<INT>(lib);
-    reg_trinary(lib, "range", StepRange::<INT>, map);
+    lib.set_fn_3("range", get_step_range::<INT>);
 
     #[cfg(not(feature = "only_i32"))]
     #[cfg(not(feature = "only_i64"))]
     {
         macro_rules! reg_step {
-            ($self:expr, $x:expr, $( $y:ty ),*) => (
+            ($lib:expr, $x:expr, $( $y:ty ),*) => (
                 $(
-                    reg_step::<$y>($self);
-                    reg_trinary($self, $x, StepRange::<$y>, map);
+                    reg_step::<$y>($lib);
+                    $lib.set_fn_3($x, get_step_range::<$y>);
                 )*
             )
         }