Add IN operator

Author: python-processing-unit

SPECIFICATION.md

@@ -287,6 +287,8 @@ Type notation: union signatures such as `INT|STR` restrict arguments to the list
 - `SLEN(STR: s):INT` returns the length of the supplied `STR` in characters as an `INT`. The argument must be a `STR`; passing an `INT` raises a runtime error.
 - `ILEN(INT: n):INT` returns the length in binary digits of the absolute value of the supplied `INT`. `ILEN(0)` returns 1. The argument must be an `INT`; passing a `STR` raises a runtime error.
 
+- `IN(ANY: value, TNS: tensor):INT` ; returns `1` if `value` is equal to any element of `tensor` (using the language's equality semantics), otherwise `0`.
+
 ### Arithmetic (`INT` only)
 - `ADD(INT: a, INT: b):INT` ; a + b
 - `SUB(INT: a, INT: b):INT` ; a - b

asmln.exe

@@ -329,6 +329,7 @@ def __init__(self) -> None:
         self._register_custom("XOR", 2, 2, self._xor)
         self._register_custom("NOT", 1, 1, self._not)
         self._register_custom("EQ", 2, 2, self._eq)
+        self._register_custom("IN", 2, 2, self._in)
         self._register_int_only("GT", 2, lambda a, b: 1 if a > b else 0)
         self._register_int_only("LT", 2, lambda a, b: 1 if a < b else 0)
         self._register_int_only("GTE", 2, lambda a, b: 1 if a >= b else 0)
@@ -662,6 +663,19 @@ def _eq(self, interpreter: "Interpreter", args: List[Value], __: List[Expression
             return Value(TYPE_INT, 1 if interpreter._tensor_equal(a.value, b.value) else 0)
         return Value(TYPE_INT, 1 if a.value == b.value else 0)
 
+    def _in(self, interpreter: "Interpreter", args: List[Value], __: List[Expression], ___: Environment, location: SourceLocation) -> Value:
+        # IN(ANY: value, TNS: tensor):INT -> 1 if value is contained anywhere in tensor, else 0
+        if len(args) != 2:
+            raise ASMRuntimeError("IN requires two arguments", location=location, rewrite_rule="IN")
+        needle, haystack = args
+        if haystack.type != TYPE_TNS:
+            raise ASMRuntimeError("IN requires a tensor as second argument", location=location, rewrite_rule="IN")
+        assert isinstance(haystack.value, Tensor)
+        for item in haystack.value.data.flat:
+            if interpreter._values_equal(needle, item):
+                return Value(TYPE_INT, 1)
+        return Value(TYPE_INT, 0)
+
     def _slice(self, _: "Interpreter", args: List[Value], __: List[Expression], ___: Environment, location: SourceLocation) -> Value:
         target, hi_val, lo_val = args
         hi = self._expect_int(hi_val, "SLICE", location)