Merge pull request #1023 from vsbogd/fix-bool

Fix bool

Author: vsbogd

hyperon-atom/src/lib.rs

@@ -656,32 +656,6 @@ pub fn match_by_string_equality(this: &str, other: &Atom) -> matcher::MatchResul
     }
 }
 
-/// A more thorough version of [match_by_equality], which will attempt the match in reverse order
-/// if the `other` atom doesn't wrap the same type as `this`
-pub fn match_by_bidirectional_equality<T>(this: &T, other: &Atom) -> matcher::MatchResultIter
-    where T: 'static + PartialEq + Clone + Grounded + Debug
-{
-    log::trace!("match_by_bidirectional_equality: this: {:?}, other: {}", this, other);
-    if let Some(other_obj) = other.as_gnd::<T>() {
-        match this == other_obj {
-            true => Box::new(std::iter::once(matcher::Bindings::new())),
-            false => Box::new(std::iter::empty()),
-        }
-    } else {
-        let temp_atom = Atom::gnd(this.clone());
-        match other {
-            Atom::Grounded(gnd) => {
-                if let Some(matchable) = gnd.as_grounded().as_match() {
-                    matchable.match_(&temp_atom)
-                } else {
-                    Box::new(std::iter::empty())
-                }
-            },
-            _ => Box::new(std::iter::empty()),
-        }
-    }
-}
-
 /// Alias for the list of traits required for the standard Rust types to be
 /// automatically wrapped into [GroundedAtom]. It is implemented automatically
 /// when type implements `'static + PartialEq + Clone + Debug`. No need

lib/src/metta/runner/bool.rs

@@ -43,21 +43,11 @@ impl Grounded for Bool {
         ATOM_TYPE_BOOL
     }
 
-    fn as_match(&self) -> Option<&dyn CustomMatch> {
-        Some(self)
-    }
-
     fn serialize(&self, serializer: &mut dyn serial::Serializer) -> serial::Result {
         serializer.serialize_bool(self.0)
     }
 }
 
-impl CustomMatch for Bool {
-    fn match_(&self, other: &Atom) -> matcher::MatchResultIter {
-        match_by_bidirectional_equality(self, other)
-    }
-}
-
 #[derive(Default)]
 struct BoolSerializer {
     value: Option<Bool>,

python/hyperon/exts/py_ops/pyop.py

@@ -4,7 +4,7 @@
 @register_tokens
 def arithm_types():
     return {
-        r"True|False": lambda token: ValueAtom(bool(token), 'Bool'),
+        r"True|False": lambda token: ValueAtom(token == "True", 'Bool'),
         r"[-+]?\d+": lambda token: ValueAtom(int(token), 'Number'),
         r"[-+]?\d+\.\d+": lambda token: ValueAtom(float(token), 'Number'),
         r"[-+]?\d+(\.\d+)?[eE][-+]?\d+": lambda token: ValueAtom(float(token), 'Number'),

python/tests/test_modules.py

@@ -48,5 +48,16 @@ def test_py_ops(self):
         result = runner.run('!(* "a" 4)')
         self.assertEqual(result[0][0], ValueAtom('aaaa'))
 
+    def test_bool(self):
+        """
+        Tests that boolean value is properly parsed by py_ops
+        """
+        runner = MeTTa(env_builder=Environment.custom_env())
+        runner.run("!(import! &self py_ops)")
+        result = runner.run('!(id False)')
+        self.assertEqual(result[0][0], ValueAtom(False))
+        result = runner.run('!(id True)')
+        self.assertEqual(result[0][0], ValueAtom(True))
+
 if __name__ == "__main__":
     unittest.main()