Optimize imports layout.

src/engine.rs

@@ -53,7 +53,7 @@ pub const TYPICAL_MAP_SIZE: usize = 8; // Small maps are typical
 // the module name will live beyond the AST of the eval script text.
 // The best we can do is a shared reference.
 #[derive(Debug, Clone, Default)]
-pub struct Imports(StaticVec<(ImmutableString, Shared<Module>)>);
+pub struct Imports(StaticVec<ImmutableString>, StaticVec<Shared<Module>>);
 
 impl Imports {
     /// Get the length of this stack of imported [modules][Module].
@@ -69,7 +69,7 @@ impl Imports {
     /// Get the imported [modules][Module] at a particular index.
     #[inline(always)]
     pub fn get(&self, index: usize) -> Option<Shared<Module>> {
-        self.0.get(index).map(|(_, m)| m).cloned()
+        self.1.get(index).cloned()
     }
     /// Get the index of an imported [modules][Module] by name.
     #[inline(always)]
@@ -78,18 +78,19 @@ impl Imports {
             .iter()
             .enumerate()
             .rev()
-            .find(|(_, (key, _))| key.as_str() == name)
-            .map(|(index, _)| index)
+            .find_map(|(i, key)| if key.as_str() == name { Some(i) } else { None })
     }
     /// Push an imported [modules][Module] onto the stack.
     #[inline(always)]
     pub fn push(&mut self, name: impl Into<ImmutableString>, module: impl Into<Shared<Module>>) {
-        self.0.push((name.into(), module.into()));
+        self.0.push(name.into());
+        self.1.push(module.into());
     }
     /// Truncate the stack of imported [modules][Module] to a particular length.
     #[inline(always)]
     pub fn truncate(&mut self, size: usize) {
         self.0.truncate(size);
+        self.1.truncate(size);
     }
     /// Get an iterator to this stack of imported [modules][Module] in reverse order.
     #[allow(dead_code)]
@@ -97,6 +98,7 @@ impl Imports {
     pub fn iter(&self) -> impl Iterator<Item = (&str, &Module)> {
         self.0
             .iter()
+            .zip(self.1.iter())
             .rev()
             .map(|(name, module)| (name.as_str(), module.as_ref()))
     }
@@ -104,52 +106,44 @@ impl Imports {
     #[allow(dead_code)]
     #[inline(always)]
     pub(crate) fn iter_raw(&self) -> impl Iterator<Item = (&ImmutableString, &Shared<Module>)> {
-        self.0.iter().rev().map(|(n, m)| (n, m))
+        self.0.iter().rev().zip(self.1.iter().rev())
     }
     /// Get an iterator to this stack of imported [modules][Module] in forward order.
     #[allow(dead_code)]
     #[inline(always)]
     pub(crate) fn scan_raw(&self) -> impl Iterator<Item = (&ImmutableString, &Shared<Module>)> {
-        self.0.iter().map(|(n, m)| (n, m))
+        self.0.iter().zip(self.1.iter())
     }
     /// Get a consuming iterator to this stack of imported [modules][Module] in reverse order.
     #[inline(always)]
     pub fn into_iter(self) -> impl Iterator<Item = (ImmutableString, Shared<Module>)> {
-        self.0.into_iter().rev()
-    }
-    /// Add a stream of imported [modules][Module].
-    #[inline(always)]
-    pub fn extend(&mut self, stream: impl Iterator<Item = (ImmutableString, Shared<Module>)>) {
-        self.0.extend(stream)
+        self.0.into_iter().rev().zip(self.1.into_iter().rev())
     }
     /// Does the specified function hash key exist in this stack of imported [modules][Module]?
     #[allow(dead_code)]
     #[inline(always)]
     pub fn contains_fn(&self, hash: u64) -> bool {
-        self.0.iter().any(|(_, m)| m.contains_qualified_fn(hash))
+        self.1.iter().any(|m| m.contains_qualified_fn(hash))
     }
     /// Get specified function via its hash key.
     #[inline(always)]
     pub fn get_fn(&self, hash: u64) -> Option<(&CallableFunction, Option<&ImmutableString>)> {
-        self.0
+        self.1
             .iter()
             .rev()
-            .find_map(|(_, m)| m.get_qualified_fn(hash).map(|f| (f, m.id_raw())))
+            .find_map(|m| m.get_qualified_fn(hash).map(|f| (f, m.id_raw())))
     }
     /// Does the specified [`TypeId`][std::any::TypeId] iterator exist in this stack of
     /// imported [modules][Module]?
     #[allow(dead_code)]
     #[inline(always)]
     pub fn contains_iter(&self, id: TypeId) -> bool {
-        self.0.iter().any(|(_, m)| m.contains_qualified_iter(id))
+        self.1.iter().any(|m| m.contains_qualified_iter(id))
     }
     /// Get the specified [`TypeId`][std::any::TypeId] iterator.
     #[inline(always)]
     pub fn get_iter(&self, id: TypeId) -> Option<IteratorFn> {
-        self.0
-            .iter()
-            .rev()
-            .find_map(|(_, m)| m.get_qualified_iter(id))
+        self.1.iter().rev().find_map(|m| m.get_qualified_iter(id))
     }
 }