Grounding space implementation with a more compact representation in memory

lib/Cargo.toml

@@ -14,6 +14,7 @@ rand = "0.8.5"
 bitset = "0.1.2"
 dyn-fmt = "0.4.0"
 itertools = "0.13.0"
+bimap = "0.6.3"
 
 # pkg_mgmt deps
 xxhash-rust = {version="0.8.7", features=["xxh3"], optional=true }

lib/src/atom/serial.rs

@@ -72,8 +72,11 @@ pub trait ConvertingSerializer<T>: Serializer + Default {
 /// Serialization result type
 pub type Result = std::result::Result<(), Error>;
 
+trait PrivHasher : Hasher {}
+impl PrivHasher for DefaultHasher {}
+
 // there are much speedier hashers, but not sure if it's worth the extra dependency given the other options
-impl Serializer for DefaultHasher {
+impl<H: PrivHasher> Serializer for H {
     fn serialize_bool(&mut self, v: bool) -> Result { Ok(self.write_u8(v as u8)) }
     fn serialize_i64(&mut self, v: i64) -> Result { Ok(self.write_i64(v)) }
     fn serialize_f64(&mut self, v: f64) -> Result { Ok(self.write_u64(v as u64)) }
@@ -95,3 +98,14 @@ impl Serializer for Vec<u8> {
     fn serialize_f64(&mut self, v: f64) -> Result { Ok(self.extend(v.to_le_bytes())) }
     fn serialize_str(&mut self, v: &str) -> Result { Ok(self.extend(v.bytes())) }
 }
+
+#[derive(Default)]
+pub struct NullSerializer();
+
+impl Serializer for NullSerializer {
+    fn serialize_bool(&mut self, _v: bool) -> Result { Ok(()) }
+    fn serialize_i64(&mut self, _v: i64) -> Result { Ok(()) }
+    fn serialize_f64(&mut self, _v: f64) -> Result { Ok(()) }
+    fn serialize_str(&mut self, _v: &str) -> Result { Ok(()) }
+}
+

lib/src/common/collections.rs

@@ -297,6 +297,22 @@ impl<'a, T: 'a + Display> Display for VecDisplay<'a, T> {
     }
 }
 
+/// Helper function to implement Display for all mapping like code structures.
+/// Displays iterator over pairs in a format { <key>: <value>, ... }
+pub fn write_mapping<A, B, I>(f: &mut std::fmt::Formatter, it: I) -> std::fmt::Result
+    where
+        A: Display,
+        B: Display,
+        I: Iterator<Item=(A, B)>
+{
+    write!(f, "{{").and_then(|()| {
+        it.fold((Ok(()), true), |(res, start), (a, b)| {
+            let comma = if start { "" } else { "," };
+            (res.and_then(|()| write!(f, "{} {}: {}", comma, a, b)), false)
+        }).0
+    }).and_then(|()| write!(f, " }}"))
+}
+
 
 #[cfg(test)]
 mod test {

lib/src/common/shared.rs

@@ -48,7 +48,7 @@ impl<'a, T: 'a> Deref for RefHolder<'a, T> {
 }
 
 impl<T> LockBorrow<T> for &T {
-    fn borrow<'a>(&'a self) -> Box<dyn Deref<Target=T> + '_> {
+    fn borrow(&self) -> Box<dyn Deref<Target=T> + '_> {
         Box::new(RefHolder(self))
     }
 }
@@ -64,7 +64,7 @@ impl<'a, T: 'a> Deref for RefHolderMut<'a, T> {
 }
 
 impl<T> LockBorrow<T> for &mut T {
-    fn borrow<'a>(&'a self) -> Box<dyn Deref<Target=T> + '_> {
+    fn borrow(&self) -> Box<dyn Deref<Target=T> + '_> {
         Box::new(RefHolderMut(self))
     }
 }

lib/src/metta/runner/environment.rs

@@ -76,13 +76,13 @@ impl Environment {
 
     /// Returns the [ModuleCatalog]s from the Environment, in search priority order
     #[cfg(feature = "pkg_mgmt")]
-    pub fn catalogs<'a>(&'a self) -> impl Iterator<Item=&dyn ModuleCatalog> + 'a {
+    pub fn catalogs(&self) -> impl Iterator<Item=&'_ dyn ModuleCatalog> + '_ {
         self.catalogs.iter().map(|catalog| &**catalog as &dyn ModuleCatalog)
     }
 
     /// Returns the [FsModuleFormat]s from the Environment, in priority order
     #[cfg(feature = "pkg_mgmt")]
-    pub fn fs_mod_formats<'a>(&'a self) -> impl Iterator<Item=&dyn FsModuleFormat> + 'a {
+    pub fn fs_mod_formats(&self) -> impl Iterator<Item=&'_ dyn FsModuleFormat> + '_ {
         self.fs_mod_formats.iter().map(|fmt| &**fmt as &dyn FsModuleFormat)
     }
 

lib/src/metta/runner/stdlib/atom.rs

@@ -3,12 +3,13 @@ use crate::space::*;
 use crate::metta::*;
 use crate::metta::text::Tokenizer;
 use crate::metta::types::{get_atom_types, get_meta_type};
-use crate::common::multitrie::MultiTrie;
-use crate::space::grounding::atom_to_trie_key;
+use crate::common::multitrie::{MultiTrie, TrieKey, TrieToken};
+use crate::common::collections::ImmutableString;
 use super::{grounded_op, regex};
 use crate::metta::runner::number::*;
 
 use std::convert::TryInto;
+use std::hash::{DefaultHasher, Hasher};
 
 #[derive(Clone, Debug)]
 pub struct UniqueAtomOp {}
@@ -83,6 +84,35 @@ impl Grounded for IntersectionAtomOp {
     }
 }
 
+fn atom_to_trie_key(atom: &Atom) -> TrieKey<SymbolAtom> {
+    fn fill_key(atom: &Atom, tokens: &mut Vec<TrieToken<SymbolAtom>>) {
+        match atom {
+            Atom::Symbol(sym) => tokens.push(TrieToken::Exact(sym.clone())),
+            Atom::Expression(expr) => {
+                tokens.push(TrieToken::LeftPar);
+                expr.children().iter().for_each(|child| fill_key(child, tokens));
+                tokens.push(TrieToken::RightPar);
+            },
+            Atom::Grounded(g) if g.as_grounded().as_match().is_none() => {
+                // TODO: Adding Hash on grounded atoms matched by equality is
+                // required in order to make TrieToken::Exact be generated for
+                // them.
+                let mut h = DefaultHasher::new();
+                match (*g).serialize(&mut h) {
+                    Ok(()) => { tokens.push(TrieToken::Exact(SymbolAtom::new(ImmutableString::Allocated(h.finish().to_string())))) }
+                    Err(_) => { tokens.push(TrieToken::Wildcard) }
+                }
+            }
+            _ => tokens.push(TrieToken::Wildcard),
+        }
+    }
+
+    let mut tokens = Vec::new();
+    fill_key(atom, &mut tokens);
+    TrieKey::from(tokens)
+}
+
+
 impl CustomExecute for IntersectionAtomOp {
     fn execute(&self, args: &[Atom]) -> Result<Vec<Atom>, ExecError> {
         let arg_error = || ExecError::from("intersection expects and executable LHS and RHS atom");
@@ -607,6 +637,19 @@ mod tests {
                         ("A" ("B" "C")) "p" "p" ("Q" "a"))]);
     }
 
+    #[test]
+    fn index_atom_to_key() {
+        assert_eq!(atom_to_trie_key(&Atom::sym("A")), TrieKey::from([TrieToken::Exact(SymbolAtom::new("A".into()))]));
+        assert_eq!(atom_to_trie_key(&Atom::value(1)), TrieKey::from([TrieToken::Wildcard]));
+        assert_eq!(atom_to_trie_key(&Atom::var("a")), TrieKey::from([TrieToken::Wildcard]));
+        assert_eq!(atom_to_trie_key(&expr!("A" "B")), TrieKey::from([
+                TrieToken::LeftPar,
+                TrieToken::Exact(SymbolAtom::new("A".into())),
+                TrieToken::Exact(SymbolAtom::new("B".into())),
+                TrieToken::RightPar
+        ]));
+    }
+
     #[test]
     fn intersection_op() {
         let intersection_op = IntersectionAtomOp{};