koatl 0.1.14__tar.gz → 0.1.16__tar.gz

{koatl-0.1.14 → koatl-0.1.16}/Cargo.lock

@@ -99,7 +99,7 @@ checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
 
 [[package]]
 name = "koatl"
-version = "0.1.14"
+version = "0.1.16"
 dependencies = [
  "ariadne",
  "koatl-core",
@@ -112,6 +112,7 @@ name = "koatl-core"
 version = "0.1.0"
 dependencies = [
  "ariadne",
+ "once_cell",
  "parser",
 ]
 

{koatl-0.1.14 → koatl-0.1.16}/PKG-INFO

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

{koatl-0.1.14 → koatl-0.1.16}/koatl/Cargo.toml

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

{koatl-0.1.14 → koatl-0.1.16}/koatl/python/koatl/notebook/__init__.py

@@ -21,14 +21,23 @@ def source_code_transformer(lines):
     return lines
 
 
-def import_prelude(namespace):
-    exec("from koatl.runtime import *", namespace)
-    exec("from koatl.prelude import *", namespace)
+def try_import_prelude(namespace):
+    try:
+        exec("from koatl.runtime import *", namespace)
+        exec("from koatl.prelude import *", namespace)
+    except Exception as e:
+        import traceback
+
+        print(
+            "There was an error importing the Koatl prelude. Some features may not work."
+        )
+        traceback.print_exc()
 
 
 def load_ipython_extension(ipython):
-    import_prelude(ipython.user_ns)
-    print("koatl enabled")
+    print("Switched notebook to Koatl.")
+
+    try_import_prelude(ipython.user_ns)
 
     ttm = ipython.input_transformer_manager
 

{koatl-0.1.14 → koatl-0.1.16/koatl}/python/koatl/prelude/functional/__init__.tl

@@ -9,8 +9,8 @@ export Fn = class:
             [] => raise ValueError("At least one function is required for composition")
             [f] => f
             [*fs] =>
-                composed = (*args, **kwargs) =>
-                    value = fs[-1](*args, **kwargs)
+                let composed = (*args, **kwargs) =>
+                    let value = fs[-1](*args, **kwargs)
                     for f in fs[..-1..-1]:
                         value = f(value)
                     value

{koatl-0.1.14 → koatl-0.1.16/koatl}/python/koatl/prelude/functional/async.tl

@@ -1,8 +1,10 @@
 import functools.wraps
 import asyncio
+
 import .async_util
+import .monad.Monad
 
-export Async = class:
+export Async = class(Monad):
     __init__ = (self, awaitable) => self.generator = awaitable.__await__()
 
     __await__ = self => self.generator
@@ -10,14 +12,14 @@ export Async = class:
     __repr__ = self => "Async(...)"
 
     from_generator_fn = staticmethod& (generator_fn, *args, **kwargs) =>
-        m = object.__new__(Async)
+        let m = object.__new__(Async)
         m.generator = generator_fn(*args, **kwargs)
         return m
 
     run = self => asyncio.run(async_util.to_coro(self))
 
     bind_once = (self, f) => Async.from_generator_fn& () =>
-        result = f(yield from self.__await__())
+        let result = f(yield from self.__await__())
 
         if hasattr(result, "__await__"):
             return yield from result.__await__()
@@ -25,7 +27,6 @@ export Async = class:
         return result
 
     bind_gen = (self, gen) => Async.from_generator_fn& () =>
-        nonlocal self = self
         try:
             while True:
                 self = gen.send(yield from self.__await__())

{koatl-0.1.14 → koatl-0.1.16}/koatl/python/koatl/prelude/functional/reader.tl

@@ -1,6 +1,7 @@
 import functools.wraps
+import .monad.Monad
 
-export Reader = class:
+export Reader = class(Monad):
     __init__ = (self, fn) => self.fn = fn
 
     __repr__ = self => "Reader(...)"
@@ -8,16 +9,13 @@ export Reader = class:
     run = (self, ctx) => self.fn(ctx)
 
     bind_once = (self, f) => Reader& ctx =>
-        v = f(self.fn(ctx))
+        let v = f(self.fn(ctx))
         if v matches Reader():
             v.fn(ctx)
         else:
             v
 
-    # TODO: this is a workaround to avoid recursion.
-    # how to get bind_gen directly from bind_once?
     bind_gen = (self, gen) => Reader& ctx =>
-        nonlocal self = self
         try:
             while True:
                 self = gen.send(self.fn(ctx))

{koatl-0.1.14 → koatl-0.1.16}/koatl/python/koatl/prelude/iterable.tl

@@ -13,7 +13,7 @@ methods = {
             yield from f(i)
 
     fold: (x, init, f) =>
-        acc = init
+        let acc = init
         for i in x:
             acc = f(acc, i)
         acc
@@ -25,7 +25,7 @@ methods = {
         return None
 
     last: (x, f) =>
-        result = None
+        let result = None
         for i in x:
             if f(i):
                 result = i
@@ -38,7 +38,7 @@ methods = {
         raise IndexError("Index out of range")
 
     sum: x =>
-        acc = 0
+        let acc = 0
         for i in x:
             acc = acc + i
         acc

{koatl-0.1.14 → koatl-0.1.16}/koatl/python/koatl/runtime/__init__.py

@@ -22,6 +22,7 @@ from .helpers import *
 
 
 __tl__ = SimpleNamespace(
+    slice=slice,
     vget=virtual.vget,
     vhas=virtual.vhas,
     unpack_record=helpers.unpack_record,

{koatl-0.1.14 → koatl-0.1.16/koatl}/python/koatl/runtime/helpers.py

@@ -75,7 +75,9 @@ def do(f):
                     return e.value
 
         try:
-            print(m, gen)
+            # TODO: this is a workaround to avoid recursion.
+            # is it possible to get bind_gen directly from bind_once?
+
             return vget(m, "bind_gen")(gen)
         except (NotImplementedError, AttributeError):
             return vget(m, "bind_once")(recurse)

{koatl-0.1.14 → koatl-0.1.16}/koatl/python/koatl/runtime/meta_finder.py

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

{koatl-0.1.14 → koatl-0.1.16}/koatl/src/emit_py.rs

@@ -333,18 +333,31 @@ impl<'src> PyStmtExt<'src> for SPyStmt<'src> {
                     &self.tl_span,
                 )
             }
-            PyStmt::FnDef(name, args, body, decorators) => {
-                let arguments = args.emit_py(ctx)?;
-                let body_ast = body.emit_py(ctx)?;
-                let decorators = decorators.emit_py(ctx)?;
-
-                ctx.ast_node(
-                    "FunctionDef",
-                    (name.as_ref(), arguments, body_ast, decorators),
-                    &self.tl_span,
-                )
+            PyStmt::FnDef(fndef) => {
+                let arguments = fndef.args.emit_py(ctx)?;
+                let body_ast = fndef.body.emit_py(ctx)?;
+                let decorators = fndef.decorators.emit_py(ctx)?;
+
+                if fndef.async_ {
+                    ctx.ast_node(
+                        "AsyncFunctionDef",
+                        (fndef.name.as_ref(), arguments, body_ast, decorators),
+                        &self.tl_span,
+                    )
+                } else {
+                    ctx.ast_node(
+                        "FunctionDef",
+                        (fndef.name.as_ref(), arguments, body_ast, decorators),
+                        &self.tl_span,
+                    )
+                }
             }
-            PyStmt::ClassDef(name, bases, body, decorators) => {
+            PyStmt::ClassDef(PyClassDef {
+                name,
+                bases,
+                body,
+                decorators,
+            }) => {
                 let mut bases_ast = Vec::new();
                 let mut keywords_ast = Vec::new();
 

{koatl-0.1.14 → koatl-0.1.16}/koatl/src/lib.rs

@@ -14,7 +14,7 @@ use pyo3::{
 fn get_option(mode: &str) -> PyResult<TranspileOptions> {
     Ok(match mode {
         "module" => TranspileOptions::module(),
-        "prelude" => TranspileOptions::prelude(),
+        "no_prelude" => TranspileOptions::no_prelude(),
         "interactive" => TranspileOptions::interactive(),
         "script" => TranspileOptions::script(),
         _ => {

{koatl-0.1.14 → koatl-0.1.16}/koatl/tests/e2e/base/coal.tl

@@ -1,9 +1,10 @@
 import util.assert_eq
 
-assert_eq(None?(1)?(2), None)
-assert_eq(None?[1]?.a, None)
-assert_eq(None?.a, None)
-assert_eq(None?.(a), None)
+none = None
+assert_eq(none?(1)?(2), None)
+assert_eq(none?[1]?.a, None)
+assert_eq(none?.a, None)
+assert_eq(none?.(a), None)
 
 obj = (class:
     a = 1

{koatl-0.1.14 → koatl-0.1.16}/koatl/tests/e2e/base/fstr.tl

@@ -11,9 +11,9 @@ fstr = f"x = {(y => y)(x)}"
 assert_eq(fstr, "x = 1")
 
 fstr = f"={
-    a = 1
-    b = 2
-    c = 3
+    let a = 1
+    let b = 2
+    let c = 3
     a * b * c
 }="
 assert_eq(fstr, "=6=")

{koatl-0.1.14 → koatl-0.1.16}/koatl/tests/e2e/base/if_expr.tl

@@ -10,7 +10,7 @@ assert_eq(a, 1)
 a = if False:
     2 * 4
 else:
-    x = 4 * 8
+    let x = 4 * 8
     x * 2
 
 assert_eq(a, 4 * 8 * 2)

{koatl-0.1.14 → koatl-0.1.16}/koatl/tests/e2e/base/match.tl

@@ -71,6 +71,6 @@ assert_eq(
 
 x = 1
 assert_eq([1, 2, 3] matches [1, 2, 3], True)
-assert_eq([1, 2, 3] matches [.x, y, 3], True)
+assert_eq([1, 2, 3] matches [.x, _, 3], True)
 
 assert_eq(try 1 matches 1, True)

koatl-0.1.16/koatl/tests/e2e/base/scopes.tl

@@ -0,0 +1,92 @@
+import util.assert_eq
+
+#-
+Note: many of the tests in this file are inside temporary functions;
+this is because the global scope is special in Python.
+-#
+
+
+
+# Scope variables shouldn't escape
+
+test = 1
+if True:
+    test = 2
+    assert_eq(test, 2)
+    let test = 3
+    assert_eq(test, 3)
+    test = 4
+    assert_eq(test, 4)
+assert_eq(test, 2)
+
+# Nested scopes should identify captures properly
+
+test = 1
+f = () =>
+    test = 2
+    let g = () =>
+        test = 3
+    g()
+    assert_eq(test, 3)
+f()
+assert_eq(test, 3)
+
+# ...but should also not leak variables
+
+test = 1
+f = () =>
+    test = 2
+    let g = () =>
+        let test = 3
+    g()
+    assert_eq(test, 2)
+f()
+assert_eq(test, 2)
+
+# Arguments should shadow all other variables
+
+test = 0
+f = test =>
+    test = 1
+    assert_eq(test, 1)
+f(1)
+assert_eq(test, 0)
+
+# Assignment lhs should be lifted into function body scope
+
+f = () =>
+    let g = 1
+    let g = () => g = 2
+    g()
+    assert_eq(g, 2)
+f()
+
+# Recursion should work
+
+a = () =>
+    let fib = n => n < 2 then 1 else fib(n - 1) + fib(n - 2)
+    assert_eq(fib(5), 8)
+a()
+
+# Classes should work
+
+f = () =>
+    let A = class:
+        B = 2
+
+        f = (self, x=B) =>
+            x
+
+    assert_eq(A.B, 2)
+    assert_eq(A().f(), 2)
+f()
+
+f = () =>
+    let A = class:
+        f = self =>
+            # this should now resolve to the class itself
+            A = 2
+
+    A().f()
+    assert_eq(A, 2)
+f()

{koatl-0.1.14 → koatl-0.1.16}/koatl/tests/e2e/base/semantic_whitespace.tl

@@ -64,7 +64,7 @@ assert_eq([
 apply = (x, y) => x(y)
 assert_eq(apply(
     x =>
-        y = x * 2
+        let y = x * 2
         y * 2
     8
 ), 8 * 2 * 2)
@@ -72,7 +72,7 @@ assert_eq(apply(
 assert_eq(
     apply(
         x =>
-            y = x * 2
+            let y = x * 2
             y * 2
         8
     )

{koatl-0.1.14 → koatl-0.1.16}/koatl/tests/test_e2e.py

@@ -6,10 +6,9 @@ from pathlib import Path
 sys.path.append(str(Path(__file__).parent / "e2e"))
 
 
-def get_test_data():
+def get_test_data(dirs):
     data_dirs = [
-        Path(__file__).parent / "e2e" / "base",
-        Path(__file__).parent / "e2e" / "prelude",
+        Path(__file__).parent / "e2e" / dirs,
     ]
 
     test_cases = []
@@ -20,13 +19,32 @@ def get_test_data():
     return test_cases
 
 
-@pytest.mark.parametrize("test_file", get_test_data())
-def test_e2e_native_emit(test_file):
+@pytest.mark.parametrize("test_file", get_test_data("base"))
+def test_e2e_native_emit_base(test_file):
+    e2e_native_emit(test_file, "no_prelude")
+
+
+@pytest.mark.parametrize("test_file", get_test_data("prelude"))
+def test_e2e_native_emit_prelude(test_file):
+    e2e_native_emit(test_file, "script")
+
+
+@pytest.mark.parametrize("test_file", get_test_data("base"))
+def test_e2e_base(test_file):
+    e2e(test_file, "no_prelude")
+
+
+@pytest.mark.parametrize("test_file", get_test_data("prelude"))
+def test_e2e_prelude(test_file):
+    e2e(test_file, "script")
+
+
+def e2e_native_emit(test_file, mode):
     import linecache
 
     with open(test_file, "r") as f:
         source = f.read()
-    source, source_map = koatl.transpile_raw(source, mode="script")
+    source, source_map = koatl.transpile_raw(source, mode=mode)
 
     global_dict = {}
 
@@ -46,6 +64,5 @@ def test_e2e_native_emit(test_file):
     print("end", test_file)
 
 
-@pytest.mark.parametrize("test_file", get_test_data())
-def test_e2e(test_file):
-    koatl.cli.run_from_path(test_file, mode="script")
+def e2e(test_file, mode):
+    koatl.cli.run_from_path(test_file, mode=mode)

{koatl-0.1.14 → koatl-0.1.16}/koatl-core/Cargo.toml

@@ -6,3 +6,4 @@ edition = "2024"
 [dependencies]
 ariadne = "0.5.1"
 parser = { path = "parser" }
+once_cell = "1.19.0"

{koatl-0.1.14 → koatl-0.1.16}/koatl-core/parser/Cargo.toml

@@ -4,4 +4,4 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-chumsky = "0.10.1"
+chumsky = { version="0.10.1", features=["memoization"] }