koatl 0.3.14__tar.gz → 0.3.16__tar.gz

{koatl-0.3.14 → koatl-0.3.16}/Cargo.lock

@@ -190,7 +190,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "koatl"
-version = "0.3.14"
+version = "0.3.16"
 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.14 → koatl-0.3.16}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: koatl
-Version: 0.3.14
+Version: 0.3.16
 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.14 → koatl-0.3.16}/koatl/Cargo.toml

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

{koatl-0.3.14 → koatl-0.3.16}/koatl/python/koatl/prelude/__init__.tl

@@ -14,14 +14,25 @@ import koatl.std.(
 export std = LazyModule("koatl.std")
 export mod = RootModulesProxy()
 
+# Extensions
+
 Extension.trait(Iterable)
 
+Extension.method(str, "match")! (regex, str) => Pattern(regex).match(str)
+Extension.method(str, "matches")! (str, regex) => Pattern(regex).match(str)
+
 Extension.property(list, "len")! List.len.fget
+Extension.method(list, "map")! (self, f) => self.iter.map(f).list()
+Extension.method(list, "filter")! (self, f) => self.iter.filter(f).list()
 
-Extension.property(object, "result")! self => Result(self)
+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()
 
-Extension.method(str, "match")! (regex, str) => Pattern(regex).match(str)
-Extension.method(str, "matches")! (str, regex) => Pattern(regex).match(str)
+# Implementations for language features
 
 __tl__.do = koatl.std.control.do.do
 

{koatl-0.3.14 → koatl-0.3.16}/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.14 → koatl-0.3.16}/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.14 → koatl-0.3.16}/koatl/python/koatl/std/re.tl

@@ -20,7 +20,7 @@ export Pattern = class:
         if not isinstance(string, str):
             raise TypeError(f"Expected a string, but got {type(string).__name__}")
 
-        self.pattern.match(string, flags).result.map(Match)
+        self.pattern.match(string, flags).(Result).map(Match)
 
 export Match = collections.abc.Sequence.register! class:
     __slots__ = ("_match",)

koatl-0.3.16/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.14/koatl/tests/e2e/prelude → koatl-0.3.16/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.16/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.16/koatl/tests/fail-parse/unmatched_closing_delimiter.tl

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

{koatl-0.3.14 → koatl-0.3.16}/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.16/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})