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

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;

lib/src/metta/interpreter.rs

@@ -88,7 +88,7 @@ pub struct InterpreterState<'a, T: SpaceRef<'a>> {
 impl<'a, T: SpaceRef<'a>> InterpreterState<'a, T> {
 
     /// INTERNAL USE ONLY. Create an InterpreterState that is ready to yield results
-    #[cfg(not(feature = "minimal"))]
+    #[cfg(feature = "old_interpreter")]
     pub(crate) fn new_finished(_space: T, results: Vec<Atom>) -> Self {
         Self {
             step_result: StepResult::Return(results.into_iter().map(|atom| InterpretedAtom(atom, Bindings::new())).collect()),
@@ -177,6 +177,10 @@ pub fn interpret_init<'a, T: Space + 'a>(space: T, expr: &Atom) -> InterpreterSt
 }
 
 fn interpret_init_internal<'a, T: Space + 'a>(space: T, expr: &Atom) -> StepResult<'a, Results, InterpreterError> {
+    let expr = match <&[Atom]>::try_from(expr).ok() {
+        Some([op, atom, _typ, _space]) if *op == METTA_SYMBOL => atom,
+        _ => expr,
+    };
     let context = InterpreterContextRef::new(space);
     interpret_as_type_plan(context,
         InterpretedAtom(expr.clone(), Bindings::new()),