koatl 0.1.13__tar.gz → 0.1.15__tar.gz

{koatl-0.1.13 → koatl-0.1.15}/Cargo.lock

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

{koatl-0.1.13 → koatl-0.1.15}/PKG-INFO

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

{koatl-0.1.13 → koatl-0.1.15}/koatl/Cargo.toml

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

{koatl-0.1.13 → koatl-0.1.15/koatl}/python/koatl/cli.py

@@ -2,7 +2,7 @@ def transpile_from_source(source, mode="script", script_path="<string>"):
     from koatl import transpile
     import ast
 
-    transpiled_code = transpile(source, mode=mode)
+    transpiled_code = transpile(source, mode=mode, filename=str(script_path))
 
     return ast.unparse(transpiled_code)
 
@@ -10,7 +10,7 @@ def transpile_from_source(source, mode="script", script_path="<string>"):
 def run_from_source(source, mode="script", script_path="<string>"):
     from koatl import transpile
 
-    transpiled_code = transpile(source, mode=mode)
+    transpiled_code = transpile(source, mode=mode, filename=str(script_path))
     code_obj = compile(transpiled_code, script_path, "exec")
 
     script_globals = {"__name__": "__main__"}

{koatl-0.1.13 → koatl-0.1.15}/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.13 → koatl-0.1.15/koatl}/python/koatl/prelude/functional/__init__.tl

@@ -1,15 +1,16 @@
-export import .ok.*
+export import .monad.*
+export import .result.*
 export import .async.*
 export import .reader.*
 
 export Fn = class:
-    compose = &[staticmethod] (*args) =>
+    compose = staticmethod& (*args) =>
         args match:
             [] => 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.15/koatl/python/koatl/prelude/functional/async.tl

@@ -0,0 +1,43 @@
+import functools.wraps
+import asyncio
+
+import .async_util
+import .monad.Monad
+
+export Async = class(Monad):
+    __init__ = (self, awaitable) => self.generator = awaitable.__await__()
+
+    __await__ = self => self.generator
+
+    __repr__ = self => "Async(...)"
+
+    from_generator_fn = staticmethod& (generator_fn, *args, **kwargs) =>
+        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& () =>
+        let result = f(yield from self.__await__())
+
+        if hasattr(result, "__await__"):
+            return yield from result.__await__()
+
+        return result
+
+    bind_gen = (self, gen) => Async.from_generator_fn& () =>
+        try:
+            while True:
+                self = gen.send(yield from self.__await__())
+        except StopIteration(value=value):
+            return value
+
+    pure = staticmethod& x => Async.from_generator_fn& () =>
+        return x
+        yield None
+
+    sleep = staticmethod& x => Async(asyncio.sleep(x))
+
+    #- TODO: Why is asyncio.gather eager? -#
+    gather = staticmethod& (*args) => Async.from_generator_fn& () => yield from asyncio.gather(*args)

koatl-0.1.15/koatl/python/koatl/prelude/functional/monad.tl

@@ -0,0 +1,12 @@
+import abc
+
+export Monad = class(abc.ABC):
+    bind = (self, f) => self.bind_once(f)
+
+    # An optional, optimized implementation of `bind` that skips deep recursion.
+    bind_gen = (self, gen) => raise NotImplementedError()
+
+    # The default implementation required for `@` syntax that should be overridden by subclasses.
+    bind_once = abc.abstractmethod& (self, f) => None
+
+    pure = staticmethod& abc.abstractmethod& value => None

koatl-0.1.15/koatl/python/koatl/prelude/functional/reader.tl

@@ -0,0 +1,31 @@
+import functools.wraps
+import .monad.Monad
+
+export Reader = class(Monad):
+    __init__ = (self, fn) => self.fn = fn
+
+    __repr__ = self => "Reader(...)"
+
+    run = (self, ctx) => self.fn(ctx)
+
+    bind_once = (self, f) => Reader& ctx =>
+        let v = f(self.fn(ctx))
+        if v matches Reader():
+            v.fn(ctx)
+        else:
+            v
+
+    bind_gen = (self, gen) => Reader& ctx =>
+        try:
+            while True:
+                self = gen.send(self.fn(ctx))
+        except StopIteration(value=value):
+            return value
+
+    NoKey = object()
+
+    ask = staticmethod& (key=NoKey) => Reader(
+        key === Reader.NoKey then ctx => ctx else ctx => ctx[key]
+    )
+
+    pure = staticmethod& value => Reader(ctx => value)

koatl-0.1.15/koatl/python/koatl/prelude/functional/result.tl

@@ -0,0 +1,80 @@
+import functools.wraps
+import .monad.Monad
+import koatl.runtime.virtual.register_global_attr
+
+export Result = class(Monad):
+    bind_once = (self, f) => self match:
+        Ok(value) => f(value)
+        Ok() => f(self)
+        default => self
+
+    bind_gen = (self, gen) =>
+        try:
+            while True:
+                if not __tl__.ok(self):
+                    return self
+
+                if self matches Ok(value):
+                    self = value
+
+                self = gen.send(self)
+        except StopIteration(value=value):
+            if value === None:
+                return Ok(None)
+            return value
+
+    map_err = (self, f) =>
+        if self matches Err():
+            return f(self)
+        else:
+            return self
+
+OkMeta = class(type):
+    __instancecheck__ = (cls, instance) => __tl__.ok(instance)
+
+export Ok = class(metaclass=OkMeta):
+    __match_args__ = ("value",)
+
+    __init__ = (self, value) =>
+        self.value = value
+
+    # Since we are using a custom metaclass, we can't derive from Result
+    # so need to copy the methods over manually from Result
+
+    # We could just use the object fallback methods, but this avoids
+    # the manual __tl__.vget
+    bind_once = Result.bind_once
+    bind_gen = Result.bind_gen
+    map_err = Result.map_err
+
+    assert = staticmethod& value =>
+        value match:
+            BaseException() as e => raise e
+            None => raise ValueError("Expected a value, got None")
+            default value
+
+export Err = BaseException
+
+register_global_attr(
+    object,
+    "map_err",
+    Result.map_err
+)
+
+register_global_attr(
+    object,
+    "bind",
+    Result.bind_once
+)
+
+register_global_attr(
+    object,
+    "bind_once",
+    Result.bind_once
+)
+
+register_global_attr(
+    object,
+    "bind_gen",
+    Result.bind_gen
+)

{koatl-0.1.13 → koatl-0.1.15}/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.13 → koatl-0.1.15}/koatl/python/koatl/runtime/__init__.py

@@ -22,10 +22,12 @@ from .helpers import *
 
 
 __tl__ = SimpleNamespace(
+    slice=slice,
+    vget=virtual.vget,
+    vhas=virtual.vhas,
     unpack_record=helpers.unpack_record,
     set_exports=helpers.set_exports,
     do=helpers.do,
-    vget=helpers.vget,
     ok=helpers.ok,
     partial=functools.partial,
     **{name: helpers.__dict__[name] for name in helpers.__all__},

{koatl-0.1.13 → koatl-0.1.15}/koatl/python/koatl/runtime/helpers.py

@@ -56,17 +56,17 @@ def ok(obj):
 def do(f):
     @wraps(f)
     def impl(*args, **kwargs):
-        coro = f(*args, **kwargs)
+        gen = f(*args, **kwargs)
 
         try:
-            m = coro.send(None)
+            m = gen.send(None)
         except StopIteration as e:
             return e.value
 
         def recurse(v):
             nonlocal m
             try:
-                m = coro.send(v)
+                m = gen.send(v)
                 return vget(m, "bind_once")(recurse)
             except StopIteration as e:
                 try:
@@ -74,6 +74,12 @@ def do(f):
                 except AttributeError:
                     return e.value
 
-        return vget(m, "bind_once")(recurse)
+        try:
+            # 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)
 
     return impl

{koatl-0.1.13 → koatl-0.1.15/koatl}/python/koatl/runtime/meta_finder.py

@@ -53,9 +53,13 @@ class TlLoader(Loader):
         )
 
         if module.__name__.startswith("koatl.prelude"):
-            transpiled_code = transpile(source_code, mode="prelude")
+            transpiled_code = transpile(
+                source_code, mode="no_prelude", filename=self.filepath
+            )
         else:
-            transpiled_code = transpile(source_code, mode="module")
+            transpiled_code = transpile(
+                source_code, mode="module", filename=self.filepath
+            )
 
         code = compile(transpiled_code, self.filepath, "exec")
 

{koatl-0.1.13 → koatl-0.1.15/koatl}/python/koatl/runtime/virtual.py

@@ -46,6 +46,33 @@ def vget(obj, name):
         ) from None
 
 
+def vhas(obj, name):
+    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)
+    if v is not None:
+        return True
+
+    return False
+
+
 def Trait(module, name, methods, *, requires=[]):
     def fix_methods(type_name, methods):
         import inspect

{koatl-0.1.13 → koatl-0.1.15}/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.13 → koatl-0.1.15}/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.13 → koatl-0.1.15}/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.13 → koatl-0.1.15}/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.15/koatl/tests/e2e/base/scopes.tl

@@ -0,0 +1,49 @@
+import util.assert_eq
+
+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)
+
+f = () =>
+    let test = 5
+    assert_eq(test, 5)
+
+f()
+assert_eq(test, 2)
+
+f = () =>
+    test = 5
+    let g = () =>
+        test = 6
+    g()
+    assert_eq(test, 6)
+
+f()
+
+
+f = () =>
+    test = 5
+    let g = () =>
+        let test = 6
+    g()
+    assert_eq(test, 5)
+
+f()
+
+test = 0
+
+f = test =>
+    test = 1
+    assert_eq(test, 1)
+
+f(1)
+assert_eq(test, 0)

{koatl-0.1.13 → koatl-0.1.15}/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.13/koatl/tests/e2e/prelude/ok.tl → koatl-0.1.15/koatl/tests/e2e/prelude/result.tl

@@ -16,4 +16,14 @@ fn = () =>
     v.append(@321)
 fn()
 
-assert_eq(v, [123, 222, 321])
+assert_eq(v, [123, 222, 321])
+
+v = []
+fn = () =>
+    v.append(@123)
+    v.append(@Ok(None))
+    v.append(@ValueError())
+    v.append(@321)
+fn()
+
+assert_eq(v, [123, None])

koatl-0.1.15/koatl/tests/parse/deco.tl

@@ -0,0 +1,2 @@
+wraps(f)& x => x
+y = wraps(f)& x => x

{koatl-0.1.13 → koatl-0.1.15}/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.13 → koatl-0.1.15}/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.13 → koatl-0.1.15}/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"] }