koatl 0.1.26__tar.gz → 0.1.28__tar.gz

{koatl-0.1.26 → koatl-0.1.28}/Cargo.lock

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

{koatl-0.1.26 → koatl-0.1.28}/PKG-INFO

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

{koatl-0.1.26 → koatl-0.1.28}/koatl/Cargo.toml

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

{koatl-0.1.26 → koatl-0.1.28/koatl}/python/koatl/prelude/functional/algebra.tl

@@ -1,6 +1,4 @@
-import abc
-
-export Monad = class(abc.ABC):
+export Monad = class(Trait):
     """
     Abstract base class for monads.
 
@@ -9,17 +7,16 @@ export Monad = class(abc.ABC):
     """
     __slots__ = ()
 
-    bind = abc.abstractmethod& (self, f) => None
+    bind = Abstract& (self, f) => None
 
-    pure = staticmethod& abc.abstractmethod& value => None
+    pure = staticmethod& Abstract& value => None
 
     # Automatically generated implementations.
     map = (self, f) => self.bind(x => self.pure(f(x)))
     apply = (self, f) => self.bind(x => f.map(fn => fn(x)))
 
 
-# TODO: should this inherit from Monad?
-export MonadOnce = class(abc.ABC):
+export MonadOnce = class(Monad, Trait):
     """
     Abstract base class for single-use monads.
 
@@ -32,9 +29,7 @@ export MonadOnce = class(abc.ABC):
     __slots__ = ()
 
     # 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
+    bind_once = Abstract& (self, f) => None
 
     # An optional, optimized implementation of `bind` that skips deep recursion.
     # TODO: can this be automatically generated from bind_once?

{koatl-0.1.26 → koatl-0.1.28/koatl}/python/koatl/prelude/functional/list.tl

@@ -1,10 +1,9 @@
-import collections.UserList
 import itertools
 
 import .Monad
 import ..iterable.Iterable
 
-export List = class(UserList, Monad):
+export List = class(Monad):
     bind_once = (self, f) =>
         raise NotImplementedError(
             "Binding List in a do-block doesn't work in Koatl " +
@@ -23,4 +22,4 @@ for name, method in List.__dict__:
     if name.startswith("_"):
         continue
 
-    register_global_attr(list, name, method)
+    ExtensionMethod(list, name)& method

{koatl-0.1.26 → koatl-0.1.28/koatl}/python/koatl/prelude/functional/result.tl

@@ -1,5 +1,4 @@
 import functools.wraps
-import koatl.runtime.virtual.register_global_attr
 import .algebra.MonadOnce
 
 export Result = class(MonadOnce):
@@ -118,14 +117,14 @@ export Err = class(Result):
     coalesce = (self, f) => f()
 
 
-register_global_attr(type(None), "ok", ExtensionProperty(_ => False))
-register_global_attr(BaseException, "ok", ExtensionProperty(_ => False))
-register_global_attr(object, "ok", ExtensionProperty(_ => True))
+ExtensionProperty(type(None), "ok")& _ => False
+ExtensionProperty(BaseException, "ok")& _ => False
+ExtensionProperty(object, "ok")& _ => True
 
-register_global_attr(object, "result", ExtensionProperty(Result))
+ExtensionProperty(object, "result")& Result
 
 # Enables @ operator for bare objects.
-register_global_attr(object, "bind_gen", Result.bind_gen)
+ExtensionMethod(object, "bind_gen")& Result.bind_gen
 
 __tl__.Ok = Ok
 __tl__.Err = Err

{koatl-0.1.26 → koatl-0.1.28/koatl}/python/koatl/prelude/iterable.tl

@@ -1,15 +1,17 @@
 import itertools
 import builtins
 
-methods = {
-    map: (x, f) => builtins.map(f, x.iter)
+export Iterable = ExtensionTrait& class(Trait):
+    iter = Abstract
 
-    filter: (x, f) => builtins.filter(f, x.iter)
+    map = (self, f) => builtins.map(f, self.iter)
 
-    flat_map: (x, f) => itertools.chain.from_iterable(x.map(f))
+    filter = (self, f) => builtins.filter(f, self.iter)
 
-    traverse: (x, f) =>
-        let it = x.iter
+    flat_map = (self, f) => itertools.chain.from_iterable(self.map(f))
+
+    traverse = (self, f) =>
+        let it = self.iter
         let v
         try:
             v = next(it)
@@ -39,45 +41,39 @@ methods = {
             acc = acc.apply(m.map(x => acc => [*acc, x]))
         acc
 
-    fold: (x, init, f) =>
+    fold = (self, init, f) =>
         let acc = init
-        for i in x:
+        for i in self:
             acc = f(acc, i)
         acc
 
-    first: (x, f) =>
-        for i in x:
+    first = (self, f) =>
+        for i in self:
             if f(i):
                 return i
         return None
 
-    last: (x, f) =>
+    last = (self, f) =>
         let result = None
-        for i in x:
+        for i in self:
             if f(i):
                 result = i
         return result
 
-    at: (x, index) =>
-        for i in x:
+    at = (self, index) =>
+        for i in self:
             if i == index:
                 return i
         raise IndexError("Index out of range")
 
-    sum: x =>
+    sum = self =>
         let acc = 0
-        for i in x:
+        for i in self:
             acc = acc + i
         acc
 
-    list: x =>
-        list(x.iter)
-
-    record: x =>
-        Record(x.iter)
-}
-
-# TODO merge this with typing.Iterable?
+    list = self =>
+        list(self.iter)
 
-export Iterable = Trait(__name__, "Iterable", methods, requires=["iter"])
-register_global_trait(Iterable)
+    record = self =>
+        Record(self.iter)

{koatl-0.1.26 → koatl-0.1.28}/koatl/python/koatl/runtime/__init__.py

@@ -19,6 +19,7 @@ meta_finder.install_hook()
 from .virtual import *
 from .record import *
 from .helpers import *
+from .classes import *
 
 
 def dummy(name):
@@ -33,9 +34,9 @@ def dummy(name):
 __tl__ = SimpleNamespace(
     Exception=Exception,
     slice=slice,
+    type=type,
     vget=virtual.vget,
     vhas=virtual.vhas,
-    unpack_record=helpers.unpack_record,
     set_exports=helpers.set_exports,
     do=helpers.do,
     partial=functools.partial,
@@ -50,6 +51,7 @@ __tl__ = SimpleNamespace(
     **{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__},
+    **{name: classes.__dict__[name] for name in classes.__all__},
 )
 
 
@@ -58,4 +60,5 @@ __all__ = [
     *helpers.__all__,
     *record.__all__,
     *virtual.__all__,
+    *classes.__all__,
 ]

koatl-0.1.28/koatl/python/koatl/runtime/classes.py

@@ -0,0 +1,92 @@
+import abc
+import collections
+import inspect
+
+from koatl.runtime.virtual import vhas
+
+
+@collections.abc.Mapping.register
+class MappingMeta(type):
+    def __getitem__(self, key):
+        return getattr(self, key)
+
+    def __iter__(self):
+        return self.keys().__iter__()
+
+    def __len__(self):
+        return len(self.items())
+
+    def __contains__(self, key):
+        return hasattr(self, key)
+
+    def get(self, key, default=None):
+        if hasattr(self, key):
+            return getattr(self, key)
+        else:
+            return default
+
+    def keys(self):
+        return [k for k, _ in self.items()]
+
+    def values(self):
+        return [v for _, v in self.items()]
+
+    def items(self):
+        return [(k, v) for k, v in inspect.getmembers(self) if not k.startswith("_")]
+
+
+class Class(metaclass=MappingMeta):
+    pass
+
+
+# temporary value, since TraitMeta needs to reference Trait.
+Trait = None
+
+
+class TraitMeta(MappingMeta):
+    def __init__(cls, name, bases, namespace):
+        super().__init__(name, bases, namespace)
+
+        if Trait in bases:
+            cls._trait_reqs = []
+            cls._own_methods = []
+
+            for key, value in inspect.getmembers(cls):
+                if (
+                    hasattr(value, "__isabstractmethod__")
+                    and value.__isabstractmethod__
+                ):
+                    cls._trait_reqs.append(key)
+
+            for key, value in namespace.items():
+                if (
+                    hasattr(value, "__isabstractmethod__")
+                    and value.__isabstractmethod__
+                ):
+                    # Abstract methods are not considered "own methods".
+                    continue
+
+                if callable(value) and not key.startswith("_"):
+                    cls._own_methods.append(key)
+
+    def __instancecheck__(cls, instance):
+        # 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):
+                    return False
+
+            return True
+        else:
+            return type.__instancecheck__(cls, instance)
+
+
+class Trait(metaclass=TraitMeta):
+    pass
+
+
+Abstract = lambda value: abc.abstractmethod(value)
+Abstract.__isabstractmethod__ = True
+
+
+__all__ = ["Class", "Trait", "Abstract"]

{koatl-0.1.26 → koatl-0.1.28}/koatl/python/koatl/runtime/helpers.py

@@ -35,16 +35,6 @@ def set_exports(package_name, globals_dict, exports, module_star_exports):
     globals_dict["__all__"] = tuple(set(globals_dict["__all__"]) | exports)
 
 
-def unpack_record(obj):
-    """
-    used in record unpacking
-    """
-    if hasattr(obj, "items"):
-        return Record(obj.items())
-    else:
-        return Record(obj.__dict__)
-
-
 def ok(obj):
     try:
         return obj.ok

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

@@ -0,0 +1,103 @@
+from functools import partial
+from itertools import count
+from .._rs import fast_vget, fast_vset, fast_vset_trait
+
+
+def vget(obj, name, ignore_traits=False):
+    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, ignore_traits)
+        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 vhas(obj, name, ignore_traits=False):
+    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, ignore_traits)
+    if v is not None:
+        return True
+
+    return False
+
+
+def ExtensionProperty(type, name):
+    def impl(value):
+        value._ext_prop = True
+        fast_vset(type, name, value)
+        return value
+
+    return impl
+
+
+def ExtensionMethod(type, name):
+    def impl(value):
+        fast_vset(type, name, value)
+        return value
+
+    return impl
+
+
+def ExtensionTrait(type):
+    for name in type._own_methods:
+        fast_vset_trait(type.__name__, type._trait_reqs, name, type.__dict__[name])
+    return type
+
+
+def TraitProperty(value):
+    value._ext_prop = True
+    return value
+
+
+__all__ = [
+    "ExtensionProperty",
+    "ExtensionMethod",
+    "ExtensionTrait",
+    "TraitProperty",
+]

{koatl-0.1.26 → koatl-0.1.28}/koatl/src/emit_py.rs

@@ -279,10 +279,36 @@ impl<'src> PyStmtExt<'src> for SPyStmt<'src> {
                     .collect();
                 ctx.ast_node("Match", (subject_ast, cases_ast?), &self.tl_span)
             }
-            PyStmt::Assign(target, value) => {
+            PyStmt::Assign(target, value, op) => {
                 let target_ast = target.emit_py(ctx)?;
                 let value_ast = value.emit_py(ctx)?;
-                ctx.ast_node("Assign", ([target_ast], value_ast), &self.tl_span)
+
+                if let Some(op) = op {
+                    let py_op = match op {
+                        PyBinaryOp::Add => "Add",
+                        PyBinaryOp::Sub => "Sub",
+                        PyBinaryOp::Mult => "Mult",
+                        PyBinaryOp::Div => "Div",
+                        _ => {
+                            return Err(PyTlErr {
+                                message: format!(
+                                    "Unsupported augmented assignment operator: {:?}",
+                                    op
+                                ),
+                                py_err: None,
+                                span: Some(self.tl_span),
+                            });
+                        }
+                    };
+
+                    ctx.ast_node(
+                        "AugAssign",
+                        (target_ast, ctx.ast_cls(py_op, ())?, value_ast),
+                        &self.tl_span,
+                    )
+                } else {
+                    ctx.ast_node("Assign", ([target_ast], value_ast), &self.tl_span)
+                }
             }
             PyStmt::Return(expr) => {
                 let expr_ast = expr.emit_py(ctx)?;

{koatl-0.1.26 → koatl-0.1.28}/koatl/src/lib.rs

@@ -178,11 +178,15 @@ fn fast_vset_trait<'py, 'ptr>(
         vtbl.insert(name.clone(), Vec::new());
     }
 
-    vtbl.get_mut(&name).unwrap().push(TraitAttr {
-        name: trait_name.to_string(),
-        requirements: reqs,
-        value: value.clone().unbind(),
-    });
+    // TODO: what about conflicting traits?
+    vtbl.get_mut(&name).unwrap().insert(
+        0,
+        TraitAttr {
+            name: trait_name.to_string(),
+            requirements: reqs,
+            value: value.clone().unbind(),
+        },
+    );
 
     Ok(())
 }

{koatl-0.1.26 → koatl-0.1.28}/koatl/tests/e2e/base/coal.tl

@@ -17,3 +17,12 @@ assert_eq(1?.($ + 1)(), 2)
 
 assert_eq(None ?? 1, 1)
 assert_eq(int(5) ?? 1, 5)
+
+counts = 0
+f = () =>
+    counts = counts + 1
+
+f() ?? 1
+
+# should only call once
+assert_eq(counts, 1)

{koatl-0.1.26 → koatl-0.1.28}/koatl/tests/e2e/base/destructure.tl

@@ -48,11 +48,5 @@ assert_eq([a, b, c], ["a", [2, 3], {2: "2", 3: "3"}])
 {a, **b} = {a: 42, b: 43}
 assert_eq([a, b], [42, {b: 43}])
 
-a, *b, c = 1, 2, 3, 4
-assert_eq([a, b, c], [1, (2, 3), 4])
-
 a, [*b], c, *d = 1, [2, 3], 4, 5, 6
-assert_eq([a, b, c, d], [1, [2, 3], 4, (5, 6)])
-
-# destructuring modules
-{assert_eq} = util
+assert_eq([a, b, c, d], [1, [2, 3], 4, [5, 6]])

koatl-0.1.28/koatl/tests/e2e/base/record.tl

@@ -0,0 +1,24 @@
+import util.assert_eq
+
+assert_eq(
+    {a: 0}.keys() | list
+    ["a"]
+)
+
+assert_eq(
+    {(): 0}.keys() | list
+    [()]
+)
+
+assert_eq(
+    {(1): 0}.keys() | list
+    [1]
+)
+
+assert_eq(
+    {(
+        let x = 1
+        x
+    ): 0}.keys() | list
+    [1]
+)

{koatl-0.1.26 → koatl-0.1.28}/koatl/tests/e2e/base/scopes.tl

@@ -89,4 +89,16 @@ f = () =>
 
     A().f()
     assert_eq(A, 2)
+f()
+
+# Shadowing should work
+f = () =>
+    let x = 1
+    let x = x + 1
+    assert_eq(x, 2)
+
+    # but recursion should also work
+    let x = 3
+    let x = () => x.__name__
+    assert_eq(type(x()), str)
 f()

koatl-0.1.28/koatl/tests/e2e/prelude/aug_assign.tl

@@ -0,0 +1,23 @@
+import util.assert_eq
+
+x = 1
+x += 2
+assert_eq(x, 3)
+
+x = None
+x ??= 2
+assert_eq(x, 2)
+
+x = 4
+x |= $ + 2
+assert_eq(x, 6)
+
+
+counts = 0
+f = () =>
+    counts += 1
+    {x: None}
+f().x ??= 2
+
+# should only call once
+assert_eq(counts, 1)

{koatl-0.1.26 → koatl-0.1.28}/koatl/tests/e2e/prelude/memo.tl

@@ -29,3 +29,20 @@ assert_eq(f(10).run(ctx), 20)
 assert_eq(f(5).run(ctx), 10)
 assert_eq(f(5).run(ctx), 10)
 assert_eq(counts, 2)
+
+# Indirect dependencies should be tracked as well.
+
+counts = 0
+
+f = (x, y) =>
+    memo:
+        counts = counts + 1
+        let other = () => y
+        x * other()
+
+ctx = Memo.Cache()
+assert_eq(f(10, 20).run(ctx), 200)
+assert_eq(f(10, 20).run(ctx), 200)
+assert_eq(f(10, 30).run(ctx), 300)
+assert_eq(f(10, 30).run(ctx), 300)
+assert_eq(counts, 2)

{koatl-0.1.26 → koatl-0.1.28}/koatl/tests/e2e/prelude/reader.tl

@@ -1,6 +1,6 @@
 import util.assert_eq
 
-{ask} = Reader
+ask = Reader.ask
 
 g = () =>
     @ask("c")

{koatl-0.1.26 → koatl-0.1.28}/koatl-core/parser/src/ast.rs

@@ -121,7 +121,9 @@ pub enum DeclType {
 #[derive(Debug, Clone)]
 pub enum Stmt<'a, TTree: Tree> {
     Decl(Vec<SIdent<'a>>, DeclType),
-    Assign(TTree::Expr, TTree::Expr, Option<DeclType>),
+    Assign(TTree::Expr, TTree::Expr, Option<BinaryOp>),
+    PatternAssign(TTree::Pattern, TTree::Expr, Option<DeclType>),
+
     Expr(TTree::Expr),
 
     Return(TTree::Expr),

{koatl-0.1.26 → koatl-0.1.28}/koatl-core/parser/src/lexer.rs

@@ -272,7 +272,8 @@ where
 
     fn parse_symbol(&mut self) -> TResult<'src, Spanned<Token<'src>>> {
         const POLYGRAMS: &[&str] = &[
-            "===", "<=>", "=>", "..", "==", "<>", "<=", ">=", "//", "**", "??", ".=",
+            "+=", "-=", "*=", "/=", "|=", "??=", "===", "<=>", "=>", "..", "==", "<>", "<=", ">=",
+            "//", "**", "??", ".=",
         ];
         const MONOGRAMS: &str = "[](){}<>.,;:!?@$%^&*+-=|\\/`~";