koatl 0.1.37__tar.gz → 0.1.39__tar.gz

{koatl-0.1.37 → koatl-0.1.39}/Cargo.lock

@@ -99,7 +99,7 @@ checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
 
 [[package]]
 name = "koatl"
-version = "0.1.37"
+version = "0.1.39"
 dependencies = [
  "ariadne",
  "koatl-core",

{koatl-0.1.37 → koatl-0.1.39}/PKG-INFO

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

{koatl-0.1.37 → koatl-0.1.39}/koatl/Cargo.toml

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

koatl-0.1.39/koatl/python/koatl/prelude/__init__.tl

@@ -0,0 +1,40 @@
+export import koatl.std.(
+    trait.*
+    ext.*
+    data.*
+    iter.*
+    alg.(Result, Ok, Err, Env, Memo, Async, AsyncMemo)
+    alg.do
+)
+
+import koatl.std.(
+    re.Pattern
+    lazy_module.(LazyModule, RootModulesProxy)
+)
+
+export std = LazyModule("koatl.std")
+export mod = RootModulesProxy()
+
+Extension.trait(Iterable)
+
+Extension.property(list, "len")& List.len.fget
+
+Extension.property(object, "result")& self => Result(self)
+
+Extension.method(str, "match")& (regex, str) => Pattern(regex).match(str)
+
+# Note: the below methods have arguments in reverse order to Python's re module.
+Extension.method(str, "matches")& (str, regex) => Pattern(regex).match(str)
+Extension.method(str, "search")& (str, regex) => Pattern(regex).search(str)
+
+__tl__.do = koatl.std.alg.do.do
+
+__tl__.op_map = koatl.std.alg.result.op_map
+__tl__.op_coal = koatl.std.alg.result.op_coal
+
+__tl__.Ok = koatl.std.alg.result.Ok
+__tl__.Err = koatl.std.alg.result.Err
+__tl__.Result = koatl.std.alg.result.Result
+
+__tl__.memo_value = koatl.std.alg.memo.Memo.value
+__tl__.async_memo_value = koatl.std.alg.memo.AsyncMemo.value

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

@@ -0,0 +1,47 @@
+import functools
+import importlib
+from types import SimpleNamespace
+
+from koatl.runtime.record import Record
+from . import meta_finder, vattr
+
+meta_finder.install_hook()
+
+__all__ = ["__tl__"]
+
+
+def set_exports(package_name, globals_dict, exports, module_star_exports):
+    exports = set(exports)
+
+    for module in module_star_exports:
+        mod = importlib.import_module(module, package_name)
+
+        if hasattr(mod, "__all__"):
+            for name in mod.__all__:
+                exports.add(name)
+        else:
+            for name in dir(mod):
+                if name.startswith("_"):
+                    continue
+
+                exports.add(name)
+
+    if "__all__" not in globals_dict:
+        globals_dict["__all__"] = ()
+
+    globals_dict["__all__"] = tuple(set(globals_dict["__all__"]) | exports)
+
+
+__tl__ = SimpleNamespace(
+    Exception=Exception,
+    slice=slice,
+    type=type,
+    partial=functools.partial,
+    #
+    record_literal=Record.from_dict_ref,
+    #
+    set_exports=set_exports,
+    #
+    vget=vattr.vget,
+    vhas=vattr.vhas,
+)

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

@@ -0,0 +1,252 @@
+import collections
+from collections.abc import MutableMapping
+import functools
+import inspect
+import re
+
+_property = property
+
+__all__ = ["Record"]
+
+
+@collections.abc.MutableMapping.register
+class Record:
+    def __init__(self, data=None, /, **kwargs):
+        if data is None:
+            self.__dict__ = kwargs
+        else:
+            self.__dict__ = dict(data, **kwargs)
+
+    @classmethod
+    def from_dict_ref(cls, dict_obj):
+        if not isinstance(dict_obj, dict):
+            raise TypeError("Expected a dictionary")
+
+        self = cls.__new__(cls)
+        self.__dict__ = dict_obj
+        return self
+
+    @staticmethod
+    def method(fn):
+        fn._method = True
+        return fn
+
+    @staticmethod
+    def property(fn):
+        fn._property = True
+        return fn
+
+    def __getattribute__(self, name):
+        dict = object.__getattribute__(self, "__dict__")
+
+        try:
+            attr = dict[name]
+
+            if hasattr(attr, "_property"):
+                return attr(self)
+            elif hasattr(attr, "_method"):
+                return functools.partial(attr, self)
+        except KeyError:
+            pass
+
+        return object.__getattribute__(self, name)
+
+    @_property
+    def iter(self):
+        return self.items()
+
+    # MutableMapping
+    def __len__(self):
+        return len(self.__dict__)
+
+    def __getitem__(self, key):
+        try:
+            return self.__dict__[key]
+        except KeyError as e:
+            raise e
+
+    def __setitem__(self, key, item):
+        self.__dict__[key] = item
+
+    def __delitem__(self, key):
+        del self.__dict__[key]
+
+    def __iter__(self):
+        return iter(self.__dict__)
+
+    def __contains__(self, key):
+        return key in self.__dict__
+
+    def get(self, key, default=None):
+        return self.__dict__.get(key, default)
+
+    def items(self):
+        return self.__dict__.items()
+
+    def keys(self):
+        return self.__dict__.keys()
+
+    def values(self):
+        return self.__dict__.values()
+
+    # dict
+    def __repr__(self):
+        return repr(self.__dict__)
+
+    def __or__(self, other):
+        if isinstance(other, Record):
+            return self.__class__(self.__dict__ | other.__dict__)
+        if isinstance(other, dict):
+            return self.__class__(self.__dict__ | other)
+        return NotImplemented
+
+    def __ror__(self, other):
+        if isinstance(other, Record):
+            return self.__class__(other.__dict__ | self.__dict__)
+        if isinstance(other, dict):
+            return self.__class__(other | self.__dict__)
+        return NotImplemented
+
+    def __ior__(self, other):
+        if isinstance(other, Record):
+            self.__dict__ |= other.__dict__
+        else:
+            self.__dict__ |= other
+        return self
+
+    def __copy__(self):
+        inst = self.__class__.__new__(self.__class__)
+        inst.__dict__ = self.__dict__.copy()
+        return inst
+
+    def copy(self):
+        if self.__class__ is Record:
+            return Record(self.__dict__.copy())
+        import copy
+
+        data = self.__dict__
+        try:
+            self.__dict__ = {}
+            c = copy.copy(self)
+        finally:
+            self.__dict__ = data
+        c.update(self)
+        return c
+
+    @_property
+    def len(self):
+        return len(self)
+
+    # Other
+
+    def __repr__(self):
+        return self._repr_with_visited(set())
+
+    def __hash__(self):
+        return hash(tuple(sorted(self.items())))
+
+    def __eq__(self, other):
+        if isinstance(other, Record):
+            return self.__dict__ == other.__dict__
+
+        if isinstance(other, dict):
+            return self.__dict__ == other
+
+        return NotImplemented
+
+    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):
+            if self._is_identifier(key):
+                # If key is an identifier, drop the quotes
+                return key
+            return f'"{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
+        )
+
+
+for key, value in MutableMapping.__dict__.items():
+    # copy over mixin methods from MutableMapping
+    if key.startswith("__"):
+        continue
+
+    if not inspect.isfunction(value):
+        continue
+
+    if hasattr(value, "__isabstractmethod__") and value.__isabstractmethod__:
+        continue
+
+    if key not in Record.__dict__:
+        setattr(Record, key, value)
+
+koatl_keywords = {
+    "if",
+    "then",
+    "else",
+    "import",
+    "export",
+    "as",
+    "class",
+    "while",
+    "for",
+    "in",
+    "break",
+    "continue",
+    "with",
+    "yield",
+    "global",
+    "return",
+    "raise",
+    "try",
+    "except",
+    "finally",
+    "and",
+    "or",
+    "not",
+    "await",
+    "let",
+    "const",
+    "with",
+}

koatl-0.1.37/koatl/python/koatl/runtime/virtual.py → koatl-0.1.39/koatl/python/koatl/runtime/vattr.py

@@ -1,7 +1,6 @@
 from functools import partial
 from itertools import count
-from types import SimpleNamespace
-from koatl._rs import fast_vget, fast_vset, fast_vset_trait
+from koatl._rs import fast_vget
 
 
 def vget(obj, name, ignore_traits=False):
@@ -66,38 +65,3 @@ def vhas(obj, name, ignore_traits=False):
         return True
 
     return False
-
-
-def ext_prop(type, name):
-    def impl(value):
-        value._property = True
-        fast_vset(type, name, value)
-        return value
-
-    return impl
-
-
-def ext_method(type, name):
-    def impl(value):
-        fast_vset(type, name, value)
-        return value
-
-    return impl
-
-
-def ext_trait(type):
-    for name, value in type._own_methods.items():
-        fast_vset_trait(type.__name__, type._trait_reqs, name, value)
-    return type
-
-
-Extension = SimpleNamespace(
-    property=ext_prop,
-    method=ext_method,
-    trait=ext_trait,
-)
-
-
-__all__ = [
-    "Extension",
-]

{koatl-0.1.37 → koatl-0.1.39/koatl}/python/koatl/std/alg/base.tl

@@ -1,3 +1,5 @@
+import koatl.std.trait.Trait
+
 export Monad = class(Trait):
     """
     Abstract base class for monads.

koatl-0.1.39/koatl/python/koatl/std/alg/do.tl

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

{koatl-0.1.37 → koatl-0.1.39/koatl}/python/koatl/std/alg/result.tl

@@ -7,6 +7,22 @@ infer_ok = x =>
         BaseException() => False
         default True
 
+op_coal = (x, f) =>
+    if x matches Result():
+        return x.coalesce(f)
+
+    if not infer_ok(x):
+        return f()
+    return x
+
+op_map = (x, f) =>
+    if x matches Result():
+        return x.map(f)
+
+    if infer_ok(x):
+        return f(x)
+    return x
+
 export Result = class(MonadOnce):
     __slots__ = ()
     __match_args__ = ("value",)
@@ -158,4 +174,4 @@ export Err = class(Result):
         if self.value matches BaseException():
             raise self.value
         raise ValueError(f"Expected Ok, got {repr(self)}")
-    coalesce = (self, f) => f()
+    coalesce = (self, f) => f()

koatl-0.1.39/koatl/python/koatl/std/data/__init__.tl

@@ -0,0 +1,2 @@
+export import .list.List
+export import .record.Record

koatl-0.1.39/koatl/python/koatl/std/data/record.tl

@@ -0,0 +1,5 @@
+import koatl.runtime
+
+# TODO: should we just move this to this module?
+
+export Record = runtime.record.Record

koatl-0.1.39/koatl/python/koatl/std/ext.tl

@@ -0,0 +1,24 @@
+import koatl._rs.(fast_vset, fast_vset_trait)
+
+ext_prop = (type, name) => value =>
+    value::_property = True
+    fast_vset(type, name, value)
+    value
+
+
+ext_method = (type, name) => value =>
+    fast_vset(type, name, value)
+    value
+
+
+ext_trait = type =>
+    for name, value in type::_own_methods:
+        fast_vset_trait(type::__name__, type::_trait_reqs, name, value)
+    type
+
+
+export Extension = {
+    property: ext_prop,
+    method: ext_method,
+    trait: ext_trait,
+}

{koatl-0.1.37 → koatl-0.1.39/koatl}/python/koatl/std/iter.tl

@@ -1,7 +1,8 @@
 import itertools
 import builtins
-import .alg.(Traversable, Ok, Err, Memo, Async, AsyncMemo, Result)
 
+import koatl.std.trait.Trait
+import .alg.(Traversable, Ok, Err, Memo, Async, AsyncMemo, Result)
 
 export Iterable = class(Traversable, Trait):
     iter = Trait.abstract& self => None

{koatl-0.1.37 → koatl-0.1.39}/koatl/python/koatl/std/lazy_module.tl

@@ -30,4 +30,16 @@ export LazyModule = class:
 
         raise AttributeError(f"Module '{self._name}' has no attribute '{attr}'")
 
-    __repr__ = self => f"LazyModule({self._name})"
+    __repr__ = self => f"LazyModule({self._name})"
+
+
+export RootModulesProxy = class:
+    __init__ = (self) =>
+        self._modules = {}
+
+    __getattr__ = (self, attr) =>
+        if attr not in self._modules:
+            self._modules[attr] = LazyModule(attr)
+        return self._modules[attr]
+
+    __repr__ = self => f"RootModulesProxy({self._modules})"

koatl-0.1.37/koatl/python/koatl/runtime/classes.py → koatl-0.1.39/koatl/python/koatl/std/trait.py

@@ -2,7 +2,7 @@ import abc
 import collections
 import inspect
 
-from koatl.runtime.virtual import vhas
+from koatl.prelude import __tl__
 
 
 @collections.abc.Mapping.register
@@ -40,7 +40,7 @@ class MappingMeta(type):
         return [(k, v) for k, v in inspect.getmembers(self) if not k.startswith("_")]
 
 
-# A utility base class to inherit from to enable __getitem__ method lookup on types and thus destructuring.
+# A utility base class to inherit from that implements Mapping on the type and thus destructuring.
 class Class(metaclass=MappingMeta):
     pass
 
@@ -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 vhas(instance, req):
+                if not __tl__.vhas(instance, req):
                     return False
 
             return True

{koatl-0.1.37 → koatl-0.1.39}/koatl/src/lib.rs

@@ -118,8 +118,9 @@ fn fast_vget<'py, 'ptr>(
     let vtbl2 = VTBL2.lock().unwrap();
 
     if let Some(traits) = vtbl2.get(&name) {
-        let tlmod = py.import("koatl.runtime.virtual")?;
-        let vget = tlmod.getattr("vget")?;
+        let runtime = py.import("koatl.runtime")?;
+        let tl = runtime.getattr("__tl__")?;
+        let vget = tl.getattr("vget")?;
 
         for t in traits {
             let mut ok = true;

{koatl-0.1.37 → koatl-0.1.39}/koatl/tests/e2e/base/containers.tl

@@ -2,7 +2,10 @@ import util.assert_eq
 
 assert_eq(type([1, 2, 3]), list)
 assert_eq(type((1, 2, 3)), tuple)
-assert_eq(type({1: 2}), Record)
+
+# Record type is not directly made available by the runtime.
+assert_eq(type({1: 2}).__name__, "Record")
+
 assert_eq(type(()), tuple)
 assert_eq(type((1,)), tuple)
 assert_eq(type(1), int)