Reduce size of Engine.

src/eval/debugger.rs

@@ -512,7 +512,9 @@ impl Engine {
         let src = src.as_ref().map(|s| s.as_str());
         let context = crate::EvalContext::new(self, global, caches, scope, this_ptr);
 
-        if let Some((.., ref on_debugger)) = self.debugger {
+        if let Some(ref x) = self.debugger {
+            let (.., ref on_debugger) = **x;
+
             let command = on_debugger(context, event, node, src, node.position())?;
 
             match command {

src/eval/expr.rs

@@ -36,7 +36,12 @@ impl Engine {
 
         // Do a text-match search if the index doesn't work
         global.find_import(root).map_or_else(
-            || self.global_sub_modules.get(root).cloned(),
+            || {
+                self.global_sub_modules
+                    .as_ref()
+                    .and_then(|m| m.get(root))
+                    .cloned()
+            },
             |offset| global.get_shared_import(offset),
         )
     }
@@ -401,13 +406,17 @@ impl Engine {
                 // The first token acts as the custom syntax's key
                 let key_token = custom.tokens.first().unwrap();
                 // The key should exist, unless the AST is compiled in a different Engine
-                let custom_def = self.custom_syntax.get(key_token.as_str()).ok_or_else(|| {
-                    Box::new(ERR::ErrorCustomSyntax(
-                        format!("Invalid custom syntax prefix: {key_token}"),
-                        custom.tokens.iter().map(<_>::to_string).collect(),
-                        *pos,
-                    ))
-                })?;
+                let custom_def = self
+                    .custom_syntax
+                    .as_ref()
+                    .and_then(|m| m.get(key_token.as_str()))
+                    .ok_or_else(|| {
+                        Box::new(ERR::ErrorCustomSyntax(
+                            format!("Invalid custom syntax prefix: {key_token}"),
+                            custom.tokens.iter().map(<_>::to_string).collect(),
+                            *pos,
+                        ))
+                    })?;
                 let mut context = EvalContext::new(self, global, caches, scope, this_ptr);
 
                 (custom_def.func)(&mut context, &expressions, &custom.state)

src/eval/global_state.rs

@@ -111,8 +111,8 @@ impl GlobalRuntimeState {
             tag: engine.default_tag().clone(),
 
             #[cfg(feature = "debugging")]
-            debugger: engine.debugger.as_ref().map(|(init, ..)| {
-                crate::eval::Debugger::new(crate::eval::DebuggerStatus::Init, init(engine))
+            debugger: engine.debugger.as_ref().map(|x| {
+                crate::eval::Debugger::new(crate::eval::DebuggerStatus::Init, (x.0)(engine))
             }),
         }
     }

src/eval/stmt.rs

@@ -502,7 +502,8 @@ impl Engine {
                 #[cfg(not(feature = "no_module"))]
                 let func = func.or_else(|| global.get_iter(iter_type)).or_else(|| {
                     self.global_sub_modules
-                        .values()
+                        .iter()
+                        .flat_map(|m| m.values())
                         .find_map(|m| m.get_qualified_iter(iter_type))
                 });