koatl 0.1.27__tar.gz → 0.1.29__tar.gz

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

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

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

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

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

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

{koatl-0.1.27 → koatl-0.1.29/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,17 @@ 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):
+# TODO: enforce binding only once?
+export MonadOnce = class(Monad, Trait):
     """
     Abstract base class for single-use monads.
 
@@ -32,9 +30,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.29/koatl}/python/koatl/prelude/functional/list.tl

@@ -1,15 +1,14 @@
-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 " +
-                "due to generator limitations. " +
-                "Wrap in Ok to use the regular Result monad."
+            "List may not be bound using @ "
+                "due to generator limitations. "
+                "Wrap in Ok to use the Result monad."
         )
 
     bind = (self, f) => List(self.flat_map(f))
@@ -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.29/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.29/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.29}/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.29/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.29}/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.29/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.29}/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.29}/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.29/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.29}/koatl-core/parser/src/parser.rs

@@ -795,9 +795,8 @@ where
     ))
     .boxed();
 
-    let literal = select! {
+    let other_literal = select! {
         Token::Num(s) => Literal::Num(Cow::Borrowed(s)),
-        Token::Str(s) => Literal::Str(Cow::Owned(s)),
         Token::Bool(s) => Literal::Bool(s),
         Token::None => Literal::None
     }
@@ -805,6 +804,20 @@ where
     .labelled("literal")
     .boxed();
 
+    let literal_str = select! {
+        Token::Str(s) => s
+    }
+    .repeated()
+    .at_least(1)
+    .collect::<Vec<_>>()
+    .map_with(|x, e| Literal::Str(Cow::Owned(x.join(""))).spanned(e.span()))
+    .labelled("string-literal")
+    .boxed();
+
+    let literal = choice((literal_str, other_literal))
+        .labelled("literal")
+        .boxed();
+
     let literal_expr = literal
         .clone()
         .map(Expr::Literal)