koatl 0.1.38__tar.gz → 0.1.40__tar.gz

{koatl-0.1.38 → koatl-0.1.40}/Cargo.lock

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

{koatl-0.1.38 → koatl-0.1.40}/PKG-INFO

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

{koatl-0.1.38 → koatl-0.1.40}/koatl/Cargo.toml

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

koatl-0.1.40/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.40/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.40/koatl/python/koatl/runtime/record.py

@@ -0,0 +1,249 @@
+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):
+        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.38/koatl/python/koatl/runtime/virtual.py → koatl-0.1.40/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.40/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.38 → koatl-0.1.40/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.40/koatl/python/koatl/std/data/__init__.tl

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

koatl-0.1.40/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.40/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.38 → koatl-0.1.40}/koatl/python/koatl/std/lazy_module.tl

@@ -3,14 +3,14 @@ import collections
 
 export LazyModule = class:
     __init__ = (self, name) =>
-        self._name = name
-        self._module = None
-        self._submodules = {}
+        self.__dict__["_name"] = name
+        self.__dict__["_module"] = None
+        self.__dict__["_submodules"] = {}
 
     __getattr__ = (self, attr) =>
         try:
             if self._module === None:
-                self._module = importlib.import_module(self._name)
+                self.__dict__["_module"] = importlib.import_module(self._name)
 
             if hasattr(self._module, "__path__"):
                 if attr not in self._submodules:
@@ -30,4 +30,22 @@ export LazyModule = class:
 
         raise AttributeError(f"Module '{self._name}' has no attribute '{attr}'")
 
-    __repr__ = self => f"LazyModule({self._name})"
+    __setattr__ = (self, attr, value) =>
+        if self._module === None:
+            self.__dict__["_module"] = importlib.import_module(self._name)
+
+        setattr(self._module, attr, value)
+
+    __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.38 → koatl-0.1.40/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
@@ -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.38 → koatl-0.1.40}/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;
@@ -179,14 +180,23 @@ fn fast_vset_trait<'py, 'ptr>(
     }
 
     // TODO: what about conflicting traits?
-    vtbl.get_mut(&name).unwrap().insert(
-        0,
-        TraitAttr {
-            name: trait_name.to_string(),
-            requirements: reqs,
-            value: value.clone().unbind(),
-        },
-    );
+    let vtbl_entry = vtbl.get_mut(&name).unwrap();
+    if let Some(existing) = vtbl_entry
+        .iter_mut()
+        .find(|e| e.name == trait_name.to_string())
+    {
+        existing.requirements = reqs;
+        existing.value = value.clone().unbind();
+    } else {
+        vtbl_entry.insert(
+            0,
+            TraitAttr {
+                name: trait_name.to_string(),
+                requirements: reqs,
+                value: value.clone().unbind(),
+            },
+        );
+    }
 
     Ok(())
 }

{koatl-0.1.38 → koatl-0.1.40}/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)

{koatl-0.1.38 → koatl-0.1.40}/koatl-core/parser/src/lexer.rs

@@ -132,7 +132,6 @@ pub fn py_escape_str(s: &str) -> String {
 }
 
 pub fn py_escape_fstr(s: &str) -> String {
-    // TODO
     py_escape_str(s)
         .chars()
         .map(|c| match c {
@@ -143,30 +142,6 @@ pub fn py_escape_fstr(s: &str) -> String {
         .collect()
 }
 
-pub fn escape_str(s: &str) -> String {
-    // TODO
-    s.chars()
-        .map(|c| match c {
-            '\n' => "\\n".to_string(),
-            '"' => "\\\"".to_string(),
-            _ => c.to_string(),
-        })
-        .collect()
-}
-
-pub fn escape_fstr(s: &str) -> String {
-    // TODO
-    s.chars()
-        .map(|c| match c {
-            '{' => "{{".to_string(),
-            '}' => "}}".to_string(),
-            '\n' => "\\n".to_string(),
-            '"' => "\\\"".to_string(),
-            _ => c.to_string(),
-        })
-        .collect()
-}
-
 // TODO don't duplicate this with parser below
 pub fn is_valid_ident(s: &str) -> bool {
     if s.is_empty() {
@@ -661,9 +636,11 @@ where
                 current_str = String::new();
 
                 self.parse_nonsemantic()?;
-                let _ = self.try_parse(|x| x.parse_newline());
+                while self.try_parse(TokenizeCtx::parse_empty_line).is_ok() {}
+
                 let sexpr = self.try_parse(|x| x.parse_block(0, NewBlockType::BeginInput))?;
-                let _ = self.try_parse(|x| x.parse_newline());
+
+                while self.try_parse(TokenizeCtx::parse_empty_line).is_ok() {}
 
                 self.parse_indentation()?;
 
@@ -851,7 +828,6 @@ where
     ) -> TResult<'src, Spanned<TokenList<'src>>> {
         let mut tokens = vec![];
 
-        // TODO should parse_empty_line be part of parse_indentation?
         while self.try_parse(TokenizeCtx::parse_empty_line).is_ok() {}
 
         let indent_level = self.try_parse(|x| x.parse_indentation()).map_err(|_| {