Merge pull request #728 from vsbogd/rust-minimal

Minimal MeTTa interpreter written mostly in Rust

.github/workflows/minimal.yml → .github/workflows/old_interpreter.yml

@@ -1,11 +1,11 @@
-# This workflow is intended to run tests on minimal MeTTa interpreter.
+# This workflow is intended to run tests on old Rust MeTTa interpreter.
 # It is indicative and temporary, it doesn't prevent any changes from merging.
 
 # This workflow uses actions that are not certified by GitHub.  They are
 # provided by a third-party and are governed by separate terms of service,
 # privacy policy, and support documentation.
 
-name: minimal
+name: old_interpreter
 
 on:
   push:
@@ -16,7 +16,7 @@ on:
       - main
 
 jobs:
-  minimal:
+  old_interpreter:
     runs-on: "ubuntu-20.04"
 
     steps:
@@ -32,13 +32,13 @@ jobs:
       - name: Build Rust library
         working-directory: ./lib
         run: |
-          cargo check --features minimal
-          cargo build --features minimal
+          cargo check --features old_interpreter
+          cargo build --features old_interpreter
 
       - name: Test Rust library
         working-directory: ./lib
         run: |
-          RUST_LOG=hyperon=debug cargo test --features minimal
+          RUST_LOG=hyperon=debug cargo test --features old_interpreter
 
       - name: Install cbindgen
         uses: actions-rs/[email protected]
@@ -106,7 +106,7 @@ jobs:
           cd build
           # specify C compiler as conan could not find it automatically
           # see https://github.com/conan-io/conan/issues/4322
-          cmake -DCARGO_ARGS="--features hyperon/minimal" -DCMAKE_BUILD_TYPE=Release -DPython3_EXECUTABLE=`which python` -DCMAKE_C_COMPILER=gcc ..
+          cmake -DCARGO_ARGS="--features hyperon/old_interpreter" -DCMAKE_BUILD_TYPE=Release -DPython3_EXECUTABLE=`which python` -DCMAKE_C_COMPILER=gcc ..
 
       - name: Build C API
         working-directory: ./build

c/src/metta.rs

@@ -639,6 +639,16 @@ pub extern "C" fn atom_error_message(atom: *const atom_ref_t, buf: *mut c_char,
     hyperon::metta::UNIT_ATOM().into()
 }
 
+/// @brief Creates a Symbol atom for the special MeTTa symbol used to indicate
+/// calling MeTTa interpreter.
+/// @ingroup metta_language_group
+/// @return  The `atom_t` representing the interpret atom
+/// @note The returned `atom_t` must be freed with `atom_free()`
+///
+#[no_mangle] pub extern "C" fn METTA_ATOM() -> atom_t {
+    hyperon::metta::METTA_SYMBOL.into()
+}
+
 /// @brief Checks whether Atom `atom` has Type `typ` in context of `space`
 /// @ingroup metta_language_group
 /// @param[in]  space  A pointer to the `space_t` representing the space context in which to perform the check

docs/minimal-metta.md

@@ -325,6 +325,23 @@ used on each exit path while nothing in code of function points to this. Using
 - functions which evaluate result in a loop and have to use `return`;
 - functions which just replace the calling expression by their bodies.
 
+# MeTTa interpreter written in Rust
+
+MeTTa interpreter written in minimal MeTTa has poor performance. To fix this
+the interpreter is rewritten in Rust. Rust implementation can be called using
+`(metta <atom> <type> <space>)` operation. To be able represent process of the
+interpretation as a list of steps and keep ability to control the inference
+`metta` doesn't evaluate passed atom till the end but instead analyses the atom
+and returns the plan written in minimal MeTTa. Plan includes steps written as a
+Rust functions. These steps are called using `(call_native <name> <function>
+<args>)` operation.
+
+Both `metta` and `call_native` could be written as a grounded operations and be
+a part of a standard library. But this requires grounded operations to be able
+returning bindings as a results. Returning bindings as results is a nice to
+have feature anyway to be able representing any functionality as a grounded
+atom. But it is not implemented yet.
+
 # Future work
 
 ## Explicit atomspace variable bindings

lib/Cargo.toml

@@ -30,7 +30,7 @@ crate-type = ["lib"]
 default = ["pkg_mgmt"]
 # Add one of the features below into default list to enable.
 # See https://doc.rust-lang.org/cargo/reference/features.html#the-features-section
-minimal = [] # enables minimal MeTTa interpreter
+old_interpreter = [] # enables old Rust interpreter
 variable_operation = [] # enables evaluation of the expressions which have
                         # a variable on the first position
 git = ["git2", "pkg_mgmt"]

lib/benches/interpreter_minimal.rs

@@ -1,5 +1,5 @@
 #![feature(test)]
-#[cfg(feature = "minimal")]
+#[cfg(not(feature = "old_interpreter"))]
 mod interpreter_minimal_bench {
 
 extern crate test;

lib/src/atom/matcher.rs

@@ -1073,10 +1073,24 @@ impl BindingsSet {
     }
 }
 
+pub trait BindingsResultIter: Iterator<Item=Bindings> {
+    fn clone_(&self) -> Box<dyn BindingsResultIter>;
+}
+impl<T: 'static + Clone + Iterator<Item=Bindings>> BindingsResultIter for T {
+    fn clone_(&self) -> Box<dyn BindingsResultIter> {
+        Box::new(self.clone())
+    }
+}
+
 /// Iterator over atom matching results. Each result is an instance of [Bindings].
 //TODO: A situation where a MatchResultIter returns an unbounded (infinite) number of results
 // will hang this implementation, on account of `.collect()`
-pub type MatchResultIter = Box<dyn Iterator<Item=matcher::Bindings>>;
+pub type MatchResultIter = Box<dyn BindingsResultIter>;
+impl Clone for MatchResultIter {
+    fn clone(&self) -> Self {
+        self.clone_()
+    }
+}
 
 /// Matches two atoms and returns an iterator over results. Atoms are
 /// treated symmetrically.

lib/src/atom/mod.rs

@@ -60,12 +60,12 @@
 /// ```
 /// #[macro_use]
 /// use hyperon::expr;
-/// use hyperon::common::MUL;
+/// use hyperon::metta::runner::arithmetics::MulOp;
 ///
 /// let sym = expr!("A");
 /// let var = expr!(x);
 /// let gnd = expr!({42});
-/// let expr = expr!("=" ("*2" n) ({MUL} n {2}));
+/// let expr = expr!("=" ("*2" n) ({MulOp{}} n {2}));
 ///
 /// assert_eq!(sym.to_string(), "A");
 /// assert_eq!(var.to_string(), "$x");

lib/src/common/mod.rs

@@ -12,9 +12,6 @@ pub mod owned_or_borrowed;
 mod flex_ref;
 pub use flex_ref::FlexRef;
 
-mod arithmetics;
-pub use arithmetics::*;
-
 use crate::*;
 use crate::metta::text::{Tokenizer, SExprParser};
 use std::cell::RefCell;