Merge pull request #1019 from vsbogd/add-macros

Add universal metta! macros to embed MeTTa syntax into Rust programs

Author: vsbogd

Cargo.toml

@@ -3,6 +3,7 @@ members = [
     "hyperon-common",
     "hyperon-atom",
     "hyperon-space",
+    "hyperon-macros",
     "lib",
     "c",
     "repl",
@@ -18,6 +19,7 @@ hyperon = { path = "./lib", version = "0.2.6" }
 hyperon-common = { path = "./hyperon-common", version = "0.2.6" }
 hyperon-atom = { path = "./hyperon-atom", version = "0.2.6" }
 hyperon-space = { path = "./hyperon-space", version = "0.2.6" }
+hyperon-macros = { path = "./hyperon-macros", version = "0.2.6" }
 
 regex = "1.11.0"
 log = "0.4.0"
@@ -27,6 +29,7 @@ env_logger = "0.8.4"
 hyperon-common = { path = "./hyperon-common", version = "0.2.6" }
 hyperon-atom = { path = "./hyperon-atom", version = "0.2.6" }
 hyperon-space = { path = "./hyperon-space", version = "0.2.6" }
+hyperon-macros = { path = "./hyperon-macros", version = "0.2.6" }
 
 [profile.release]
 strip = "symbols"

hyperon-atom/Cargo.toml

@@ -9,6 +9,7 @@ smallvec = "1.10.0"
 bitset = "0.1.2"
 
 hyperon-common = { workspace = true }
+hyperon-macros = { workspace = true }
 
 [lib]
 path = "src/lib.rs"

hyperon-atom/src/lib.rs

@@ -91,14 +91,6 @@ macro_rules! expr {
     ($($x:tt)*) => { $crate::Atom::expr([ $( expr!($x) , )* ]) };
 }
 
-#[macro_export]
-macro_rules! constexpr {
-    () => { $crate::Atom::Expression($crate::ExpressionAtom::new(hyperon_common::collections::CowArray::Literal(&[]))) };
-    ($x:literal) => { $crate::Atom::Symbol($crate::SymbolAtom::new(hyperon_common::unique_string::UniqueString::Const($x))) };
-    (($($x:tt)*)) => { $crate::Atom::Expression($crate::ExpressionAtom::new(hyperon_common::collections::CowArray::Literal(const { &[ $( constexpr!($x) , )* ] }))) };
-    ($($x:tt)*) => { $crate::Atom::Expression($crate::ExpressionAtom::new(hyperon_common::collections::CowArray::Literal(const { &[ $( constexpr!($x) , )* ] }))) };
-}
-
 /// Constructs new symbol atom. Can be used to construct `const` instances.
 ///
 /// # Examples
@@ -171,7 +163,7 @@ pub struct ExpressionAtom {
 
 impl ExpressionAtom {
     /// Constructs new expression from vector of sub-atoms. Not intended to be
-    /// used directly, use [expr!], [constexpr!] or [Atom::expr] instead.
+    /// used directly, use [expr!], [metta!], [metta_const!] or [Atom::expr] instead.
     pub const fn new(children: CowArray<Atom>) -> Self {
         Self{ children, evaluated: false }
     }
@@ -242,16 +234,24 @@ pub struct VariableAtom {
 }
 
 impl VariableAtom {
-    /// Constructs new variable using `name` provided. Name should not contain
-    /// `#` characted which is reserved for internal name formatting (see
-    /// [VariableAtom::parse_name]). Usually [Atom::var] method should be used
-    /// to create new variable atom instance. But sometimes [VariableAtom]
-    /// instance is required. For example for using as a key in variable bindings
-    /// (see [matcher::Bindings]).
+    /// Constructs new variable using `name` provided.  Usually [Atom::var]
+    /// method should be used to create new variable atom instance. But
+    /// sometimes [VariableAtom] instance is required. For example for using
+    /// as a key in variable bindings (see [matcher::Bindings]).
+    /// Name should not contain `#` characted which is reserved for internal
+    /// name formatting (see [VariableAtom::parse_name]).
     pub fn new<T: Into<UniqueString>>(name: T) -> Self {
         Self{ name: Self::check_name(name), id: 0 }
     }
 
+    /// Constructs new constant variable instance using `name` provided. Method
+    /// is introduced to support creating constant expressions.
+    /// Name should not contain `#` characted which is reserved for internal
+    /// name formatting (see [VariableAtom::parse_name]).
+    pub const fn new_const(name: UniqueString) -> Self {
+        Self{ name, id: 0 }
+    }
+
     /// Constructs new variable using `name` and 'id' provided. This method is
     /// used to construct proper variable for testing purposes only.
     pub fn new_id<T: Into<UniqueString>>(name: T, id: usize) -> Self {

hyperon-atom/tests/macros.rs

@@ -0,0 +1,24 @@
+use hyperon_atom::*;
+use hyperon_macros::metta;
+
+#[test]
+fn macros_metta_symbol() {
+    assert_eq!(metta!{A}, Atom::sym("A"));
+}
+
+#[test]
+fn macros_metta_variable() {
+    assert_eq!(metta!{$a}, Atom::var("a"));
+    assert_eq!(metta!{$a+}, Atom::var("a+"));
+}
+
+#[test]
+fn macros_metta_expression() {
+    assert_eq!(metta!{()}, Atom::expr([]));
+    assert_eq!(metta!{(A $a)}, Atom::expr([Atom::sym("A"), Atom::var("a")]));
+    assert_eq!(metta!{(A ($b B) $a)}, Atom::expr([
+        Atom::sym("A"),
+        Atom::expr([Atom::var("b"), Atom::sym("B")]),
+        Atom::var("a")
+    ]));
+}

hyperon-macros/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "hyperon-macros"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+litrs = "0.5.1"
+
+[lib]
+proc-macro = true