subtypes can have any length, pattern matching treats such cases correctly

Author: telmomenezes

CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## [0.10.1] - work in progress
+## [0.11.0] - work in progress
 
 ### Added
 
@@ -15,6 +15,7 @@
 
 ### Changed
 
+- subtypes can have any length, pattern matching treats such cases correctly.
 - transforms propagate per-atom `tok_pos`/`text_span` through rewrites.
 - REPL `/load` now uses `ParseResult.from_dict` (was dropping `tokens`/`tok_pos`).
 - REPL shows multiple results if available.

src/hyperbase/hyperedge.py

@@ -330,14 +330,17 @@ def connector_mtype(self) -> str | None:
 
     def atom_with_type(self, atom_type: str) -> Atom | None:
         """Returns the first atom found in the edge that has the given
-        'atom_type', or whose type starts with 'atom_type'.
+        'atom_type'. A bare main type (single character) matches any subtype;
+        a type with a subtype must match exactly.
         If no such atom is found, returns None.
 
         For example, given the edge (+/B a/Cn b/Cp) and the 'atom_type'
-        c, this function returns:
+        'C', this function returns:
         a/Cn
         If the 'atom_type' is 'Cp', the it will return:
         b/Cp
+        Querying for 'Cm' would NOT match an atom typed 'Cmath' --
+        only an exact 'Cm' would.
         """
         for item in self:
             atom: Atom | None = item.atom_with_type(atom_type)
@@ -612,11 +615,12 @@ def connector_type(self) -> str | None:
 
     def atom_with_type(self, atom_type: str) -> Atom | None:
         et = self.type()
-        n = len(atom_type)
-        if len(et) >= n and et[:n] == atom_type:
+        if len(atom_type) == 1:
+            if et and et[0] == atom_type:
+                return self
+        elif et == atom_type:
             return self
-        else:
-            return None
+        return None
 
     def argroles(self) -> str:
         if "argroles" in self._cache:

src/hyperbase/patterns/matcher.py

@@ -163,12 +163,15 @@ def _matches_atomic_pattern(edge: Hyperedge, atomic_pattern: Atom) -> bool:
     if len(ap_parts) > 1:
         pos = 1
 
-        # type match
+        # type match: a bare main type (single character) matches any
+        # subtype; a type that includes a subtype must match exactly.
         ap_role = atomic_pattern.role()
         ap_type = ap_role[0]
         e_type = edge.type()
-        n = len(ap_type)
-        if len(e_type) < n or e_type[:n] != ap_type:
+        if len(ap_type) == 1:
+            if not e_type or e_type[0] != ap_type:
+                return False
+        elif e_type != ap_type:
             return False
 
         e_atom = edge.inner_atom()

tests/test_hyperedge.py

@@ -436,6 +436,24 @@ def test_non_atom_mtype9(self):
     def test_non_atom_mtype10(self):
         assert hedge("(and/J (is/Pd.so hyperbase/Cp.s great/C))").mtype() == "R"
 
+    def test_atom_type_long_subtype(self):
+        assert hedge("exp/Cmath").type() == "Cmath"
+        assert hedge("exp/Cmath").mtype() == "C"
+
+    def test_atom_role_long_subtype(self):
+        assert hedge("was/Ppast.so").role() == ["Ppast", "so"]
+        assert hedge("was/Ppast.so").type() == "Ppast"
+        assert hedge("was/Ppast.so").mtype() == "P"
+        assert hedge("was/Ppast.so").argroles() == "so"
+
+    def test_non_atom_type_long_subtype(self):
+        assert hedge("(was/Ppast.so john/C art/C)").type() == "Rpast"
+        assert hedge("(was/Ppast.so john/C art/C)").mtype() == "R"
+
+    def test_non_atom_type_long_modifier_subtype(self):
+        assert hedge("(red/Mcolor shoes/Cc.p)").type() == "Cc"
+        assert hedge("(before/Tlong noon/C)").type() == "Slong"
+
     def test_connector_type1(self):
         assert hedge("hyperbase/Cp.s/1").connector_type() is None
 
@@ -553,6 +571,26 @@ def test_atom_with_type6(self):
     def test_atom_with_type7(self):
         assert hedge("a/Cn").atom_with_type("P") is None
 
+    def test_atom_with_type_long_subtype1(self):
+        edge = hedge("(is/Pd.so john/Cmath rich/C)")
+        assert edge.atom_with_type("Cmath") == hedge("john/Cmath")
+
+    def test_atom_with_type_long_subtype2(self):
+        edge = hedge("(is/Pd.so john/Cmath rich/C)")
+        assert edge.atom_with_type("C") == hedge("john/Cmath")
+
+    def test_atom_with_type_long_subtype3(self):
+        edge = hedge("(is/Pd.so john/Cmath rich/C)")
+        assert edge.atom_with_type("Cmusic") is None
+
+    def test_atom_with_type_partial_subtype_no_match(self):
+        edge = hedge("(is/Pd.so john/Cmath rich/C)")
+        assert edge.atom_with_type("Cm") is None
+
+    def test_atom_with_type_short_subtype_no_match_against_long(self):
+        edge = hedge("(is/Pd.so john/Cmath rich/Cm)")
+        assert edge.atom_with_type("Cm") == hedge("rich/Cm")
+
     def test_argroles_connector_atom1(self):
         edge = hedge("s/Bp.am")
         assert edge.argroles() == "am"

tests/test_patterns.py

@@ -115,6 +115,28 @@ def test_match_pattern_atomic_wildcard4(self):
             == []
         )
 
+    def test_match_pattern_bare_main_type_matches_long_subtype(self):
+        assert match_pattern("(is/Pd john/Cmath rich/C)", "(is/Pd */C rich/C)") == [{}]
+
+    def test_match_pattern_bare_main_type_matches_short_subtype(self):
+        assert match_pattern("(is/Pd john/Cp.s rich/C)", "(is/Pd */C rich/C)") == [{}]
+
+    def test_match_pattern_exact_subtype_matches(self):
+        assert match_pattern("(is/Pd john/Cm rich/C)", "(is/Pd */Cm rich/C)") == [{}]
+
+    def test_match_pattern_short_subtype_does_not_match_long(self):
+        assert match_pattern("(is/Pd john/Cmath rich/C)", "(is/Pd */Cm rich/C)") == []
+
+    def test_match_pattern_long_subtype_exact_match(self):
+        assert match_pattern("(is/Pd john/Cmath rich/C)", "(is/Pd */Cmath rich/C)") == [
+            {}
+        ]
+
+    def test_match_pattern_long_subtype_does_not_match_other_long(self):
+        assert (
+            match_pattern("(is/Pd john/Cmath rich/C)", "(is/Pd */Cmusic rich/C)") == []
+        )
+
     def test_match_pattern_non_atomic_wildcard1(self):
         assert match_pattern(
             "(is/Pd hyperbase/Cp.s (fairly/M great/C))", "(is/Pd hyperbase/Cp.s (PROP))"