gh-12: Add MATCH operator.

Author: python-processing-unit

README.md

@@ -1,8 +1,6 @@
 ## Installation
-<code>
-Invoke-WebRequest -Uri "https://github.com/python-processing-unit/ASM-Lang/archive/refs/heads/main.zip" -OutFile "path\to\download\ASM-Lang.zip"<br>
+<code>Invoke-WebRequest -Uri "https://github.com/python-processing-unit/ASM-Lang/archive/refs/heads/main.zip" -OutFile "path\to\download\ASM-Lang.zip"<br>
 Expand-Archive -Path "path\to\download\ASM-Lang.zip" -DestinationPath "path\to\extract\ASM-Lang"<br>
 $old = [Environment]::GetEnvironmentVariable('Path','User')<br>
 if(-not $old.Split(';') -contains 'path\to\extract\ASM-Lang'){ [Environment]::SetEnvironmentVariable('Path',$old + ';path\to\extract\ASM-Lang','User') }<br>
-Remove-Item -Path "path\to\download\ASM-Lang.zip"
-</code>
+Remove-Item -Path "path\to\download\ASM-Lang.zip"</code>

asm-lang.exe

@@ -697,6 +697,8 @@
 
 - `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`.
+
 - `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.
 
 ### 12.8 Concurrency

docs/SPECIFICATION.html

@@ -534,6 +534,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("VALUEIN", 2, 2, self._valuein)
         self._register_custom("INV", 1, 1, self._inv)
         self._register_custom("EXPORT", 2, 2, self._export)
@@ -1260,6 +1261,50 @@ def _valuein(
                 return Value(TYPE_INT, 1)
         return Value(TYPE_INT, 0)
 
+    def _match(
+        self,
+        interpreter: "Interpreter",
+        args: List[Value],
+        __: List[Expression],
+        ___: Environment,
+        location: SourceLocation,
+    ) -> Value:
+        # MATCH(MAP: map, MAP: template, INT: typing = 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")
+        mval = args[0]
+        tval = args[1]
+        typing_flag = Value(TYPE_INT, 0)
+        if len(args) == 3:
+            typing_flag = args[2]
+
+        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")
+
+        m = mval.value
+        t = tval.value
+        assert isinstance(m, Map) and isinstance(t, Map)
+
+        require_typing = 0 if typing_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]
+                tv = t.data[key]
+                if mv.type != tv.type:
+                    return Value(TYPE_INT, 0)
+
+        return Value(TYPE_INT, 1)
+
     def _inv(
         self,
         _: "Interpreter",

interpreter.py

@@ -286,6 +286,21 @@ FUNC BUILTIN_TESTS():INT{
     ASSERT( EQ( inv2<10>, "two" ) )
     DEL(inv2<1>)
     ASSERT( EQ( KEYIN(1, inv2), 0 ) )
+    # MATCH operator tests
+    MAP: tmpl1 = < "one" = 1 >
+    MAP: tmpl2 = < "one" = "x" >
+    ASSERT( EQ( MATCH(mm2, tmpl1), 1 ) )
+    ASSERT( EQ( MATCH(mm2, tmpl2), 1 ) )
+    ASSERT( EQ( MATCH(mm2, tmpl1, 1), 1 ) )
+    ASSERT( EQ( MATCH(mm2, tmpl2, 1), 0 ) )
+    MAP: tmpl3 = < "one" = 1, "two" = 10 >
+    ASSERT( EQ( MATCH(mm2, tmpl3), 1 ) )
+    MAP: tmpl4 = < "three" = 1 >
+    ASSERT( EQ( MATCH(mm2, tmpl4), 0 ) )
+    DEL(tmpl1)
+    DEL(tmpl2)
+    DEL(tmpl3)
+    DEL(tmpl4)
     DEL(ks)
     DEL(vs)
     DEL(inv2)