koatl 0.1.27__tar.gz → 0.1.28__tar.gz

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

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

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

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

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

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

{koatl-0.1.27 → 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.27 → 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.27 → 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.27 → 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.27 → 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.27 → 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.27 → 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.27 → 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.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.27 → koatl-0.1.28}/koatl-core/src/transform.rs

@@ -230,6 +230,29 @@ fn simple_err(msg: impl Into<String>, span: Span) -> TlErrs {
     TlErrBuilder::new().message(msg.into()).span(span).build()
 }
 
+fn deduplicate<'src, 'ast>(
+    ctx: &mut TlCtx<'src, 'ast>,
+    expr: SPyExpr<'src>,
+    span: Span,
+) -> TlResult<SPyExprWithPre<'src>> {
+    let var_name = ctx.create_aux_var("lhs", span.start);
+    let a = PyAstBuilder::new(span);
+    let mut pre = PyBlock::new();
+
+    let expr = match expr.value {
+        PyExpr::Ident(id, _) => a.load_ident(id),
+        x => {
+            pre.push(a.assign(
+                a.ident(var_name.clone(), PyAccessCtx::Store),
+                (x, expr.tl_span).into(),
+            ));
+            a.load_ident(var_name.clone())
+        }
+    };
+
+    Ok(SPyExprWithPre { value: expr, pre })
+}
+
 impl<'src> BlockExt<'src> for [Indirect<SStmt<'src>>] {
     fn transform<'ast>(
         &'ast self,
@@ -715,10 +738,16 @@ fn create_throwing_matcher<'src, 'ast>(
     let fail = PyBlock(vec![a.raise(Some(a.call(
         a.load_ident("MatchError"),
         vec![a.call_arg(a.fstr(vec![
-            a.fstr_str("failed to match value "),
-            a.fstr_expr(a.load_ident(cursor.clone()), None),
+            a.fstr_str("failed to match value of type "),
+            a.fstr_expr(
+                a.call(
+                    a.tl_builtin("type"),
+                    vec![a.call_arg(a.load_ident(cursor.clone()))],
+                ),
+                None,
+            ),
             a.fstr_str(format!(
-                " to pattern {}",
+                " to pattern \"{}\"",
                 &ctx.source[pattern.span.start..pattern.span.end]
             )),
         ]))],
@@ -1528,29 +1557,6 @@ impl<'src> SStmtExt<'src> for SStmt<'src> {
                 if let Some(BinaryOp::Coalesce | BinaryOp::Pipe) = op {
                     let lhs = pre.bind(lhs.transform_store(ctx)?);
 
-                    fn deduplicate<'src, 'ast>(
-                        ctx: &mut TlCtx<'src, 'ast>,
-                        expr: SPyExpr<'src>,
-                        span: Span,
-                    ) -> TlResult<SPyExprWithPre<'src>> {
-                        let var_name = ctx.create_aux_var("lhs", span.start);
-                        let a = PyAstBuilder::new(span);
-                        let mut pre = PyBlock::new();
-
-                        let expr = match expr.value {
-                            PyExpr::Ident(id, _) => a.load_ident(id),
-                            x => {
-                                pre.push(a.assign(
-                                    a.ident(var_name.clone(), PyAccessCtx::Store),
-                                    (x, expr.tl_span).into(),
-                                ));
-                                a.load_ident(var_name.clone())
-                            }
-                        };
-
-                        Ok(SPyExprWithPre { value: expr, pre })
-                    }
-
                     // TODO this is a bit hacky. We need to get separate the root node
                     // from the rest of the expression to avoid double evaluation
                     let (safe_lhs_store, safe_lhs_load) = match lhs.value {
@@ -1568,11 +1574,11 @@ impl<'src> SStmtExt<'src> for SStmt<'src> {
                         }
                         PyExpr::Subscript(left, right, _) => {
                             let left_span = left.tl_span;
-                            // TODO, critical: this leads to double evaluation of subscript indices
                             let dedup = pre.bind(deduplicate(ctx, *left, left_span)?);
+                            let dedup_right = pre.bind(deduplicate(ctx, *right, left_span)?);
                             (
-                                a.subscript(dedup.clone(), *right.clone(), PyAccessCtx::Store),
-                                a.subscript(dedup, *right, PyAccessCtx::Load),
+                                a.subscript(dedup.clone(), dedup_right.clone(), PyAccessCtx::Store),
+                                a.subscript(dedup, dedup_right, PyAccessCtx::Load),
                             )
                         }
                         _ => panic!(),
@@ -1717,17 +1723,6 @@ impl<'src> SStmtExt<'src> for SStmt<'src> {
 trait SExprExt<'src, 'ast> {
     fn transform(&'ast self, ctx: &mut TlCtx<'src, 'ast>) -> TlResult<SPyExprWithPre<'src>>;
 
-    /**
-     * Transforms
-     * expr
-     * to
-     * x = expr
-     * x
-     *
-     * to avoid evaluating expr multiple times
-     */
-    fn transform_lifted(&'ast self, ctx: &mut TlCtx<'src, 'ast>) -> TlResult<SPyExprWithPre<'src>>;
-
     fn transform_store(&'ast self, ctx: &mut TlCtx<'src, 'ast>) -> TlResult<SPyExprWithPre<'src>>;
 
     fn transform_full(
@@ -1742,25 +1737,6 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
         self.transform_full(ctx, PyAccessCtx::Load)
     }
 
-    fn transform_lifted(&'ast self, ctx: &mut TlCtx<'src, 'ast>) -> TlResult<SPyExprWithPre<'src>> {
-        let mut pre = PyBlock::new();
-        let value = pre.bind(self.transform(ctx)?);
-        let a = PyAstBuilder::new(self.span);
-
-        let expr = match self.value {
-            Expr::Ident(..) | Expr::Literal(..) => value,
-            _ => {
-                let temp_var = ctx.create_aux_var("tmp", self.span.start);
-
-                pre.push(a.assign(a.ident(temp_var.clone(), PyAccessCtx::Store), value));
-
-                a.ident(temp_var, PyAccessCtx::Load)
-            }
-        };
-
-        Ok(SPyExprWithPre { value: expr, pre })
-    }
-
     fn transform_store(&'ast self, ctx: &mut TlCtx<'src, 'ast>) -> TlResult<SPyExprWithPre<'src>> {
         self.transform_full(ctx, PyAccessCtx::Store)
     }
@@ -1939,10 +1915,12 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
             }
             Expr::Binary(op, lhs, rhs) => 'block: {
                 if let BinaryOp::Coalesce = op {
-                    let py_lhs = pre.bind(lhs.transform_lifted(ctx)?);
+                    let py_lhs = pre.bind(lhs.transform(ctx)?);
                     let call = pre.bind(create_coalesce(ctx, py_lhs, rhs, span)?);
                     break 'block call;
                 } else if let BinaryOp::And | BinaryOp::Or = op {
+                    // handle short-circuiting manually
+
                     let is_and = *op == BinaryOp::And;
 
                     let py_lhs = pre.bind(lhs.transform(ctx)?);