Allocate packages with higher functions capacity.

examples/hello.rs

@@ -1,5 +1,4 @@
 use rhai::{packages::*, Engine, EvalAltResult, INT};
-use std::rc::Rc;
 
 fn main() -> Result<(), Box<EvalAltResult>> {
     let mut engine = Engine::new_raw();

examples/repl.rs

@@ -1,12 +1,9 @@
-use rhai::{Dynamic, Engine, EvalAltResult, Scope, AST, INT};
+use rhai::{Dynamic, Engine, EvalAltResult, Scope, AST};
 
 #[cfg(not(feature = "no_optimize"))]
 use rhai::OptimizationLevel;
 
-use std::{
-    io::{stdin, stdout, Write},
-    iter,
-};
+use std::io::{stdin, stdout, Write};
 
 fn print_error(input: &str, err: EvalAltResult) {
     let lines: Vec<_> = input.trim().split('\n').collect();

examples/rhai_runner.rs

@@ -3,7 +3,7 @@ use rhai::{Engine, EvalAltResult};
 #[cfg(not(feature = "no_optimize"))]
 use rhai::OptimizationLevel;
 
-use std::{env, fs::File, io::Read, iter, process::exit};
+use std::{env, fs::File, io::Read, process::exit};
 
 fn eprint_error(input: &str, err: EvalAltResult) {
     fn eprint_line(lines: &[&str], line: usize, pos: usize, err: &str) {

src/module.rs

@@ -94,6 +94,24 @@ impl Module {
         Default::default()
     }
 
+    /// Create a new module with a specified capacity for native Rust functions.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rhai::Module;
+    ///
+    /// let mut module = Module::new();
+    /// module.set_var("answer", 42_i64);
+    /// assert_eq!(module.get_var_value::<i64>("answer").unwrap(), 42);
+    /// ```
+    pub fn new_with_capacity(capacity: usize) -> Self {
+        Self {
+            functions: HashMap::with_capacity(capacity),
+            ..Default::default()
+        }
+    }
+
     /// Does a variable exist in the module?
     ///
     /// # Examples

src/packages/array_basic.rs

@@ -17,7 +17,7 @@ fn ins<T: Variant + Clone>(list: &mut Array, position: INT, item: T) -> FuncRetu
     if position <= 0 {
         list.insert(0, Dynamic::from(item));
     } else if (position as usize) >= list.len() - 1 {
-        push(list, item);
+        push(list, item)?;
     } else {
         list.insert(position as usize, Dynamic::from(item));
     }
@@ -26,7 +26,7 @@ fn ins<T: Variant + Clone>(list: &mut Array, position: INT, item: T) -> FuncRetu
 fn pad<T: Variant + Clone>(list: &mut Array, len: INT, item: T) -> FuncReturn<()> {
     if len >= 0 {
         while list.len() < len as usize {
-            push(list, item.clone());
+            push(list, item.clone())?;
         }
     }
     Ok(())

src/packages/mod.rs

@@ -129,7 +129,7 @@ macro_rules! def_package {
 
         impl $package {
             pub fn new() -> Self {
-                let mut module = $root::Module::new();
+                let mut module = $root::Module::new_with_capacity(512);
                 <Self as $root::packages::Package>::init(&mut module);
                 Self(module.into())
             }