Merge branch 'main' into edit_listening_agent

c/src/atom.rs

@@ -1256,7 +1256,7 @@ pub extern "C" fn bindings_add_var_binding(bindings: *mut bindings_t, var: atom_
         _ => panic!("var argument must be variable atom")
     };
     let atom = atom.into_inner();
-    match bindings.clone().add_var_binding_v2(var, atom) {
+    match bindings.clone().add_var_binding(var, atom) {
         Ok(new_bindings) => {
             *bindings = new_bindings;
             true
@@ -1309,7 +1309,7 @@ pub extern "C" fn bindings_merge(_self: bindings_t, other: *const bindings_t) ->
     let other = unsafe{ &*other }.borrow();
     let owned_self = _self.into_inner();
 
-    let new_set = owned_self.merge_v2(other);
+    let new_set = owned_self.merge(other);
     new_set.into()
 }
 

lib/examples/custom_match.rs

@@ -36,14 +36,15 @@ impl Grounded for TestDict {
 impl CustomMatch for TestDict {
     fn match_(&self, other: &Atom) -> MatchResultIter {
         if let Some(other) = other.as_gnd::<TestDict>() {
-            other.0.iter().map(|(ko, vo)| {
+            Box::new(other.0.iter().map(|(ko, vo)| {
                 self.0.iter().map(|(k, v)| {
                     match_atoms(&Atom::expr(vec![k.clone(), v.clone()]), &Atom::expr(vec![ko.clone(), vo.clone()]))
                 }).fold(Box::new(std::iter::empty()) as MatchResultIter, |acc, i| {
                     Box::new(acc.chain(i))
-                })
-            }).fold(Box::new(std::iter::once(Bindings::new())),
-            |acc, i| { matcher::match_result_product(acc, i) })
+                }).collect::<BindingsSet>()
+            }).fold(BindingsSet::single(),
+            |acc, i| { acc.merge(&i) })
+            .into_iter())
         } else {
             Box::new(std::iter::empty())
         }

lib/src/metta/interpreter.rs

@@ -567,7 +567,7 @@ fn query<'a, T: Space>(space: T, prev: Option<Rc<RefCell<Stack>>>, to_eval: Atom
     let result = |res, bindings| eval_result(prev.clone(), res, &call_stack, bindings);
     let results: Vec<InterpretedAtom> = results.into_iter().flat_map(|b| {
         log::debug!("interpreter::query: b: {}", b);
-        b.merge_v2(&bindings).into_iter()
+        b.merge(&bindings).into_iter()
     }).filter_map(move |b| {
         b.resolve(&var_x).map_or(None, |res| {
             if b.has_loops() {
@@ -640,7 +640,7 @@ fn chain(stack: Stack, bindings: Bindings) -> Vec<InterpretedAtom> {
             panic!("Unexpected state")
         }
     };
-    let b = Bindings::new().add_var_binding_v2(var, nested).unwrap();
+    let b = Bindings::new().add_var_binding(var, nested).unwrap();
     let templ = apply_bindings_to_atom_move(templ, &b);
     vec![InterpretedAtom(atom_to_stack(templ, prev), bindings)]
 }
@@ -760,7 +760,7 @@ fn unify(stack: Stack, bindings: Bindings) -> Vec<InterpretedAtom> {
     };
     let bindings_ref = &bindings;
     let matches: Vec<InterpretedAtom> = matches.into_iter().flat_map(move |b| {
-        b.merge_v2(bindings_ref).into_iter().filter_map(move |b| {
+        b.merge(bindings_ref).into_iter().filter_map(move |b| {
             if b.has_loops() {
                 None
             } else {
@@ -842,7 +842,7 @@ fn superpose_bind(stack: Stack, bindings: Bindings) -> Vec<InterpretedAtom> {
                 let stack = Stack::finished(prev.clone(), atom);
                 InterpretedAtom(stack, bindings)
             };
-            b.merge_v2(&bindings).into_iter().filter_map(move |b| {
+            b.merge(&bindings).into_iter().filter_map(move |b| {
                 if b.has_loops() {
                     None
                 } else {
@@ -989,7 +989,7 @@ fn match_types(type1: &Atom, type2: &Atom, bindings: Bindings) -> Result<MatchRe
     } else {
         let bindings_copy = bindings.clone();
         let mut result = match_atoms(type1, type2)
-            .flat_map(move |b| b.merge_v2(&bindings).into_iter())
+            .flat_map(move |b| b.merge(&bindings).into_iter())
             .peekable();
         if result.peek().is_none() {
             log::trace!("match_types: no match: {} !~ {}", type1, type2);

lib/src/metta/runner/stdlib/stdlib.metta

@@ -816,7 +816,7 @@
         (@doc-formal (@item $atom) (@kind atom) (@type $type) (@desc "No documentation")) )))))
 
 (@doc help!
-  (@desc "Function prints documentation for the input atom.")
+  (@desc "Function prints documentation for the input atom. Without parameters prints the list of the stdlib functions.")
   (@params (
     (@param "Input to get documentation for")))
   (@return "Unit atom"))
@@ -839,6 +839,16 @@
       () ))
     ($other (Error $other "Cannot match @doc-formal structure") ))))
 
+(: help! (-> (->)))
+(= (help!) (let $top-space (mod-space! top)
+    (unify $top-space (@doc $name (@desc $desc) $params $ret)
+      (let () (println! (format-args "{}\n\t{}" ($name $desc))) Empty)
+      Empty)))
+(= (help!) (let $top-space (mod-space! top)
+    (unify $top-space (@doc $name (@desc $desc))
+      (let () (println! (format-args "{}\n\t{}" ($name $desc))) Empty)
+      Empty)))
+
 (@doc help-param!
   (@desc "Function used by function help! to output parameters using println!")
   (@params (

lib/src/metta/types.rs

@@ -69,7 +69,7 @@ fn check_arg_types(actual: &[Vec<Atom>], meta: &[Vec<Atom>], expected: &[Atom],
                 for typ in actual {
                     result_bindings.extend(
                         match_reducted_types_v2(typ, expected)
-                            .flat_map(|b| b.merge_v2(&bindings))
+                            .flat_map(|b| b.merge(&bindings))
                             .flat_map(|b| check_arg_types(actual_tail, meta_tail, expected_tail, b))
                     );
                 }
@@ -347,7 +347,7 @@ pub fn match_reducted_types(left: &Atom, right: &Atom, bindings: &mut Bindings)
     let matched = match result.len() {
         0 => false,
         1 => {
-            let result_set = result.pop().unwrap().merge_v2(bindings);
+            let result_set = result.pop().unwrap().merge(bindings);
             *bindings = result_set.try_into().expect("Single result is expected because custom matching for types is not supported yet!");
             true
         }

lib/src/space/grounding.rs

@@ -259,7 +259,7 @@ impl GroundingSpace {
                                 let query = matcher::apply_bindings_to_atom_move(query.clone(), &prev);
                                 let mut res = self.query(&query);
                                 res.drain(0..)
-                                    .flat_map(|next| next.merge_v2(&prev))
+                                    .flat_map(|next| next.merge(&prev))
                                     .collect()
                             }).collect()
                         };

repl/src/main.rs

@@ -93,6 +93,11 @@ fn main() -> Result<()> {
     }
 }
 
+fn show_welcome_message() {
+    println!("Visit https://metta-lang.dev/ for tutorials.");
+    println!("Execute !(help!) to get list of the standard library functions.");
+}
+
 // To debug rustyline:
 // RUST_LOG=rustyline=debug cargo run --example example 2> debug.log
 fn start_interactive_mode(repl_params: ReplParams, mut metta: MettaShim) -> rustyline::Result<()> {
@@ -137,6 +142,8 @@ fn start_interactive_mode(repl_params: ReplParams, mut metta: MettaShim) -> rust
         }
     }
 
+    show_welcome_message();
+
     //The Interpreter Loop
     loop {