koatl 0.3.13__tar.gz → 0.3.15__tar.gz

{koatl-0.3.13 → koatl-0.3.15}/Cargo.lock

@@ -190,7 +190,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "koatl"
-version = "0.3.13"
+version = "0.3.15"
 dependencies = [
  "ariadne",
  "koatl-core",
@@ -248,7 +248,7 @@ dependencies = [
 
 [[package]]
 name = "ohtli"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
  "anyhow",
  "clap",

{koatl-0.3.13 → koatl-0.3.15}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: koatl
-Version: 0.3.13
+Version: 0.3.15
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 License-File: LICENSE
+Home-Page: https://koatl.org
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 

{koatl-0.3.13 → koatl-0.3.15}/koatl/Cargo.toml

@@ -1,7 +1,8 @@
 [package]
 name = "koatl"
-version = "0.3.13"
+version = "0.3.15"
 edition = "2021"
+homepage = "https://koatl.org"
 
 [lib]
 name = "koatl"

{koatl-0.3.13 → koatl-0.3.15}/koatl/python/koatl/prelude/__init__.tl

@@ -23,6 +23,16 @@ Extension.property(object, "result")! self => Result(self)
 Extension.method(str, "match")! (regex, str) => Pattern(regex).match(str)
 Extension.method(str, "matches")! (str, regex) => Pattern(regex).match(str)
 
+Extension.method(list, "map")! (self, f) => self.iter.map(f).list()
+Extension.method(list, "filter")! (self, f) => self.iter.filter(f).list()
+
+Extension.method(dict, "map")! (self, f) => self.iter.map(f).dict()
+Extension.method(dict, "map_values")! (self, f) => self.iter.map([k, v] => [k, f(v)]).dict()
+Extension.method(dict, "map_keys")! (self, f) => self.iter.map([k, v] => [f(k), v]).dict()
+Extension.method(dict, "filter")! (self, f) => self.iter.filter(f).dict()
+Extension.method(dict, "filter_keys")! (self, f) => self.iter.filter([k, v] => f(k)).dict()
+Extension.method(dict, "filter_values")! (self, f) => self.iter.filter([k, v] => f(v)).dict()
+
 __tl__.do = koatl.std.control.do.do
 
 __tl__.op_map = koatl.std.control.result.op_map

{koatl-0.3.13 → koatl-0.3.15}/koatl/python/koatl/runtime/record.py

@@ -4,8 +4,6 @@ import functools
 import inspect
 import re
 
-_property = property
-
 __all__ = ["Record"]
 
 
@@ -48,9 +46,50 @@ class Record:
 
         return object.__getattribute__(self, name)
 
-    @_property
+    def map(self, f):
+        newrec = Record()
+        for k, v in self.items():
+            nk, nv = f((k, v))
+            newrec[nk] = nv
+        return newrec
+
+    def map_values(self, f):
+        newrec = Record()
+        for k, v in self.items():
+            newrec[k] = f(v)
+        return newrec
+
+    def map_keys(self, f):
+        newrec = Record()
+        for k, v in self.items():
+            nk = f(k)
+            newrec[nk] = v
+        return newrec
+
+    def filter(self, f):
+        newrec = Record()
+        for k, v in self.items():
+            if f((k, v)):
+                newrec[k] = v
+        return newrec
+
+    def filter_values(self, f):
+        newrec = Record()
+        for k, v in self.items():
+            if f(v):
+                newrec[k] = v
+        return newrec
+
+    def filter_keys(self, f):
+        newrec = Record()
+        for k, v in self.items():
+            if f(k):
+                newrec[k] = v
+        return newrec
+
+    @__builtins__["property"]
     def iter(self):
-        return self.items()
+        return iter(self.items())
 
     # MutableMapping
     def __len__(self):
@@ -130,7 +169,7 @@ class Record:
         c.update(self)
         return c
 
-    @_property
+    @__builtins__["property"]
     def len(self):
         return len(self)
 

koatl-0.3.15/koatl/python/koatl/runtime/vattr.py

@@ -0,0 +1,66 @@
+from functools import partial
+from itertools import count
+from koatl._rs import fast_vget
+
+
+def vget(obj, name, ignore_traits=False):
+    try:
+        return getattr(obj, name)
+    except AttributeError as e:
+        # special case for iter - this could be implemented using types and trait vtbls
+        # but this is simpler and probably faster
+        if name == "iter":
+            if isinstance(obj, slice):
+                start = obj.start if obj.start is not None else 0
+                step = obj.step if obj.step is not None else 1
+                if obj.stop is None:
+                    return iter(count(start, step))
+                else:
+                    return iter(range(start, obj.stop, step))
+
+            try:
+                return iter(obj.items())
+            except AttributeError:
+                pass
+
+            try:
+                return iter(obj)
+            except TypeError:
+                pass
+
+        v = fast_vget(obj, name, ignore_traits)
+        if v is not None:
+            if hasattr(v, "_property"):
+                return v(obj)
+
+            return partial(v, obj)
+
+        e.__traceback__ = None
+        raise
+
+
+def vhas(obj, name, ignore_traits=False):
+    if hasattr(obj, name):
+        return True
+
+    if name == "iter":
+        if isinstance(obj, slice):
+            return True
+
+        try:
+            obj.items()
+            return True
+        except AttributeError:
+            pass
+
+        try:
+            iter(obj)
+            return True
+        except TypeError:
+            pass
+
+    v = fast_vget(obj, name, ignore_traits)
+    if v is not None:
+        return True
+
+    return False

{koatl-0.3.13 → koatl-0.3.15}/koatl/python/koatl/std/iter.tl

@@ -10,7 +10,7 @@ export Iterable = class(Traversable, Trait):
 
     skip = (self, n) =>
         let it = self.iter
-        for _ in..n:
+        for _ in ..n:
             next(it, None)
         it
 
@@ -27,7 +27,7 @@ export Iterable = class(Traversable, Trait):
     take = (self, n) =>
         let impl = () =>
             let it = self.iter
-            for _ in..n:
+            for _ in ..n:
                 try:
                     yield next(it)
                 except StopIteration(value=value) =>
@@ -56,6 +56,8 @@ export Iterable = class(Traversable, Trait):
     product = (self, *others) =>
         itertools.product(self.iter, *others.map($.iter))
 
+    cycle = self => itertools.cycle(self.iter)
+
     zip = (self, *others) =>
         zip(self.iter, *others.map($.iter))
 
@@ -86,7 +88,7 @@ export Iterable = class(Traversable, Trait):
 
     reverse = self => reversed(list(self.iter))
 
-    sorted = (self, key=None, reverse=False) =>
+    sort = (self, key=None, reverse=False) =>
         sorted(self.iter, key=key, reverse=reverse)
 
     copy = self => itertools.tee(self.iter)
@@ -184,7 +186,7 @@ export Iterable = class(Traversable, Trait):
 
         impl()
 
-    join_str = (self, sep="") =>
+    join = (self, sep="") =>
         sep.join(self.map(str))
 
     sum = self =>

{koatl-0.3.13 → koatl-0.3.15}/koatl/src/emit_py.rs

@@ -631,6 +631,12 @@ impl<'src> PyExprExt<'src> for SPyExpr<'src> {
                     PyBinaryOp::FloorDiv => Some("FloorDiv"),
                     PyBinaryOp::Mod => Some("Mod"),
                     PyBinaryOp::Pow => Some("Pow"),
+                    PyBinaryOp::BitAnd => Some("BitAnd"),
+                    PyBinaryOp::BitOr => Some("BitOr"),
+                    PyBinaryOp::BitXor => Some("BitXor"),
+                    PyBinaryOp::MatMult => Some("MatMult"),
+                    PyBinaryOp::LShift => Some("LShift"),
+                    PyBinaryOp::RShift => Some("RShift"),
                     _ => None,
                 };
 

koatl-0.3.15/koatl/tests/conftest.py

@@ -0,0 +1,62 @@
+"""
+Pytest configuration for Koatl tests.
+This allows pytest to discover and execute .tl files as test modules.
+"""
+import pytest
+import koatl
+import sys
+from pathlib import Path
+
+# Add e2e directory to Python path so util module can be imported
+sys.path.insert(0, str(Path(__file__).parent / "e2e"))
+
+
+def pytest_collect_file(parent, file_path):
+    """
+    Custom collector to discover .tl files as test modules.
+    """
+    if file_path.suffix == ".tl" and file_path.name.startswith("test_"):
+        return TlModule.from_parent(parent, path=file_path)
+
+
+class TlModule(pytest.Module):
+    """
+    Custom pytest Module for .tl files.
+    Transpiles the .tl file and collects test functions from it.
+    """
+    
+    def collect(self):
+        """
+        Transpile the .tl file and collect test functions.
+        """
+        with open(self.path, "r") as f:
+            source = f.read()
+        
+        try:
+            # Transpile to Python AST in module mode
+            py_ast = koatl.transpile(source, mode="module")
+            
+            # Create a namespace for the module
+            module_name = self.path.stem
+            module_namespace = {
+                "__name__": module_name,
+                "__file__": str(self.path),
+            }
+            
+            # Compile and execute the Python AST in the namespace
+            # This defines all test_* functions
+            code_obj = compile(py_ast, str(self.path), "exec")
+            exec(code_obj, module_namespace)
+            
+            # Collect test functions from the namespace
+            for name, obj in module_namespace.items():
+                if name.startswith("test_") and callable(obj):
+                    func = pytest.Function.from_parent(
+                        self, 
+                        name=name
+                    )
+                    func.obj = obj
+                    yield func
+        except Exception as e:
+            # If transpilation fails, create an error item
+            raise self.CollectError(f"Error transpiling {self.path}: {e}") from e

{koatl-0.3.13/koatl/tests/e2e/prelude → koatl-0.3.15/koatl/tests/e2e/base}/imports.tl

@@ -11,18 +11,18 @@ import os.*
 
 assert_eq(getcwd, os.getcwd)
 
-import util.module0
+import e2e.test_modules.module0
 
 assert_eq(set(module0.__all__), set(["z"]))
 assert_eq(module0.z, 3)
 
-import util.module1
+import e2e.test_modules.module1
 
 assert_eq(set(module1.__all__), set(["a", "z"]))
 assert_eq(module1.a, 1)
 assert_eq(module1.z, 3)
 
-import util.module2
+import e2e.test_modules.module2
 
 assert_eq(set(module2.__all__), set(["b"]))
 assert_eq(module2.b, 3)

koatl-0.3.15/koatl/tests/e2e/base/imports2.tl

@@ -0,0 +1,15 @@
+import ast
+import koatl
+import util.assert_contains
+
+# Test: import a.b should emit "from a import b"
+parsed = koatl.transpile("import a.b", mode="no_prelude")
+assert_contains(ast.unparse(parsed), "from a import b")
+
+# Test: import a.b.(.) should emit "import a.b as b"
+parsed = koatl.transpile("import a.b.(.)", mode="no_prelude")
+assert_contains(ast.unparse(parsed), "import a.b as b")
+
+# Test: import a.b.c should emit "from a.b import c"
+parsed = koatl.transpile("import a.b.c", mode="no_prelude")
+assert_contains(ast.unparse(parsed), "from a.b import c")

koatl-0.3.15/koatl/tests/fail-parse/unmatched_closing_delimiter.tl

@@ -0,0 +1 @@
+a)

koatl-0.3.15/koatl/tests/parse/operators.tl

@@ -0,0 +1 @@
+1 >> 2 << 3 ^^ 4 // 5 && 6 ** (1 || 2 @@ -3)

{koatl-0.3.13 → koatl-0.3.15}/koatl/tests/test_e2e.py

@@ -4,7 +4,7 @@ import os
 import koatl.cli
 from pathlib import Path
 
-sys.path.append(str(Path(__file__).parent / "e2e"))
+sys.path.append(str(Path(__file__).parent))
 os.chdir(Path(__file__).parent / "e2e")
 
 

koatl-0.3.15/koatl/tests/test_iterable.tl

@@ -0,0 +1,176 @@
+import util.assert_eq
+
+test_sum = () =>
+    assert_eq((..10).sum(), 45)
+    assert_eq([1, 2, 3, 4, 5].sum(), 15)
+    assert_eq([].sum(), 0)
+    assert_eq([1.5, 2.5, 3.0].sum(), 7.0)
+
+test_product = () =>
+    let prod_iter = [1, 2, 3].product([4, 5])
+    assert_eq(list(prod_iter), [(1, 4), (1, 5), (2, 4), (2, 5), (3, 4), (3, 5)])
+
+test_min = () =>
+    assert_eq([3, 1, 4, 1, 5].min(), 1)
+    assert_eq([10, 5, 8].min(), 5)
+    assert_eq([42].min(), 42)
+
+test_max = () =>
+    assert_eq([3, 1, 4, 1, 5].max(), 5)
+    assert_eq([10, 5, 8].max(), 10)
+    assert_eq([42].max(), 42)
+
+test_map = () =>
+    # List.map returns a list directly (not an iterator)
+    assert_eq([1, 2, 3].map($ * 2), [2, 4, 6])
+    assert_eq([1, 2, 3].map($ + 10), [11, 12, 13])
+    assert_eq([].map($ * 2), [])
+    # Range/iterator map still returns an iterator
+    assert_eq((..5).map($ * 2).list(), [0, 2, 4, 6, 8])
+
+test_filter = () =>
+    assert_eq([1, 2, 3, 4, 5].filter($ > 3).list(), [4, 5])
+    assert_eq([1, 2, 3, 4, 5].filter($ %% 2 == 0).list(), [2, 4])
+    assert_eq((..10).filter($ > 5).list(), [6, 7, 8, 9])
+    assert_eq([1, 2, 3].filter($ > 10).list(), [])
+
+test_flat_map = () =>
+    assert_eq([1, 2, 3].flat_map(x => [x, x * 2]).list(), [1, 2, 2, 4, 3, 6])
+    assert_eq([[1, 2], [3, 4]].flat_map(x => x).list(), [1, 2, 3, 4])
+    assert_eq([].flat_map(x => [x, x]).list(), [])
+
+test_find = () =>
+    # find() returns Ok(value) or Err()
+    assert_eq([1, 2, 3, 4, 5].find($ > 3).ok, True)
+    let result = [1, 2, 3, 4, 5].find($ > 10)
+    assert_eq(result.ok, False)
+
+test_any = () =>
+    assert_eq([1, 2, 3].any(x => x > 2), True)
+    assert_eq([1, 2, 3].any(x => x > 10), False)
+    assert_eq([].any(x => x > 0), False)
+    assert_eq([False, False, True].any(x => x), True)
+
+test_all = () =>
+    assert_eq([1, 2, 3].all(x => x > 0), True)
+    assert_eq([1, 2, 3].all(x => x > 2), False)
+    assert_eq([].all(x => x > 0), True)
+    assert_eq([True, True, True].all(x => x), True)
+
+test_count = () =>
+    # count() works on Iterable trait via .iter
+    assert_eq([1, 2, 3, 4, 5].iter.count(x => x > 2), 3)
+    assert_eq([1, 2, 3, 4, 5].iter.count(x => x %% 2 == 0), 2)
+    assert_eq([1, 2, 3].iter.count(x => x > 10), 0)
+
+test_take = () =>
+    assert_eq([1, 2, 3, 4, 5].take(3).list(), [1, 2, 3])
+    assert_eq((..100).take(5).list(), [0, 1, 2, 3, 4])
+    assert_eq([1, 2].take(10).list(), [1, 2])
+    assert_eq([].take(5).list(), [])
+
+test_skip = () =>
+    assert_eq([1, 2, 3, 4, 5].skip(2).list(), [3, 4, 5])
+    assert_eq((..10).skip(5).list(), [5, 6, 7, 8, 9])
+    assert_eq([1, 2].skip(10).list(), [])
+    assert_eq([].skip(5).list(), [])
+
+test_take_while = () =>
+    assert_eq([1, 2, 3, 4, 5].take_while($ < 4).list(), [1, 2, 3])
+    assert_eq([2, 4, 6, 7, 8].take_while($ %% 2 == 0).list(), [2, 4, 6])
+    assert_eq([1, 2, 3].take_while($ > 10).list(), [])
+
+test_skip_while = () =>
+    # Uses skip_while() method
+    assert_eq([1, 2, 3, 4, 5].skip_while($ < 4).list(), [4, 5])
+    assert_eq([2, 4, 6, 7, 8].skip_while($ %% 2 == 0).list(), [7, 8])
+    assert_eq([1, 2, 3].skip_while($ > 10).list(), [1, 2, 3])
+
+test_enumerate = () =>
+    assert_eq((..3).enumerate().list(), [(0, 0), (1, 1), (2, 2)])
+    assert_eq(["a", "b", "c"].enumerate().list(), [(0, "a"), (1, "b"), (2, "c")])
+
+test_zip = () =>
+    assert_eq([1, 2, 3].zip([4, 5, 6]).list(), [(1, 4), (2, 5), (3, 6)])
+    assert_eq([1, 2].zip(["a", "b", "c"]).list(), [(1, "a"), (2, "b")])
+    assert_eq([].zip([1, 2, 3]).list(), [])
+
+test_chain = () =>
+    assert_eq([1, 2].chain([3, 4]).list(), [1, 2, 3, 4])
+    assert_eq([1].chain([]).chain([2, 3]).list(), [1, 2, 3])
+    assert_eq([].chain([]).list(), [])
+
+test_cycle = () =>
+    assert_eq([1, 2, 3].cycle().take(7).list(), [1, 2, 3, 1, 2, 3, 1])
+    assert_eq([5].cycle().take(3).list(), [5, 5, 5])
+
+test_reverse = () =>
+    # reverse() is a method on Iterable trait, accessed via .iter
+    assert_eq(list([1, 2, 3, 4, 5].iter.reverse()), [5, 4, 3, 2, 1])
+    assert_eq(list([1].iter.reverse()), [1])
+    assert_eq(list([].iter.reverse()), [])
+
+test_sort = () =>
+    assert_eq([3, 1, 4, 1, 5].iter.sort().list(), [1, 1, 3, 4, 5])
+    assert_eq(["c", "a", "b"].iter.sort().list(), ["a", "b", "c"])
+    assert_eq([].iter.sort().list(), [])
+
+test_join = () =>
+    assert_eq(["a", "b", "c"].join(", "), "a, b, c")
+    assert_eq([1, 2, 3].map(str).join("-"), "1-2-3")
+    assert_eq(["hello"].join(", "), "hello")
+    assert_eq([].join(", "), "")
+
+test_associate = () =>
+    assert_eq((..3).associate($ * 2), {0: 0, 1: 2, 2: 4})
+    assert_eq(["a", "bb", "ccc"].associate(len), {"a": 1, "bb": 2, "ccc": 3})
+    assert_eq([].associate($ + 1), {})
+
+test_group_by = () =>
+    assert_eq([1, 2, 3, 4, 5].group_by($ %% 2), {0: [2, 4], 1: [1, 3, 5]})
+    assert_eq(["a", "bb", "ccc", "dd"].group_by(len), {1: ["a"], 2: ["bb", "dd"], 3: ["ccc"]})
+    assert_eq([].group_by($ > 0), {})
+
+test_list_conversion = () =>
+    assert_eq((..5).list(), [0, 1, 2, 3, 4])
+    assert_eq([1, 2, 3].map($ * 2).list(), [2, 4, 6])
+
+test_record_conversion = () =>
+    # Dict.map returns a dict directly (not an iterator)
+    assert_eq({1: 2, 3: 4}.map([k, v] => [k * 2, v * 3]), {2: 6, 6: 12})
+    assert_eq([[1, "a"], [2, "b"]].record(), {1: "a", 2: "b"})
+
+test_record_take = () =>
+    assert_eq({0: 2}.take(1).list(), [(0, 2)])
+
+test_for_each = () =>
+    let test_list = []
+    [1, 2, 3].for_each(test_list.append)
+    assert_eq(test_list, [1, 2, 3])
+
+test_fold = () =>
+    assert_eq([1, 2, 3, 4].fold(0, (acc, x) => acc + x), 10)
+    assert_eq([1, 2, 3].fold(1, (acc, x) => acc * x), 6)
+    assert_eq([5, 3, 8, 1].fold(0, (acc, x) => max(acc, x)), 8)
+
+# Record/dict methods - defined in both prelude/__init__.tl (Extension.method for dict)
+# and runtime/record.py (Record class methods)
+test_record_map = () =>
+    # map transforms both keys and values
+    assert_eq({1: 10, 2: 20}.map([k, v] => [k + 1, v + 5]), {2: 15, 3: 25})
+    assert_eq({"a": 1, "b": 2}.map([k, v] => [k.upper(), v * 10]), {"A": 10, "B": 20})
+
+test_record_filter = () =>
+    # filter based on key-value pairs (defined in prelude/__init__.tl for dict)
+    assert_eq({1: 10, 2: 20, 3: 30}.filter([k, v] => v > 15), {2: 20, 3: 30})
+    assert_eq({1: 10, 2: 20, 3: 30}.filter([k, v] => k %% 2 == 1), {1: 10, 3: 30})
+
+test_record_filter_keys = () =>
+    # filter_keys - defined in prelude/__init__.tl for dict and record.py for Record
+    assert_eq({1: 10, 2: 20, 3: 30}.filter_keys($ > 1), {2: 20, 3: 30})
+    assert_eq({"a": 1, "b": 2, "c": 3}.filter_keys($ <> "b"), {"a": 1, "c": 3})
+
+test_record_filter_values = () =>
+    # filter_values - defined in prelude/__init__.tl for dict and record.py for Record
+    assert_eq({1: 10, 2: 20, 3: 30}.filter_values($ >= 20), {2: 20, 3: 30})
+    assert_eq({"a": 5, "b": 10, "c": 25}.filter_values($ %% 10 == 5), {"a": 5, "c": 25})

koatl-0.3.15/koatl/tests/util/__init__.py

@@ -0,0 +1,5 @@
+def assert_eq(received, expected):
+    assert received == expected, f"Expected {expected}, but got {received}"
+
+def assert_contains(haystack, needle):
+    assert needle in haystack, f"Expected to find {needle} in {haystack}"

{koatl-0.3.13 → koatl-0.3.15}/koatl-core/src/py/ast.rs

@@ -128,7 +128,7 @@ impl<'a> IntoIterator for PyBlock<'a> {
 }
 
 impl<'a> PyBlock<'a> {
-    pub fn iter(&self) -> std::slice::Iter<SPyStmt<'a>> {
+    pub fn iter(&self) -> std::slice::Iter<'_, SPyStmt<'a>> {
         self.0.iter()
     }
 }

{koatl-0.3.13 → koatl-0.3.15}/koatl-core/src/transform.rs

@@ -1829,26 +1829,21 @@ impl<'src> SStmtExt<'src> for SStmt<'src> {
                                     tree.leaf.span,
                                 ))
                             } else {
-                                let base_module = trunk_accum[..trunk_accum.len() - 1]
+                                let full_module = trunk_accum
                                     .iter()
                                     .map(|ident| ident.value.0.as_ref())
                                     .collect::<Vec<_>>()
                                     .join(".");
 
-                                let aliases = vec![a.import_alias(
-                                    trunk_accum.last().unwrap().value.escape(),
-                                    alias.as_ref().map(|a| a.value.escape()),
-                                )];
-
-                                if trunk_accum.len() == 1 && level == 0 {
-                                    Ok(PyBlock(vec![a.import(aliases)]))
-                                } else {
-                                    Ok(PyBlock(vec![a.import_from(
-                                        Some(base_module.into()),
-                                        aliases,
-                                        level,
-                                    )]))
-                                }
+                                let last_name = trunk_accum.last().unwrap().value.escape();
+                                let asname = alias
+                                    .as_ref()
+                                    .map(|a| a.value.escape())
+                                    .unwrap_or(last_name);
+
+                                let aliases = vec![a.import_alias(full_module, Some(asname))];
+
+                                Ok(PyBlock(vec![a.import(aliases)]))
                             }
                         }
                         ImportLeaf::Single(name, alias) => {

{koatl-0.3.13 → koatl-0.3.15}/koatl-parser/src/lexer.rs

@@ -424,7 +424,7 @@ impl<'src> TokenizeCtx<'src> {
     fn parse_symbol(&mut self) -> TResult<'src, (Token<'src>, Span)> {
         const POLYGRAMS: &[&str] = &[
             "+=", "-=", "*=", "/=", "|=", "??=", "===", "<=>", "=>", "..", "==", "<>", "<=", ">=",
-            "//", "%%", "@@", "**", "??", ".=", "::", "||", "&&", "^^", ">>", "<<",
+            "!=", "!==", "//", "%%", "@@", "**", "??", ".=", "::", "||", "&&", "^^", ">>", "<<",
         ];
         const MONOGRAMS: &str = "[](){}<>.,;:!?@$%^&*+-=|\\/`~";
 
@@ -1574,7 +1574,16 @@ impl<'src> TokenizeCtx<'src> {
 
         let mut tokens = TokenList(vec![]);
 
-        let (block_tokens, _, _) = self.parse_block(0, ParseBlockMode::BeginInput)?;
+        let (block_tokens, end_type, _) = self.parse_block(0, ParseBlockMode::BeginInput)?;
+
+        // Check if we ended due to an unmatched closing delimiter at the top level
+        if end_type == ParseBlockEndType::Delimiter {
+            return Err(LexError::custom(
+                self.span_since(&self.cursor()),
+                "unmatched closing delimiter",
+            ));
+        }
+
         tokens.0.extend(block_tokens.0);
 
         Ok(tokens)
@@ -1652,7 +1661,7 @@ mod tests {
         );
     }
 
-    fn simple_tokenize(source: &str) -> TokenList {
+    fn simple_tokenize(source: &str) -> TokenList<'_> {
         let (tokens, errors) = tokenize(source, true);
         if !errors.is_empty() {
             assert!(false, "Errors during tokenization: {:?}", errors);
@@ -1662,7 +1671,7 @@ mod tests {
         tokens.unwrap()
     }
 
-    fn simple_trivium(typ: TrivialTokenType, value: &str) -> TrivialToken {
+    fn simple_trivium(typ: TrivialTokenType, value: &'_ str) -> TrivialToken<'_> {
         TrivialToken {
             span: Span { start: 0, end: 0 },
             typ,
@@ -1674,15 +1683,15 @@ mod tests {
         simple_trivium(TrivialTokenType::Newline, "\n")
     }
 
-    fn whitespace_trivium(value: &str) -> TrivialToken {
+    fn whitespace_trivium(value: &str) -> TrivialToken<'_> {
         simple_trivium(TrivialTokenType::Whitespace, value)
     }
 
-    fn comment_trivium(value: &str) -> TrivialToken {
+    fn comment_trivium(value: &str) -> TrivialToken<'_> {
         simple_trivium(TrivialTokenType::LineComment, value)
     }
 
-    fn block_comment_trivium(value: &str) -> TrivialToken {
+    fn block_comment_trivium(value: &'_ str) -> TrivialToken<'_> {
         simple_trivium(TrivialTokenType::BlockComment, value)
     }