koatl 0.1.28__tar.gz → 0.1.30__tar.gz

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

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

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

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

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

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

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

@@ -0,0 +1,4 @@
+export import .functional.*
+
+export import .iterable.Iterable
+export import .io

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

@@ -3,7 +3,8 @@ export Monad = class(Trait):
     Abstract base class for monads.
 
     Subclasses must implement `bind` and `pure`.
-    Automatically provides standard monadic operations: bind_once, map, and apply.
+    Automatically provides (likely suboptimal) standard
+    functor operations: map, apply, lift.
     """
     __slots__ = ()
 
@@ -13,18 +14,20 @@ export Monad = class(Trait):
 
     # Automatically generated implementations.
     map = (self, f) => self.bind(x => self.pure(f(x)))
-    apply = (self, f) => self.bind(x => f.map(fn => fn(x)))
+    apply = (self, mf) => self.bind(x => mf.map(f => f(x)))
 
 
 export MonadOnce = class(Monad, Trait):
     """
-    Abstract base class for single-use monads.
+    Abstract base class for monads that don't require branching.
 
-    A MonadOnce can only be bound once, which is suitable for
+    A MonadOnce only calls `f` in `bind_once` once, which is suitable for
     use with Python generators that cannot be cloned or reused.
 
     Subclasses must implement `bind_once` and `pure`.
-    Automatically provides (likely suboptimal) standard monadic operations: bind, map, and apply.
+
+    Subclasses may also implement `bind_gen` for more efficient
+    handling of do-blocks.
     """
     __slots__ = ()
 
@@ -37,5 +40,23 @@ export MonadOnce = class(Monad, Trait):
 
     # Automatically generated implementations.
     bind = (self, f) => self.bind_once(f)
-    map = (self, f) => self.bind(x => self.pure(f(x)))
-    apply = (self, f) => self.bind(x => f.map(fn => fn(x)))
+
+
+export Identity = class(MonadOnce):
+    __init__ = (self, *args, **kwargs) => raise ValueError(
+        "Identity should not be instantiated directly. "
+    )
+
+    bind_once = (self, f) => f(self)
+
+    pure = staticmethod& x => x
+
+
+export Traversable = class(Trait):
+    """
+    Abstract base class for traversable data structures.
+    Subclasses must implement `traverse`.
+    """
+    __slots__ = ()
+
+    traverse = Abstract& (self, f) => None

{koatl-0.1.28 → koatl-0.1.30}/koatl/python/koatl/prelude/functional/async.tl

@@ -24,7 +24,7 @@ export Async = class(MonadOnce):
         if hasattr(result, "__await__"):
             return yield from result.__await__()
 
-        return result
+        result
 
     bind_gen = (self, gen) => Async.from_generator_fn& () =>
         try:
@@ -39,5 +39,11 @@ export Async = class(MonadOnce):
 
     sleep = staticmethod& x => Async(asyncio.sleep(x))
 
-    # TODO: Why is asyncio.gather eager?
-    gather = staticmethod& (*args) => Async.from_generator_fn& () => yield from asyncio.gather(*args)
+    # These execute immediately, so we need to wrap them in a generator
+    # (otherwise, there might not be an event loop running)
+
+    gather = staticmethod& (*args) => Async.from_generator_fn& () =>
+        yield from asyncio.gather(*args)
+
+    from_sync = staticmethod& (f, *args, **kwargs) => Async.from_generator_fn& () =>
+        yield from asyncio.get_running_loop().run_in_executor(None, () => f(*args, **kwargs))

koatl-0.1.30/koatl/python/koatl/prelude/functional/list.tl

@@ -0,0 +1,29 @@
+import itertools
+
+import .Monad
+
+export List = class(Monad):
+    __new__ = (cls, *args, **kwargs) => raise ValueError(
+        "List cannot be instantiated directly. "
+            "Use [] or list()."
+    )
+
+    bind_once = (self, f) =>
+        raise NotImplementedError(
+            "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))
+
+    pure = staticmethod& x => [x]
+
+    len = TraitProperty& self => len(self)
+
+
+for name, method in List.__dict__:
+    if name.startswith("_"):
+        continue
+
+    ExtensionMethod(list, name)& method

{koatl-0.1.28 → koatl-0.1.30}/koatl/python/koatl/prelude/functional/memo.tl

@@ -64,7 +64,7 @@ export Memo = class(MonadOnce):
     bind_once = (self, f) => Memo(ctx =>
         let value = f(self.f(ctx))
         if value matches Memo():
-            value = value.f(ctx)
+            return value.f(ctx)
         value
     )
 

{koatl-0.1.28 → koatl-0.1.30/koatl}/python/koatl/prelude/functional/reader.tl

@@ -11,9 +11,8 @@ export Reader = class(MonadOnce):
     bind_once = (self, f) => Reader& ctx =>
         let v = f(self.fn(ctx))
         if v matches Reader():
-            v.fn(ctx)
-        else:
-            v
+            return v.fn(ctx)
+        v
 
     bind_gen = (self, gen) => Reader& ctx =>
         try:

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

@@ -1,5 +1,5 @@
 import functools.wraps
-import .algebra.MonadOnce
+import .algebra.(Identity, MonadOnce)
 
 export Result = class(MonadOnce):
     __slots__ = ()
@@ -28,9 +28,7 @@ export Result = class(MonadOnce):
         if not self.ok:
             return self
 
-        let v = Result(f(self.value))
-
-    bind = bind_once
+        f(self.value)
 
     bind_gen = (self, gen) =>
         self = Result(self)
@@ -41,7 +39,7 @@ export Result = class(MonadOnce):
 
                 self = Result(gen.send(self.value))
         except StopIteration(value=value):
-            return Result.pure(value)
+            return Result(value)
 
     pure = staticmethod& x => Ok(x)
 
@@ -74,6 +72,29 @@ export Result = class(MonadOnce):
             return Err(f())
         return self
 
+    T = class(MonadOnce):
+        __slots__ = ("value",)
+        __init__ = (self, value) =>
+            if not hasattr(value, "bind_once"):
+                raise TypeError("Expected a MonadOnce value")
+
+            self.value = value
+
+        __repr__ = self => f"Result.T({repr(self.value)})"
+
+        pure = (self, x) => self.value.pure(Result.pure(x))
+
+        bind_once = (self, f) =>
+            self.value.bind_once(x =>
+                x = Result(x)
+
+                if not x.ok:
+                    return self.value.pure(x)
+
+                f(x.value)
+            )
+
+
 export Ok = class(Result):
     __slots__ = ("value",)
     ok = True
@@ -95,11 +116,12 @@ export Ok = class(Result):
     unwrap = self => self.value
     coalesce = (self, f) => self.value
 
+
 export Err = class(Result):
     __slots__ = ("value",)
     ok = False
-    __new__ = (cls, value) => object.__new__(cls)
-    __init__ = (self, value) =>
+    __new__ = (cls, value=None) => object.__new__(cls)
+    __init__ = (self, value=None) =>
         if hasattr(self, "value"):
             return None
         self.value = value
@@ -109,7 +131,7 @@ export Err = class(Result):
             return False
         return self.value == other.value
 
-    __repr__ = self => f"Err({repr(self.value)})"
+    __repr__ = self => f"Err({self.value === None then "" else repr(self.value)})"
     unwrap = self =>
         if self.value matches BaseException():
             raise self.value
@@ -123,11 +145,9 @@ ExtensionProperty(object, "ok")& _ => True
 
 ExtensionProperty(object, "result")& Result
 
-# Enables @ operator for bare objects.
-ExtensionMethod(object, "bind_gen")& Result.bind_gen
-
 __tl__.Ok = Ok
 __tl__.Err = Err
+__tl__.Result = Result
 
 __tl__.op_coal = (x, f) =>
     if x matches Result():

koatl-0.1.30/koatl/python/koatl/prelude/io.tl

@@ -0,0 +1,5 @@
+export read = (filename) =>
+    let desc = open(filename, "r")
+    let data = desc.read()
+    desc.close()
+    data

koatl-0.1.30/koatl/python/koatl/prelude/iterable.tl

@@ -0,0 +1,194 @@
+import itertools
+import builtins
+import .functional.Traversable
+import .functional.(Ok, Err)
+
+export Iterable = ExtensionTrait& class(Traversable, Trait):
+    iter = Abstract
+
+    skip = (self, n) =>
+        let it = self.iter
+        for _ in ..n:
+            next(it, None)
+        it
+
+    take = (self, n) =>
+        let impl = () =>
+            let it = self.iter
+            for _ in ..n:
+                try:
+                    yield next(it)
+                except StopIteration(value=value):
+                    return value
+
+        impl.__name__ = f"take"
+        impl.__qualname__ = f"Iterable.take"
+
+        impl()
+
+    take_while = (self, f) =>
+        let impl = () =>
+            for i in self.iter:
+                if not f(i):
+                    return None
+                yield i
+
+        impl.__name__ = f"take_while"
+        impl.__qualname__ = f"Iterable.take_while"
+
+        impl()
+
+    chain = (self, *others) =>
+        itertools.chain(self.iter, *others.map($.iter))
+
+    zip = (self, *others) =>
+        zip(self.iter, *others.map($.iter))
+
+    enumerate = (self, start=0) =>
+        enumerate(self.iter, start)
+
+    map = (self, f) => builtins.map(f, self.iter)
+
+    filter = (self, f) => builtins.filter(f, self.iter)
+
+    flat_map = (self, f) => itertools.chain.from_iterable(self.map(f))
+
+    reverse = self => reversed(list(self.iter))
+
+    sort = (self, key=None, reverse=False) =>
+        sorted(self.iter, key=key, reverse=reverse)
+
+    copy = self => itertools.tee(self.iter)
+
+
+    count = self => len(self.iter)
+
+    fold = (self, init, f) =>
+        let acc = init
+        for i in self:
+            acc = f(acc, i)
+        acc
+
+    associate = (self, f) =>
+        let acc = dict() # Don't use Record here.
+        for i in self:
+            let value = f(i)
+            acc[i] = value
+        acc
+
+    group_by = (self, f) =>
+        let acc = dict()
+        for i in self:
+            let key = f(i)
+            if not acc.__contains__(key):
+                acc[key] = []
+            acc[key].append(i)
+        acc
+
+    count_by = (self, f) =>
+        let acc = dict()
+        for i in self:
+            let key = f(i)
+            if not acc.__contains__(key):
+                acc[key] = 0
+            acc[key] += 1
+        acc
+
+    all = (self, f) =>
+        for i in self:
+            if not f(i):
+                return False
+        return True
+
+    any = (self, f) =>
+        for i in self:
+            if f(i):
+                return True
+        return False
+
+    find = (self, f) =>
+        for i in self:
+            if f(i):
+                return Ok(i)
+        return Err()
+
+    first = self =>
+        (try next(self.iter)).map_err(_ => None)
+
+    last = (self, f) =>
+        let result = Err()
+        for i in self:
+            if f(i):
+                result = Ok(i)
+        return result
+
+    at = (self, index) =>
+        for i in self:
+            if i == index:
+                return Ok(i)
+        return Err()
+
+    sum = self =>
+        let acc = 0
+        for i in self:
+            acc = acc + i
+        acc
+
+    for_each = (self, f) =>
+        for i in self:
+            f(i)
+
+    list = self =>
+        list(self.iter)
+
+    dict = self =>
+        dict(self.iter)
+
+    record = self =>
+        Record(self.iter)
+
+    traverse = (self, f=None) =>
+        import .functional.(Async, Result)
+
+        if f === None:
+            f = x => x
+
+        let it = self.iter
+        let v
+        try:
+            v = next(it)
+        except StopIteration():
+            return []
+
+        let m = f(v)
+
+        # TODO: can special case traversals be generalized?
+
+        # The Result traversal of a list is short-circuiting.
+        # Fall back to Result semantics for bare types.
+        if m matches Result() or not hasattr(m, "apply"):
+            if not m.ok:
+                return m
+
+            let acc = [m]
+            for v in it:
+                let fv = f(v)
+                if not fv.ok:
+                    return fv
+                acc.append(fv)
+            return acc
+
+        # The Async traversal of a list is gather.
+        if m matches Async():
+            let acc = [m]
+            for v in it:
+                acc.append(f(v))
+            return Async.gather(*acc)
+
+        # Fall back to default applicative semantics.
+        let acc = m.map([$])
+        for v in it:
+            m = f(v)
+            # acc = liftA2((list, value) => [*list, value])(acc, f(v))
+            acc = acc.apply(m.map(x => acc => [*acc, x]))
+        acc

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

@@ -48,6 +48,7 @@ __tl__ = SimpleNamespace(
     op_coal=("??"),
     Ok=dummy("try-expr"),
     Err=dummy("try-expr"),
+    Result=dummy("do"),
     **{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__},

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

@@ -1,6 +1,5 @@
 from functools import wraps
 from .virtual import vget
-from .record import Record
 
 
 __all__ = ["MatchError"]
@@ -56,11 +55,10 @@ def do(f):
         try:
             m = gen.send(None)
         except StopIteration as e:
-            if not hasattr(e.value, "bind_once"):
-                raise ValueError(
-                    "This do-block returned a bare value before it could infer the monadic type. Wrap the value in pure()."
-                ) from None
-            return e.value
+            raise ValueError(
+                "Returning before `@` is not allowed. "
+                "Use `return @MonadType.pure(value)` instead."
+            ) from None
 
         def recurse(v):
             nonlocal m
@@ -76,7 +74,13 @@ def do(f):
 
             bind_gen = vget(m, "bind_gen")
         except AttributeError:
-            return vget(m, "bind_once")(recurse)
+            try:
+                return vget(m, "bind_once")(recurse)
+            except AttributeError:
+                # Fallback to Result if m is not a monadic type
+                from . import __tl__
+
+                bind_gen = __tl__.Result(m).bind_gen
 
         return bind_gen(gen)
 

{koatl-0.1.28 → koatl-0.1.30/koatl}/python/koatl/runtime/record.py

@@ -1,4 +1,5 @@
 import re
+from .virtual import vget
 
 __all__ = ["Record"]
 
@@ -11,9 +12,7 @@ class Record(dict):
         try:
             return self[name]
         except KeyError:
-            raise AttributeError(
-                f"'{type(self).__name__}' object has no attribute '{name}'"
-            ) from None
+            return super().__getattr__(name)
 
     def _repr_with_visited(self, visited):
         # Handle cycles by checking if this object is already being processed
@@ -46,9 +45,11 @@ class Record(dict):
             visited.remove(obj_id)
 
     def _format_key(self, key):
-        if isinstance(key, str) and self._is_identifier(key):
-            # If key is an identifier, drop the quotes
-            return 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

{koatl-0.1.28 → koatl-0.1.30}/koatl/python/koatl/runtime/virtual.py

@@ -14,12 +14,12 @@ def vget(obj, name, ignore_traits=False):
                 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)
+                    return iter(count(start, step))
                 else:
-                    return range(start, obj.stop, step)
+                    return iter(range(start, obj.stop, step))
 
             try:
-                return obj.items()
+                return iter(obj.items())
             except AttributeError:
                 pass
 

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

@@ -496,19 +496,23 @@ trait PyLiteralExt<'src> {
 impl<'src> PyLiteralExt<'src> for PyLiteral<'src> {
     fn emit_py<'py>(&self, ctx: &PyCtx<'py, 'src>, span: &Span) -> PyTlResult<PyObject> {
         Ok(match self {
-            PyLiteral::Num(num) => match num.parse::<i128>() {
-                Ok(i) => ctx.ast_node("Constant", (i,), span)?,
-                Err(_) => match num.parse::<f64>() {
-                    Ok(f) => ctx.ast_node("Constant", (f,), span)?,
-                    Err(_) => {
-                        return Err(PyTlErr {
-                            message: format!("Invalid number literal: {}", num),
-                            py_err: None,
-                            span: Some(*span),
-                        })
-                    }
-                },
-            },
+            PyLiteral::Num(num) => {
+                let num = num.replace('_', "");
+
+                match num.parse::<i128>() {
+                    Ok(i) => ctx.ast_node("Constant", (i,), span)?,
+                    Err(_) => match num.parse::<f64>() {
+                        Ok(f) => ctx.ast_node("Constant", (f,), span)?,
+                        Err(_) => {
+                            return Err(PyTlErr {
+                                message: format!("Invalid number literal: {}", num),
+                                py_err: None,
+                                span: Some(*span),
+                            });
+                        }
+                    },
+                }
+            }
             PyLiteral::Bool(b) => ctx.ast_node("Constant", (b,), span)?,
             PyLiteral::Str(s) => ctx.ast_node("Constant", (s,), span)?,
             PyLiteral::None => ctx.ast_node("Constant", (ctx.py.None(),), span)?,

{koatl-0.1.28 → koatl-0.1.30}/koatl/tests/e2e/prelude/iterables.tl

@@ -18,4 +18,14 @@ assert_eq(
 assert_eq(
     {1: 2}.map([k, v] => [v, k]).record(),
     {2: 1}
+)
+
+assert_eq(
+    (..3).associate($ + 2)
+    {0: 2, 1: 3, 2: 4}
+)
+
+assert_eq(
+    (..6).group_by($ < 2)
+    {False: [2, 3, 4, 5], True: [0, 1]}
 )

koatl-0.1.30/koatl/tests/e2e/prelude/list.tl

@@ -0,0 +1,47 @@
+import util.assert_eq
+import time
+
+# Async traversal must be concurrent.
+
+now = time.time()
+
+assert_eq(
+    (..10).traverse(x =>
+        @Async.sleep(0.1)
+        x
+    ).run()
+    (..10).list()
+)
+
+assert_eq(time.time() - now < 0.3, True)
+
+# Result traversal must short-circuit.
+
+# Bare Result traversal should not be wrapped in Ok.
+
+assert_eq(
+    [1, 2, 3].traverse(x => x + 1)
+    [2, 3, 4]
+)
+
+counts = 0
+assert_eq(
+    (..20).traverse(x =>
+        counts += 1
+        if x == 10:
+            return Err()
+        Ok(x)
+    )
+    Err()
+)
+assert_eq(counts, 11)
+
+counts = 0
+assert_eq(
+    (..10).traverse(x =>
+        counts += 1
+        Ok(x)
+    )
+    (..10).map(Ok).list()
+)
+assert_eq(counts, 10)

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

@@ -4,7 +4,7 @@ counts = 0
 
 fib = Memo.fn& x =>
     if x < 2:
-        return Memo.pure(1)
+        return @Memo.pure(1)
 
     counts = counts + 1