koatl 0.1.41__tar.gz → 0.2.2__tar.gz

{koatl-0.1.41 → koatl-0.2.2}/Cargo.lock

@@ -99,7 +99,7 @@ checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
 
 [[package]]
 name = "koatl"
-version = "0.1.41"
+version = "0.2.2"
 dependencies = [
  "ariadne",
  "koatl-core",
@@ -112,11 +112,18 @@ name = "koatl-core"
 version = "0.1.0"
 dependencies = [
  "ariadne",
+ "koatl-parser",
  "once_cell",
- "parser",
  "slotmap",
 ]
 
+[[package]]
+name = "koatl-parser"
+version = "0.1.0"
+dependencies = [
+ "chumsky",
+]
+
 [[package]]
 name = "libc"
 version = "0.2.174"
@@ -144,13 +151,6 @@ version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
-[[package]]
-name = "parser"
-version = "0.1.0"
-dependencies = [
- "chumsky",
-]
-
 [[package]]
 name = "portable-atomic"
 version = "1.11.1"

koatl-0.2.2/Cargo.toml

@@ -0,0 +1,3 @@
+[workspace]
+members = ["koatl-parser", "koatl-core", "koatl"]
+resolver = "3"

{koatl-0.1.41 → koatl-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koatl
-Version: 0.1.41
+Version: 0.2.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{koatl-0.1.41 → koatl-0.2.2}/koatl/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "koatl"
-version = "0.1.41"
+version = "0.2.2"
 edition = "2021"
 
 [lib]

{koatl-0.1.41 → koatl-0.2.2/koatl}/python/koatl/cli.py

@@ -9,9 +9,23 @@ def transpile_from_source(source, mode="script", script_path="<string>"):
 
 def run_from_source(source, mode="script", script_path="<string>"):
     from koatl import transpile
+    import ast
 
     transpiled_code = transpile(source, mode=mode, filename=str(script_path))
-    code_obj = compile(transpiled_code, script_path, "exec")
+
+    try:
+        code_obj = compile(transpiled_code, script_path, "exec")
+    except Exception as e:
+
+        class Visitor(ast.NodeVisitor):
+            def generic_visit(self, node):
+                if hasattr(node, "lineno"):
+                    if node.lineno > node.end_lineno:
+                        print(f"Error: {node.lineno} > {node.end_lineno} for {node}")
+                super().generic_visit(node)
+
+        Visitor().visit(transpiled_code)
+        raise
 
     script_globals = {"__name__": "__main__"}
 

{koatl-0.1.41 → koatl-0.2.2/koatl}/python/koatl/runtime/__init__.py

@@ -3,7 +3,8 @@ import importlib
 from types import SimpleNamespace
 
 from koatl.runtime.record import Record
-from . import meta_finder, vattr
+from . import meta_finder
+from .vattr import vhas, vget
 
 meta_finder.install_hook()
 
@@ -42,6 +43,6 @@ __tl__ = SimpleNamespace(
     #
     set_exports=set_exports,
     #
-    vget=vattr.vget,
-    vhas=vattr.vhas,
+    vget=vget,
+    vhas=vhas,
 )

{koatl-0.1.41 → koatl-0.2.2}/koatl/python/koatl/runtime/meta_finder.py

@@ -52,7 +52,7 @@ class TlLoader(Loader):
             self.filepath,
         )
 
-        if module.__name__.startswith("koatl.prelude"):
+        if module.__name__.startswith("koatl"):
             transpiled_code = transpile(
                 source_code, mode="no_prelude", filename=self.filepath
             )

{koatl-0.1.41 → koatl-0.2.2/koatl}/python/koatl/std/alg/async.tl

@@ -31,7 +31,7 @@ export Async = class(MonadOnce):
                 self = gen.send(yield from self.__await__())
                 if not hasattr(self, "__await__"):
                     raise ValueError(f"Expected the binder to return an Awaitable, but got {type(self).__name__}")
-        except StopIteration(value=value):
+        except StopIteration(value=value) =>
             return value
 
     pure = staticmethod& x => Async.from_generator_fn& () =>

{koatl-0.1.41 → koatl-0.2.2/koatl}/python/koatl/std/alg/do.tl

@@ -7,10 +7,10 @@ export do = f => wraps(f)& (*args, **kwargs) =>
     let m
     try:
         m = gen.send(None)
-    except StopIteration() as e:
+    except StopIteration() as e =>
         raise ValueError(
             "Returning before `@` is not allowed. "
-                "Use `return @MonadType.pure(value)` instead."
+                + "Use `return @MonadType.pure(value)` instead."
         )
 
     try:
@@ -18,17 +18,17 @@ export do = f => wraps(f)& (*args, **kwargs) =>
         # is it possible to derive bind_gen directly from bind_once?
 
         return m.bind_gen(gen)
-    except AttributeError():
+    except AttributeError() =>
         None
 
     let recurse = v =>
         try:
             m = gen.send(v)
             return m.bind_once(recurse)
-        except StopIteration() as e:
+        except StopIteration() as e =>
             return m.pure(e.value)
 
     try:
         return m.bind_once(recurse)
-    except AttributeError():
+    except AttributeError() =>
         raise ValueError("@ can only be used with an object that has `bind_once`.")

{koatl-0.1.41 → koatl-0.2.2}/koatl/python/koatl/std/alg/env.tl

@@ -26,7 +26,7 @@ export Env = class(MonadOnce):
 
     bind_once = (self, f) => Env& ctx =>
         let v = f(self.f(ctx))
-        if v matches not Env():
+        if v not matches Env():
             raise ValueError(f"Expected the binder to return an Env, but got {type(v)}")
 
         v.f(ctx)
@@ -35,9 +35,9 @@ export Env = class(MonadOnce):
         try:
             while True:
                 self = gen.send(self.f(ctx))
-                if self matches not Env():
+                if self not matches Env():
                     raise ValueError(f"Expected the binder to return an Env, but got {type(self)}")
-        except StopIteration(value=value):
+        except StopIteration(value=value) =>
             return value
 
     NoKey = object()

{koatl-0.1.41 → koatl-0.2.2/koatl}/python/koatl/std/alg/memo.tl

@@ -24,7 +24,7 @@ export Memo = class(MonadOnce):
 
         __repr__ = self => f"Memo.Cache({self.cache})"
 
-        try_get = (self, name, deps) => try self.cache[name][deps] except KeyError()
+        try_get = (self, name, deps) => check self.cache[name][deps] except KeyError()
 
         update = (self, name, deps, value) =>
             self.cache[name][deps] = value
@@ -88,7 +88,7 @@ export Memo = class(MonadOnce):
     bind_once = (self, f) => Memo(ctx =>
         let value = f(self.f(ctx))
 
-        if value matches not Memo():
+        if value not matches Memo():
             raise ValueError(f"Expected the binder to return a Memo, but got {type(value)}")
 
         return value.f(ctx)
@@ -100,10 +100,9 @@ export Memo = class(MonadOnce):
                 let inner = self.f(ctx)
                 self = gen.send(inner)
 
-                if self matches not Memo():
+                if self not matches Memo():
                     raise ValueError(f"Expected the binder to return a Memo, but got {type(value)}")
-
-        except StopIteration(value=value):
+        except StopIteration(value=value) =>
             return value
     )
 
@@ -164,7 +163,7 @@ export AsyncMemo = class(MonadOnce):
     bind_once = (self, f) => AsyncMemo(ctx =>
         let value = f(@self.f(ctx))
 
-        if value matches not AsyncMemo():
+        if value not matches AsyncMemo():
             raise ValueError(f"Expected the binder to return a Memo, but got {type(value)}")
 
         return value.f(ctx)
@@ -176,9 +175,9 @@ export AsyncMemo = class(MonadOnce):
                 let inner = @self.f(ctx)
                 self = gen.send(inner)
 
-                if self matches not AsyncMemo():
+                if self not matches AsyncMemo():
                     raise ValueError(f"Expected the binder to return a Memo, but got {type(value)}")
 
-        except StopIteration(value=value):
+        except StopIteration(value=value) =>
             return value
     )

{koatl-0.1.41 → koatl-0.2.2}/koatl/python/koatl/std/alg/result.tl

@@ -5,7 +5,7 @@ infer_ok = x =>
     x match:
         None => False
         BaseException() => False
-        default True
+        _ => True
 
 op_coal = (x, f) =>
     if x matches Result():
@@ -42,7 +42,7 @@ export Result = class(MonadOnce):
         """
         try:
             return Ok(f())
-        except BaseException() as e:
+        except BaseException() as e =>
             return Err(e)
 
     bind_once = (self, f) =>
@@ -50,7 +50,7 @@ export Result = class(MonadOnce):
             return self
 
         let value = f(self.value)
-        if value matches not Result():
+        if value not matches Result():
             raise ValueError(f"Expected the binder to return a Result, but got {type(value)}")
         value
 
@@ -61,9 +61,9 @@ export Result = class(MonadOnce):
                     return self
 
                 self = gen.send(self.value)
-                if self matches not Result():
+                if self not matches Result():
                     raise ValueError(f"Expected the binder to return a Result, but got {type(self)}")
-        except StopIteration(value=value):
+        except StopIteration(value=value) =>
             return Result(value)
 
     pure = staticmethod& x => Ok(x)

{koatl-0.1.41 → koatl-0.2.2}/koatl/python/koatl/std/data/list.tl

@@ -5,14 +5,14 @@ import koatl.std.alg.Monad
 export List = class(Monad):
     __new__ = (cls, *args, **kwargs) => raise ValueError(
         "List cannot be instantiated directly. "
-            "Use [] or list()."
+            + "Use [] or list()."
     )
 
     bind_once = (self, f) =>
         raise NotImplementedError(
             "List may not be bound using @ "
-                "due to generator limitations. "
-                "Wrap in Ok to use the Result monad."
+                + "due to generator limitations. "
+                + "Wrap in Ok to use the Result monad."
         )
 
     bind = (self, f) => List(self.flat_map(f))

koatl-0.2.2/koatl/python/koatl/std/io.tl

@@ -0,0 +1,7 @@
+export read_file = (filename, binary=False) =>
+    with desc = open(filename, binary then "rb" else "r"):
+        desc.read()
+
+export write_file = (filename, content, binary=False) =>
+    with desc = open(filename, binary then "wb" else "w"):
+        desc.write(content)

{koatl-0.1.41 → koatl-0.2.2}/koatl/python/koatl/std/iter.tl

@@ -1,6 +1,7 @@
 import itertools
 import builtins
 
+import koatl.std.data.Record
 import koatl.std.trait.Trait
 import .alg.(Traversable, Ok, Err, Memo, Async, AsyncMemo, Result)
 
@@ -20,7 +21,7 @@ export Iterable = class(Traversable, Trait):
                 let value = next(it)
                 if not f(value):
                     return Iterable.chain([value], it)
-            except StopIteration():
+            except StopIteration() =>
                 return it
 
     take = (self, n) =>
@@ -29,7 +30,7 @@ export Iterable = class(Traversable, Trait):
             for _ in ..n:
                 try:
                     yield next(it)
-                except StopIteration(value=value):
+                except StopIteration(value=value) =>
                     return value
 
         impl.__name__ = f"take"
@@ -52,6 +53,9 @@ export Iterable = class(Traversable, Trait):
     chain = (self, *others) =>
         itertools.chain(self.iter, *others.map($.iter))
 
+    product = (self, *others) =>
+        itertools.product(self.iter, *others.map($.iter))
+
     zip = (self, *others) =>
         zip(self.iter, *others.map($.iter))
 
@@ -148,7 +152,7 @@ export Iterable = class(Traversable, Trait):
         return Err()
 
     first = self =>
-        (try next(self.iter)).map_err(_ => None)
+        (check next(self.iter)).map_err(_ => None)
 
     last = (self, f) =>
         let result = Err()
@@ -208,7 +212,7 @@ export Iterable = class(Traversable, Trait):
                 m = v
             else:
                 m = key(v)
-        except StopIteration(value=value):
+        except StopIteration(value=value) =>
             raise ValueError("max of empty iterable")
 
 
@@ -235,7 +239,7 @@ export Iterable = class(Traversable, Trait):
                 m = v
             else:
                 m = key(v)
-        except StopIteration(value=value):
+        except StopIteration(value=value) =>
             raise ValueError("min of empty iterable")
 
         if key === None:
@@ -268,7 +272,7 @@ export Iterable = class(Traversable, Trait):
         let v
         try:
             v = next(it)
-        except StopIteration():
+        except StopIteration() =>
             return []
 
         let m = f(v)

koatl-0.2.2/koatl/python/koatl/std/json.tl

@@ -0,0 +1,34 @@
+import json
+import koatl.std.io
+import koatl.std.data.Record
+
+export JSONEncoder = class(json.JSONEncoder):
+    default = (self, o) =>
+        o match:
+            Record() => o.__dict__
+            default => super().default(o)
+
+export JSONDecoder = class(json.JSONDecoder):
+    __init__ = (self, **kwargs) =>
+        let object_hook = d =>
+            d match:
+                dict() => Record(d)
+                default => d
+
+        super().__init__(object_hook=object_hook, **kwargs)
+
+export parse = json_str => JSONDecoder().decode(json_str)
+
+export stringify = (obj, **kwargs) => JSONEncoder(**kwargs).encode(obj)
+
+export pretty = obj => stringify(obj, indent=2)
+
+export compact = obj => stringify(obj, separators=(",", ":"))
+
+export read_file = filename =>
+    let s = io.read_file(filename)
+    parse(s)
+
+export write_file = (filename, obj, indent=2, sort_keys=True) =>
+    let s = stringify(obj, indent=indent, sort_keys=sort_keys)
+    io.write_file(filename, s)

{koatl-0.1.41 → koatl-0.2.2}/koatl/python/koatl/std/lazy_module.tl

@@ -25,7 +25,7 @@ export LazyModule = class:
 
             if hasattr(self._module, attr):
                 return getattr(self._module, attr)
-        except e:
+        except e =>
             raise ValueError(str(e))
 
         raise AttributeError(f"Module '{self._name}' has no attribute '{attr}'")

koatl-0.2.2/koatl/python/koatl/std/pickle.tl

@@ -0,0 +1,10 @@
+import pickle
+import koatl.std.io
+
+export write_file = (filename, obj, protocol=None) =>
+    with f = open(filename, "wb"):
+        pickle.dump(obj, f, protocol=protocol ?? pickle.DEFAULT_PROTOCOL)
+
+export load_file = filename =>
+    with f = open(filename, "rb"):
+        pickle.load(f)

{koatl-0.1.41 → koatl-0.2.2}/koatl/python/koatl/std/trait.py

@@ -2,7 +2,7 @@ import abc
 import collections
 import inspect
 
-from koatl.prelude import __tl__
+from koatl.runtime import vhas
 
 
 @collections.abc.Mapping.register
@@ -90,7 +90,7 @@ class TraitMeta(MappingMeta):
         # Check if the exact class has _trait_reqs, in which case it's a trait.
         if "_trait_reqs" in cls.__dict__:
             for req in cls._trait_reqs:
-                if not __tl__.vhas(instance, req):
+                if not vhas(instance, req):
                     return False
 
             return True

{koatl-0.1.41 → koatl-0.2.2}/koatl/src/emit_py.rs

@@ -1,4 +1,4 @@
-use koatl_core::{parser::ast::*, py::ast::*, util::LineColCache};
+use koatl_core::{py::ast::*, util::LineColCache, Span};
 
 use pyo3::{
     call::PyCallArgs,

{koatl-0.1.41 → koatl-0.2.2}/koatl/tests/e2e/base/match.tl

@@ -1,28 +1,36 @@
 import util.assert_eq
 
 # parsing test
-1 match 1 if False => 2 default 3
+1 match:
+    1 if False => 2
+    _ => 3
 
 assert_eq(
-    1 match 1 if False => 2 default 3,
+    1 match:
+        1 if False => 2
+        _ => 3
     3
 )
 
 assert_eq(
-    1 match 1 if False => 2 else _ => 3,
+    1 match:
+        1 if False => 2
+        _ => 3
     3
 )
 
 x = 1
 assert_eq(
-    1 match .x => 2 default 3,
+    1 match:
+        .x => 2
+        _ => 3
     2
 )
 
 assert_eq(
     1 match:
         .x => 2
-        default 3
+        _ => 3
     2
 )
 
@@ -34,7 +42,7 @@ assert_eq(
 )
 
 assert_eq(
-    match 1:
+    1 match:
         .x => 2
         _ => 3
     2
@@ -42,29 +50,36 @@ assert_eq(
 
 x = 1
 assert_eq(
-    2 match .x => 2 default 3
+    2 match:
+        .x => 2
+        _ => 3
     3
 )
 
 assert_eq(
-    2 match x => 2
+    2 match:
+        x => 2
     2
 )
 
 assert_eq(
-    [1, 2, 3] match [3, *x] => x default 123
+    [1, 2, 3] match:
+        [3, *x] => x
+        _ => 123
     123
 )
 
 assert_eq(
-    [1, 2, 3] match [1, *x] => x default 123
+    [1, 2, 3] match:
+        [1, *x] => x
+        _ => 123
     [2, 3] | list
 )
 
 assert_eq(
     [1, 2, 3] match:
         [1, *x] => x
-        default:
+        _ =>
             123
     [2, 3] | list
 )
@@ -79,7 +94,7 @@ f = () =>
     else:
         raise
 
-    if [1, 2, 3] matches not [1, 2, x]:
+    if [1, 2, 3] not matches [1, 2, x]:
         raise
     else:
         assert_eq(x, 3)

koatl-0.2.2/koatl/tests/e2e/prelude/try.tl

@@ -0,0 +1,28 @@
+import util.assert_eq
+
+# precedence
+assert_eq(check 1 ?? 2, 1)
+assert_eq(check z ?? 2, 2)
+assert_eq(check z matches Err(NameError()), True)
+assert_eq(check z ?? check 1 ?? 2, 1)
+assert_eq(check z ?? check None ?? 2, None)
+assert_eq(check z ?? Err(None) ?? 2, 2)
+
+err_type = NameError
+assert_eq(check a except err_type() matches Err(), True)
+
+# handlers
+assert_eq(check 1 except ValueError() ?? 2, 1)
+assert_eq(check a except NameError() ?? 2, 2)
+assert_eq(check a except (ValueError() | NameError()) ?? 2, 2)
+
+try:
+    check a except (ValueError() | StopIteration())
+    raise
+except _ =>
+    None
+
+assert_eq(check 1 matches Ok(1), True)
+
+assert_eq((check 5)?.($+1), Ok(6))
+assert_eq((check x)?.($+1) matches Err(), True)

{koatl-0.1.41 → koatl-0.2.2}/koatl/tests/e2e/prelude/virtual.tl

@@ -28,5 +28,5 @@ assert_eq(None.some_global_prop, ())
 assert_eq({required_method: Record.method& self => 42}.derived_method(), 42)
 assert_eq({required_method: Record.method& self => 42}.derived_property, 42)
 
-assert_eq((try "asdf".derived_method).ok, False)
-assert_eq((try "asdf".derived_prop).ok, False)
+assert_eq((check "asdf".derived_method).ok, False)
+assert_eq((check "asdf".derived_prop).ok, False)

koatl-0.2.2/koatl/tests/parse/matches.tl

@@ -0,0 +1,2 @@
+1 matches 1
+1 not matches 1

{koatl-0.1.41 → koatl-0.2.2}/koatl-core/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 ariadne = "0.5.1"
-parser = { path = "parser" }
+koatl-parser = { path = "../koatl-parser" }
 once_cell = "1.19.0"
 slotmap = "1.0.7"