gh-17: Add new kwargs to MATCH operator

Author: python-processing-unit

asm-lang.exe

@@ -699,7 +699,7 @@
 
 - `VALUEIN(ANY: value, MAP: map):INT` - Returns `1` if any value stored in `map` is equal to `value` using the language's equality semantics, otherwise `0`.
 
-- `MATCH(MAP: map, MAP: template, INT: typing = 0):INT` - Returns `1` if every key in `template` is present in `map`. If `typing` is true, also require that for each matching key the stored value types are identical between `map` and `template`; otherwise return `0`.
+- `MATCH(MAP: map, MAP: template, INT: typing = 0, INT: recurse = 0, INT: shape = 0):INT` - Returns `1` if every key in `template` is present in `map`. If `typing` is true, also require that for each matching key the stored value types are identical between `map` and `template`. If `shape` is true, require that for any matching key where either side is a `TNS`, both sides are `TNS` and their shapes are identical. If `recurse` is true, apply these same rules to every `MAP` value nested anywhere within `map` (recursively). On any failure return `0`.
 
 - `INV(MAP: map):MAP` - Return a new map whose key/value pairs are reversed. Each value in `map` becomes a key in the returned map and each original key becomes the corresponding value. All values in `map` MUST be scalar (`INT`, `FLT`, or `STR`) so they can be used as keys; otherwise `INV` raises a runtime error. If `map` contains duplicate values (by key type and value), `INV` raises a runtime error.
 
@@ -725,9 +725,7 @@
 
 ### 12.9 Logarithms
 
-- `LOG(INT: a):INT` ; floor(log2(a)) for a > 0
-
-- `LOG(FLT: a):FLT` ; floor(log2(a)) for a > 0
+- `LOG(INT|FLT: a):INT|FLT` ; floor(log2(a)) for a > 0
 
 - `CLOG(INT: a):INT` ; ceil(log2(a)) for a > 0
 

docs/SPECIFICATION.html

@@ -536,7 +536,7 @@ def __init__(self) -> None:
         self._register_custom("KEYS", 1, 1, self._keys)
         self._register_custom("VALUES", 1, 1, self._values)
         self._register_custom("KEYIN", 2, 2, self._keyin)
-        self._register_custom("MATCH", 2, 3, self._match)
+        self._register_custom("MATCH", 2, 5, self._match)
         self._register_custom("VALUEIN", 2, 2, self._valuein)
         self._register_custom("INV", 1, 1, self._inv)
         self._register_custom("EXPORT", 2, 2, self._export)
@@ -1271,39 +1271,78 @@ def _match(
         ___: Environment,
         location: SourceLocation,
     ) -> Value:
-        # MATCH(MAP: map, MAP: template, INT: typing = 0):INT
+        # MATCH(MAP: map, MAP: template, INT: typing = 0, INT: recurse = 0, INT: shape = 0):INT
         # Return 1 if every key in `template` is present in `map`.
         # If `typing` is true (non-zero), also require the types of the
         # associated values to match between the two maps.
-        if len(args) not in (2, 3):
-            raise ASMRuntimeError("MATCH requires two or three arguments", location=location, rewrite_rule="MATCH")
+        # If `recurse` is true, apply the same rules to every MAP value nested
+        # anywhere within `map` (recursively).
+        # If `shape` is true, require that any matching TNS values have identical
+        # shapes between `map` and `template`.
+        if len(args) not in (2, 3, 4, 5):
+            raise ASMRuntimeError("MATCH requires 2 to 5 arguments", location=location, rewrite_rule="MATCH")
         mval = args[0]
         tval = args[1]
-        typing_flag = Value(TYPE_INT, 0)
-        if len(args) == 3:
-            typing_flag = args[2]
+        typing_flag = args[2] if len(args) >= 3 else Value(TYPE_INT, 0)
+        recurse_flag = args[3] if len(args) >= 4 else Value(TYPE_INT, 0)
+        shape_flag = args[4] if len(args) >= 5 else Value(TYPE_INT, 0)
 
         if mval.type != TYPE_MAP:
             raise ASMRuntimeError("MATCH expects a MAP as first argument", location=location, rewrite_rule="MATCH")
         if tval.type != TYPE_MAP:
             raise ASMRuntimeError("MATCH expects a MAP as second argument", location=location, rewrite_rule="MATCH")
         if typing_flag.type != TYPE_INT:
             raise ASMRuntimeError("MATCH expects typing flag to be INT", location=location, rewrite_rule="MATCH")
+        if recurse_flag.type != TYPE_INT:
+            raise ASMRuntimeError("MATCH expects recurse flag to be INT", location=location, rewrite_rule="MATCH")
+        if shape_flag.type != TYPE_INT:
+            raise ASMRuntimeError("MATCH expects shape flag to be INT", location=location, rewrite_rule="MATCH")
 
         m = mval.value
         t = tval.value
         assert isinstance(m, Map) and isinstance(t, Map)
 
         require_typing = 0 if typing_flag.value == 0 else 1
+        require_recurse = 0 if recurse_flag.value == 0 else 1
+        require_shape = 0 if shape_flag.value == 0 else 1
 
-        for key in t.data.keys():
-            if key not in m.data:
-                return Value(TYPE_INT, 0)
-            if require_typing:
-                mv = m.data[key]
+        def _match_one(mm: Map) -> int:
+            for key in t.data.keys():
+                if key not in mm.data:
+                    return 0
+                mv = mm.data[key]
                 tv = t.data[key]
-                if mv.type != tv.type:
-                    return Value(TYPE_INT, 0)
+                if require_typing and mv.type != tv.type:
+                    return 0
+                if require_shape:
+                    if (mv.type == TYPE_TNS) or (tv.type == TYPE_TNS):
+                        if mv.type != TYPE_TNS or tv.type != TYPE_TNS:
+                            return 0
+                        mt = mv.value
+                        tt = tv.value
+                        if not isinstance(mt, Tensor) or not isinstance(tt, Tensor):
+                            return 0
+                        if mt.shape != tt.shape:
+                            return 0
+            return 1
+
+        if not require_recurse:
+            return Value(TYPE_INT, _match_one(m))
+
+        # Recurse into nested MAP values within `map`.
+        visited: set[int] = set()
+        stack: List[Map] = [m]
+        while stack:
+            mm = stack.pop()
+            mm_id = id(mm)
+            if mm_id in visited:
+                continue
+            visited.add(mm_id)
+            if _match_one(mm) == 0:
+                return Value(TYPE_INT, 0)
+            for v in mm.data.values():
+                if v.type == TYPE_MAP and isinstance(v.value, Map):
+                    stack.append(v.value)
 
         return Value(TYPE_INT, 1)
 
@@ -1370,7 +1409,7 @@ def _bool(self, interpreter: "Interpreter", args: List[Value], __: List[Expressi
         # BOOL(ANY: item):INT -> truthiness of item (INT: nonzero, STR: non-empty, TNS: any true element)
         return Value(TYPE_INT, 1 if self._as_bool_value(interpreter, args[0], loc) != 0 else 0)
 
-    def _eq(self, interpreter: "Interpreter", args: List[Value], __: List[Expression], ___: Environment, ___loc: SourceLocation) -> Value:
+    def _eq(self, interpreter: "Interpreter", args: List[Value], __: List[Expression], ___: Environment, location: SourceLocation) -> Value:
         a, b = args
         return Value(TYPE_INT, 1 if interpreter._values_equal(a, b) else 0)
 
@@ -1639,7 +1678,7 @@ def _os(
         args: List[Value],
         __: List[Expression],
         ___: Environment,
-        __loc: SourceLocation,
+        loc: SourceLocation,
     ) -> Value:
         # Return a short lowercase host OS family string as STR.
         plat = sys.platform.lower()

interpreter.py

@@ -306,6 +306,43 @@ FUNC BUILTIN_TESTS():INT{
     ASSERT( EQ( MATCH(mm2, tmpl3), 1 ) )
     MAP: tmpl4 = < "three" = 1 >
     ASSERT( EQ( MATCH(mm2, tmpl4), 0 ) )
+
+    # MATCH recurse flag: when true, apply same template rules to nested MAPs.
+    MAP: mmr_ok = < "one" = 1, "child" = < "one" = 1 > >
+    ASSERT( EQ( MATCH(mmr_ok, tmpl1, 0, 0), 1 ) )
+    ASSERT( EQ( MATCH(mmr_ok, tmpl1, 0, 1), 1 ) )
+    MAP: mmr_bad = < "one" = 1, "child" = < "two" = 10 > >
+    ASSERT( EQ( MATCH(mmr_bad, tmpl1, 0, 0), 1 ) )
+    ASSERT( EQ( MATCH(mmr_bad, tmpl1, 0, 1), 0 ) )
+    # recurse + typing: nested MAP must also satisfy typing constraint.
+    MAP: mmr_tbad = < "one" = 1, "child" = < "one" = "x" > >
+    ASSERT( EQ( MATCH(mmr_tbad, tmpl1, 1, 0), 1 ) )
+    ASSERT( EQ( MATCH(mmr_tbad, tmpl1, 1, 1), 0 ) )
+
+    # MATCH shape flag: when true, require matching TNS shapes.
+    TNS: s1 = [1, 10, 11]
+    TNS: s1b = [0, 0, 0]
+    TNS: s2 = [[1,10],[11,100]]
+    MAP: mshape_ok = < "t" = s1 >
+    MAP: tshape_ok = < "t" = s1b >
+    ASSERT( EQ( MATCH(mshape_ok, tshape_ok, 1, 0, 1), 1 ) )
+    MAP: tshape_bad = < "t" = s2 >
+    ASSERT( EQ( MATCH(mshape_ok, tshape_bad, 1, 0, 1), 0 ) )
+    # If shape is enabled and either side is a TNS, both must be TNS.
+    MAP: mshape_non = < "t" = 1 >
+    ASSERT( EQ( MATCH(mshape_non, tshape_ok, 0, 0, 0), 1 ) )
+    ASSERT( EQ( MATCH(mshape_non, tshape_ok, 0, 0, 1), 0 ) )
+
+    DEL(mmr_ok)
+    DEL(mmr_bad)
+    DEL(mmr_tbad)
+    DEL(s1)
+    DEL(s1b)
+    DEL(s2)
+    DEL(mshape_ok)
+    DEL(tshape_ok)
+    DEL(tshape_bad)
+    DEL(mshape_non)
     DEL(tmpl1)
     DEL(tmpl2)
     DEL(tmpl3)