koatl 0.1.11__tar.gz → 0.1.13__tar.gz

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

@@ -99,10 +99,11 @@ checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
 
 [[package]]
 name = "koatl"
-version = "0.1.11"
+version = "0.1.13"
 dependencies = [
  "ariadne",
  "koatl-core",
+ "once_cell",
  "pyo3",
 ]
 

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

@@ -1,10 +1,9 @@
 Metadata-Version: 2.4
 Name: koatl
-Version: 0.1.11
+Version: 0.1.13
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Dist: forbiddenfruit
 License-File: LICENSE
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM

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

@@ -1,6 +1,6 @@
 [package]
 name = "koatl"
-version = "0.1.11"
+version = "0.1.13"
 edition = "2021"
 
 [lib]
@@ -8,6 +8,7 @@ name = "koatl"
 crate-type = ["cdylib"]
 
 [dependencies]
+koatl-core = { path = "../koatl-core" }
 pyo3 = "0.25.0"
 ariadne = "0.5.1"
-koatl-core = { path = "../koatl-core" }
+once_cell = "1.19.0"

koatl-0.1.13/koatl/python/koatl/__init__.py

@@ -0,0 +1,15 @@
+from . import _rs
+
+
+def transpile(*args, **kwargs):
+    try:
+        return _rs.transpile(*args, **kwargs)
+    except SyntaxError as e:
+        raise SyntaxError(e.args[0].decode("utf8")) from None
+
+
+def transpile_raw(*args, **kwargs):
+    try:
+        return _rs.transpile_raw(*args, **kwargs)
+    except SyntaxError as e:
+        raise SyntaxError(e.args[0].decode("utf8")) from None

{koatl-0.1.11 → koatl-0.1.13}/koatl/python/koatl/__main__.py

@@ -3,13 +3,16 @@ import subprocess
 import os
 import time
 
+
 def main():
     mode = "script"
     transpile_only = False
 
     while True and len(sys.argv) > 1:
         if sys.argv[1] == "--help":
-            print(f"Usage: python -m koatl [--trans] [--mode script|module|interactive] <filename.(py|tl)>")
+            print(
+                f"Usage: python -m koatl [--trans] [--mode script|module|interactive] <filename.(py|tl)>"
+            )
             sys.exit(1)
 
         if sys.argv[1] == "--mode":
@@ -31,37 +34,54 @@ def main():
         km = None
 
         try:
-            km = KernelManager(kernel_name='koatl')
+            km = KernelManager(kernel_name="koatl")
             km.start_kernel()
 
             # Give the kernel a moment to fully initialize
             # time.sleep(1)
-            
-            jupyter_command = [sys.executable, '-m', 'jupyter_console', '--existing', km.connection_file]
+
+            jupyter_command = [
+                sys.executable,
+                "-m",
+                "jupyter_console",
+                "--existing",
+                km.connection_file,
+            ]
             subprocess.call(jupyter_command)
         except FileNotFoundError:
             print("\nError: 'jupyter' command not found.", file=sys.stderr)
-            print("Please ensure 'jupyter_console' is installed (pip install jupyter_console) and in your PATH.", file=sys.stderr)
-            print("Also, ensure 'koatl' kernel is installed for Jupyter.", file=sys.stderr)
+            print(
+                "Please ensure 'jupyter_console' is installed (pip install jupyter_console) and in your PATH.",
+                file=sys.stderr,
+            )
+            print(
+                "Also, ensure 'koatl' kernel is installed for Jupyter.", file=sys.stderr
+            )
             sys.exit(1)
         except Exception as e:
             print(f"\nAn unexpected error occurred: {e}", file=sys.stderr)
-            print("Please ensure the 'koatl' kernel is correctly installed and registered with Jupyter.", file=sys.stderr)
+            print(
+                "Please ensure the 'koatl' kernel is correctly installed and registered with Jupyter.",
+                file=sys.stderr,
+            )
             sys.exit(1)
         finally:
             # 4. Clean up: Shutdown the kernel and remove its connection file
             if km and km.is_alive():
                 print("Shutting down the kernel...")
-                km.shutdown_kernel(now=True) # Forceful shutdown
+                km.shutdown_kernel(now=True)  # Forceful shutdown
                 print("Kernel shut down.")
-            
+
             # Clean up the connection file if it still exists
             if km and km.connection_file and os.path.exists(km.connection_file):
                 try:
                     os.remove(km.connection_file)
                     print(f"Removed connection file: {km.connection_file}")
                 except OSError as e:
-                    print(f"Error removing connection file {km.connection_file}: {e}", file=sys.stderr)
+                    print(
+                        f"Error removing connection file {km.connection_file}: {e}",
+                        file=sys.stderr,
+                    )
     else:
         script_path = sys.argv[1]
         sys.argv = sys.argv[1:]
@@ -73,27 +93,34 @@ def main():
             print(f"Error: File not found at '{script_path}'")
             sys.exit(1)
 
-        if script_path.endswith('.tl'):
+        if script_path.endswith(".tl"):
             import koatl.cli
+
             if transpile_only:
-                print(koatl.cli.transpile_from_source(original_script_code, mode=mode, script_path=script_path))
+                print(
+                    koatl.cli.transpile_from_source(
+                        original_script_code, mode=mode, script_path=script_path
+                    )
+                )
             else:
-                koatl.cli.run_from_source(original_script_code, mode=mode, script_path=script_path)
+                koatl.cli.run_from_source(
+                    original_script_code, mode=mode, script_path=script_path
+                )
         else:
-            injected_code = \
-        """
+            injected_code = """
         # -- injected code --
         from koatl.runtime import *
         """
 
             full_code = injected_code + original_script_code
-            code_obj = compile(full_code, script_path, 'exec')
+            code_obj = compile(full_code, script_path, "exec")
 
             script_globals = {
-                '__name__': '__main__',
+                "__name__": "__main__",
             }
 
             exec(code_obj, script_globals)
 
+
 if __name__ == "__main__":
-    main()
+    main()

koatl-0.1.13/koatl/python/koatl/prelude/functional/async.tl

@@ -0,0 +1,38 @@
+import functools.wraps
+import asyncio
+import .async_util
+
+export Async = class:
+    __init__ = (self, awaitable) => self.generator = awaitable.__await__()
+
+    __await__ = self => self.generator
+
+    __repr__ = self => "Async(...)"
+
+    from_generator_fn = &[staticmethod] (generator_fn, *args, **kwargs) =>
+        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__())
+
+            if hasattr(result, "__await__"):
+                return yield from result.__await__()
+
+            return result
+    )
+
+    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.13/koatl/python/koatl/prelude/functional/async_util.py

@@ -0,0 +1,15 @@
+"""
+At the time of writing, I haven't implemented async def
+in Koatl, so this is a workaround.
+
+This function converts a generic awaitable (perhaps a
+vanilla generator) into a coroutine that can be used
+by asyncio.run, which expects strictly a coroutine.
+
+(In practice, async def shouldn't be needed anyways,
+since we have the Async monad.)
+"""
+
+
+async def to_coro(awaitable):
+    return await awaitable

{koatl-0.1.11 → koatl-0.1.13}/koatl/python/koatl/prelude/functional/ok.tl

@@ -1,5 +1,5 @@
 import functools.wraps
-import koatl.runtime.traits.register_global_attr
+import koatl.runtime.virtual.register_global_attr
 
 OkMeta = class(type):
     __instancecheck__ = (cls, instance) => __tl__.ok(instance)

{koatl-0.1.11 → koatl-0.1.13}/koatl/python/koatl/prelude/iterable.tl

@@ -44,10 +44,10 @@ methods = {
         acc
 
     list: x =>
-        list(x!iter)
+        list(x.iter)
 
     record: x =>
-        Record(x!iter)
+        Record(x.iter)
 }
 
 # TODO merge this with typing.Iterable?

koatl-0.1.13/koatl/python/koatl/runtime/__init__.py

@@ -0,0 +1,42 @@
+"""
+This module initializes the environment for koatl.
+It sets up the meta-finder hook to enable importing .tl files,
+and also declares functions that are required for certain tl features to work,
+such as coalescing and module exports.
+
+koatl.runtime should be written in Python only since otherwise
+it would create a circular dependency.
+"""
+
+import functools
+from types import SimpleNamespace
+
+from . import meta_finder
+
+meta_finder.install_hook()
+
+
+from .virtual import *
+from .record import *
+from .helpers import *
+
+
+__tl__ = SimpleNamespace(
+    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__},
+    **{name: record.__dict__[name] for name in record.__all__},
+    **{name: virtual.__dict__[name] for name in virtual.__all__}
+)
+
+
+__all__ = [
+    "__tl__",
+    *helpers.__all__,
+    *record.__all__,
+    *virtual.__all__,
+]

koatl-0.1.11/koatl/python/koatl/runtime/__init__.py → koatl-0.1.13/koatl/python/koatl/runtime/helpers.py

@@ -1,17 +1,9 @@
-"""
-This module initializes the environment for koatl.
-It sets up the meta-finder hook to enable importing .tl files,
-and also declares functions that are required for certain tl features to work,
-such as coalescing and module exports.
-"""
-
 from functools import wraps
-from types import SimpleNamespace
+from .virtual import vget
+from .record import Record
 
-from . import meta_finder
-from .._rs import Record, vget, ok
 
-meta_finder.install_hook()
+__all__ = ["MatchError"]
 
 
 class MatchError(Exception):
@@ -37,7 +29,10 @@ def set_exports(package_name, globals_dict, exports, module_star_exports):
 
                 exports.add(name)
 
-    globals_dict["__all__"] = tuple(exports)
+    if "__all__" not in globals_dict:
+        globals_dict["__all__"] = ()
+
+    globals_dict["__all__"] = tuple(set(globals_dict["__all__"]) | exports)
 
 
 def unpack_record(obj):
@@ -50,6 +45,14 @@ def unpack_record(obj):
         return Record(obj.__dict__)
 
 
+def ok(obj):
+    if obj is None:
+        return False
+    if isinstance(obj, BaseException):
+        return False
+    return True
+
+
 def do(f):
     @wraps(f)
     def impl(*args, **kwargs):
@@ -74,26 +77,3 @@ def do(f):
         return vget(m, "bind_once")(recurse)
 
     return impl
-
-
-from .traits import *
-
-
-__tl__ = SimpleNamespace(
-    Record=Record,
-    MatchError=MatchError,
-    unpack_record=unpack_record,
-    set_exports=set_exports,
-    vget=vget,
-    ok=ok,
-    do=do,
-    **{name: traits.__dict__[name] for name in traits.__all__}
-)
-
-
-__all__ = [
-    "__tl__",
-    "Record",
-    "MatchError",
-    *traits.__all__,
-]

koatl-0.1.13/koatl/python/koatl/runtime/record.py

@@ -0,0 +1,88 @@
+import re
+
+__all__ = ["Record"]
+
+
+class Record(dict):
+    def __repr__(self):
+        return self._repr_with_visited(set())
+
+    def __getattr__(self, name):
+        try:
+            return self[name]
+        except KeyError:
+            raise AttributeError(
+                f"'{type(self).__name__}' object has no attribute '{name}'"
+            ) from None
+
+    def _repr_with_visited(self, visited):
+        # Handle cycles by checking if this object is already being processed
+        obj_id = id(self)
+        if obj_id in visited:
+            return "{...}"
+
+        visited.add(obj_id)
+        try:
+            if not self:
+                return "{}"
+
+            items = []
+            for key, value in self.items():
+                key_str = self._format_key(key)
+
+                # Handle value representation with cycle detection
+                if isinstance(value, Record):
+                    value_str = value._repr_with_visited(visited.copy())
+                elif hasattr(value, "__dict__") and hasattr(value, "__class__"):
+                    # For other objects that might contain cycles, use a simple repr
+                    value_str = repr(value)
+                else:
+                    value_str = repr(value)
+
+                items.append(f"{key_str}: {value_str}")
+
+            return "{" + ", ".join(items) + "}"
+        finally:
+            visited.remove(obj_id)
+
+    def _format_key(self, key):
+        if isinstance(key, str) and self._is_identifier(key):
+            # If key is an identifier, drop the quotes
+            return key
+
+        elif isinstance(key, (int, float, bool, type(None))):
+            # If key is a literal like 0, 1, True, False, None, use repr
+            return repr(key)
+
+        else:
+            # Otherwise, use f"({repr(key)})"
+            return f"({repr(key)})"
+
+    def _is_identifier(self, s):
+        return (
+            isinstance(s, str)
+            and re.match(r"^[a-zA-Z_][a-zA-Z0-9_]*$", s)
+            and s not in koatl_keywords
+        )
+
+
+koatl_keywords = {
+    "if",
+    "else",
+    "while",
+    "for",
+    "def",
+    "class",
+    "return",
+    "import",
+    "from",
+    "as",
+    "with",
+    "try",
+    "except",
+    "finally",
+    "raise",
+    "assert",
+    "async",
+    "await",
+}

koatl-0.1.13/koatl/python/koatl/runtime/virtual.py

@@ -0,0 +1,111 @@
+from functools import partial
+from itertools import count
+from types import new_class
+from .._rs import fast_vget, fast_vset, fast_vset_trait
+
+
+def ExtensionProperty(f):
+    f.ext_prop = True
+    return f
+
+
+def vget(obj, name):
+    try:
+        return getattr(obj, name)
+    except:
+        # 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 count(start, step)
+                else:
+                    return range(start, obj.stop, step)
+
+            try:
+                return obj.items()
+            except AttributeError:
+                pass
+
+            try:
+                return iter(obj)
+            except TypeError:
+                pass
+
+        v = fast_vget(obj, name)
+        if v is not None:
+            if hasattr(v, "ext_prop"):
+                return v(obj)
+
+            return partial(v, obj)
+
+        raise AttributeError(
+            f"'{type(obj).__name__}' object has no v-attribute '{name}'"
+        ) from None
+
+
+def Trait(module, name, methods, *, requires=[]):
+    def fix_methods(type_name, methods):
+        import inspect
+
+        for method_name, method in methods.items():
+            method.__name__ = method_name
+            method.__qualname__ = f"{type_name}.{method_name}"
+
+            if not isinstance(method, (staticmethod, classmethod)):
+                sig = inspect.signature(method)
+                params = list(sig.parameters.values())
+                params[0].replace(name="self")
+                sig = sig.replace(parameters=params)
+                method.__signature__ = sig
+
+    fix_methods(name, methods)
+
+    def instancecheck(cls, instance):
+        if cls != typ:
+            # if not checking for the trait itself, use the default behavior
+            return type.__instancecheck__(cls, instance)
+
+        for req in requires:
+            try:
+                vget(instance, req)
+            except AttributeError:
+                return False
+
+        return True
+
+    meta = type(
+        f"{name}Meta",
+        (type,),
+        {"__instancecheck__": instancecheck, "__module__": "types"},
+    )
+
+    def populate(ns):
+        for method_name, method in methods.items():
+            ns[method_name] = method
+        ns["__module__"] = module
+        ns["_methods"] = methods
+        ns["_requires"] = requires
+
+    typ = new_class(name, (), {"metaclass": meta}, populate)
+
+    return typ
+
+
+def register_global_attr(type, name, value):
+    fast_vset(type, name, value)
+
+
+def register_global_trait(type):
+    for name, method in type._methods.items():
+        fast_vset_trait(type.__name__, type._requires, name, method)
+
+
+__all__ = [
+    "Trait",
+    "ExtensionProperty",
+    "register_global_attr",
+    "register_global_trait",
+]