koatl 0.1.24__tar.gz → 0.1.26__tar.gz

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

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

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

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

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

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

{koatl-0.1.24 → koatl-0.1.26}/koatl/python/koatl/prelude/functional/__init__.tl

@@ -1,4 +1,4 @@
-export import .monad.*
+export import .algebra.*
 export import .result.*
 export import .async.*
 export import .reader.*

koatl-0.1.26/koatl/python/koatl/prelude/functional/algebra.tl

@@ -0,0 +1,46 @@
+import abc
+
+export Monad = class(abc.ABC):
+    """
+    Abstract base class for monads.
+
+    Subclasses must implement `bind` and `pure`.
+    Automatically provides standard monadic operations: bind_once, map, and apply.
+    """
+    __slots__ = ()
+
+    bind = abc.abstractmethod& (self, f) => None
+
+    pure = staticmethod& abc.abstractmethod& 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):
+    """
+    Abstract base class for single-use monads.
+
+    A MonadOnce can only be bound 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.
+    """
+    __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
+
+    # An optional, optimized implementation of `bind` that skips deep recursion.
+    # TODO: can this be automatically generated from bind_once?
+    # bind_gen = (self, gen) => ...
+
+    # 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)))

{koatl-0.1.24 → koatl-0.1.26}/koatl/python/koatl/prelude/functional/async.tl

@@ -2,9 +2,9 @@ import functools.wraps
 import asyncio
 
 import .async_util
-import .monad.Monad
+import .MonadOnce
 
-export Async = class(Monad):
+export Async = class(MonadOnce):
     __init__ = (self, awaitable) => self.generator = awaitable.__await__()
 
     __await__ = self => self.generator
@@ -39,5 +39,5 @@ export Async = class(Monad):
 
     sleep = staticmethod& x => Async(asyncio.sleep(x))
 
-    #- TODO: Why is asyncio.gather eager? -#
+    # TODO: Why is asyncio.gather eager?
     gather = staticmethod& (*args) => Async.from_generator_fn& () => yield from asyncio.gather(*args)

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

@@ -1,7 +1,7 @@
 import collections.UserList
 import itertools
 
-import .monad.Monad
+import .Monad
 import ..iterable.Iterable
 
 export List = class(UserList, Monad):

{koatl-0.1.24 → koatl-0.1.26}/koatl/python/koatl/prelude/functional/memo.tl

@@ -1,18 +1,16 @@
 import collections.defaultdict
 import functools.wraps
 import .result.(Result, Ok)
-import .Monad
+import .MonadOnce
 
-export Memo = class(Monad):
+export Memo = class(MonadOnce):
     Cache = class:
         __init__ = self =>
             self.cache = defaultdict(dict)
 
         __repr__ = self => f"Memo.Cache({self.cache})"
 
-        try_get = (self, name, deps) =>
-            # TODO should try operator return a Result directly?
-            Result(try self.cache[name][deps] except KeyError())
+        try_get = (self, name, deps) => try self.cache[name][deps] except KeyError()
 
         update = (self, name, deps, value) =>
             self.cache[name][deps] = value
@@ -22,6 +20,17 @@ export Memo = class(Monad):
 
     __repr__ = self => f"Memo(...)"
 
+    # This needs to be special cased because if we try to use Memo.value
+    # directly, the *generator* itself gets memoized. We want to memoize
+    # the thing that that comes out of the generator.
+    bind_value = staticmethod& (id, deps, f) =>
+        Memo(ctx =>
+            if ctx.try_get(id, tuple(deps)) matches Ok(value):
+                return value
+
+            ctx.update(id, tuple(deps), f().f(ctx))
+        )
+
     value = staticmethod& (id, deps, f) =>
         Memo(ctx =>
             if ctx.try_get(id, tuple(deps)) matches Ok(value):
@@ -40,7 +49,7 @@ export Memo = class(Monad):
 
             let v = f(*args, **kwargs)
             if v matches Memo():
-                v = v.run(ctx)
+                v = v.f(ctx)
 
             ctx.update(id, deps, v)
         )
@@ -53,21 +62,22 @@ export Memo = class(Monad):
     pure = staticmethod& value => Memo(ctx => value)
 
     bind_once = (self, f) => Memo(ctx =>
-        let value = f(self.run(ctx))
+        let value = f(self.f(ctx))
         if value matches Memo():
-            value = value.run(ctx)
+            value = value.f(ctx)
         value
     )
 
     bind_gen = (self, gen) => Memo(ctx =>
-        self = self.run(ctx)
+        self = self.f(ctx)
         try:
             while True:
                 self = gen.send(self)
                 if self matches Memo():
-                    self = self.run(ctx)
+                    self = self.f(ctx)
         except StopIteration(value=value):
             return value
     )
 
-__tl__.memo = Memo.value
+__tl__.memo_value = Memo.value
+__tl__.bind_memo_value = Memo.bind_value

{koatl-0.1.24 → koatl-0.1.26/koatl}/python/koatl/prelude/functional/reader.tl

@@ -1,7 +1,7 @@
 import functools.wraps
-import .monad.Monad
+import .MonadOnce
 
-export Reader = class(Monad):
+export Reader = class(MonadOnce):
     __init__ = (self, fn) => self.fn = fn
 
     __repr__ = self => "Reader(...)"

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

@@ -1,8 +1,8 @@
 import functools.wraps
-import .monad.Monad
 import koatl.runtime.virtual.register_global_attr
+import .algebra.MonadOnce
 
-export Result = class:
+export Result = class(MonadOnce):
     __slots__ = ()
     __match_args__ = ("value",)
 
@@ -14,24 +14,15 @@ export Result = class:
     __init__ = (self, *args, **kwargs) =>
         raise ValueError("Result should not be instantiated directly, use Ok or Err")
 
-    raw = self =>
+    checked = staticmethod& f =>
         """
-        Unwraps the value from a Result, making it look like
-        a non-monadic Python value.
+        Runs the function in a try block and returns a Result.
+        If the function raises an exception, it will be wrapped in an Err.
         """
-        if self matches not Result():
-            return self
-
-        if self.ok:
-            if self.value.ok:
-                return self.value
-            else:
-                return self
-        else:
-            if self.value.ok:
-                return self
-            else:
-                return self.value
+        try:
+            return Ok(f())
+        except BaseException() as e:
+            return Err(e)
 
     bind_once = (self, f) =>
         self = Result(self)
@@ -96,8 +87,14 @@ export Ok = class(Result):
             return None
         self.value = value
 
+    __eq__ = (self, other) =>
+        if not isinstance(other, Ok):
+            return False
+        return self.value == other.value
+
     __repr__ = self => f"Ok({repr(self.value)})"
     unwrap = self => self.value
+    coalesce = (self, f) => self.value
 
 export Err = class(Result):
     __slots__ = ("value",)
@@ -108,24 +105,43 @@ export Err = class(Result):
             return None
         self.value = value
 
+    __eq__ = (self, other) =>
+        if not isinstance(other, Err):
+            return False
+        return self.value == other.value
+
     __repr__ = self => f"Err({repr(self.value)})"
     unwrap = self =>
         if self.value matches BaseException():
             raise self.value
         raise ValueError(f"Expected Ok, got {repr(self.value)}")
+    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))
+
+register_global_attr(object, "result", ExtensionProperty(Result))
+
+# Enables @ operator for bare objects.
+register_global_attr(object, "bind_gen", Result.bind_gen)
 
+__tl__.Ok = Ok
+__tl__.Err = Err
 
-# Provide a default implementation for *most* Result methods
-# ...we shouldn't provide a default for `map` since that
-# would prevent virtual trait lookup. TODO: fix this?
-for name, method in Result.__dict__:
-    if name.startswith("_"):
-        continue
-    if name == "map":
-        continue
+__tl__.op_coal = (x, f) =>
+    if x matches Result():
+        return x.coalesce(f)
 
-    let make_closure = method => (self, *args, **kwargs) => Result.raw(method(self, *args, **kwargs))
+    if not x.ok:
+        return f()
+    return x
 
-    register_global_attr(object, name, make_closure(method))
+__tl__.op_map = (x, f) =>
+    if x matches Result():
+        return x.map(f)
 
-register_global_attr(object, "ok", ExtensionProperty(__tl__.ok))
+    if x.ok:
+        return f(x)
+    return x

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

@@ -21,13 +21,13 @@ methods = {
         if not hasattr(m, "apply"):
             # special case for bare types - slightly more efficient
             # ...also required since bare types don't have .map
-            if not __tl__.ok(m):
+            if not m.ok:
                 return m
 
             let acc = [m]
             for v in it:
                 let fv = f(v)
-                if not __tl__.ok(fv):
+                if not fv.ok:
                     return fv
                 acc.append(fv)
             return acc

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

@@ -21,10 +21,13 @@ from .record import *
 from .helpers import *
 
 
-def dummy_memo(*args, **kwargs):
-    raise RuntimeError(
-        "memo is not available without the prelude. Please import koatl.prelude."
-    )
+def dummy(name):
+    def wrapper(*args, **kwargs):
+        raise RuntimeError(
+            f"{name} is not available without the prelude. Please import koatl.prelude."
+        )
+
+    return wrapper
 
 
 __tl__ = SimpleNamespace(
@@ -32,15 +35,21 @@ __tl__ = SimpleNamespace(
     slice=slice,
     vget=virtual.vget,
     vhas=virtual.vhas,
-    memo=dummy_memo,
     unpack_record=helpers.unpack_record,
     set_exports=helpers.set_exports,
     do=helpers.do,
-    ok=helpers.ok,
     partial=functools.partial,
+    # These require more complex logic and require the prelude.
+    # The runtime provides dummy implementations that raise if used without the prelude.
+    memo_value=dummy("memo"),
+    bind_memo_value=dummy("memo"),
+    op_map=dummy("?"),
+    op_coal=("??"),
+    Ok=dummy("try-expr"),
+    Err=dummy("try-expr"),
     **{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: virtual.__dict__[name] for name in virtual.__all__},
 )
 
 

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

@@ -66,6 +66,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
 
         def recurse(v):
@@ -74,17 +78,16 @@ def do(f):
                 m = gen.send(v)
                 return vget(m, "bind_once")(recurse)
             except StopIteration as e:
-                try:
-                    return vget(m, "pure")(e.value)
-                except AttributeError:
-                    return e.value
+                return vget(m, "pure")(e.value)
 
         try:
             # TODO: this is a workaround to avoid recursion.
             # is it possible to derive bind_gen directly from bind_once?
 
-            return vget(m, "bind_gen")(gen)
-        except (NotImplementedError, AttributeError):
+            bind_gen = vget(m, "bind_gen")
+        except AttributeError:
             return vget(m, "bind_once")(recurse)
 
+        return bind_gen(gen)
+
     return impl

{koatl-0.1.24 → koatl-0.1.26}/koatl/python/koatl/runtime/virtual.py

@@ -1,3 +1,4 @@
+import abc
 from functools import partial
 from itertools import count
 from types import new_class
@@ -105,7 +106,7 @@ def Trait(module, name, methods, *, requires=[]):
 
     meta = type(
         f"{name}Meta",
-        (type,),
+        (abc.ABCMeta,),
         {"__instancecheck__": instancecheck, "__module__": "types"},
     )
 

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

@@ -17,15 +17,3 @@ assert_eq(1?.($ + 1)(), 2)
 
 assert_eq(None ?? 1, 1)
 assert_eq(int(5) ?? 1, 5)
-
-
-# try exprs
-
-assert_eq(type(try x), NameError)
-assert_eq(type(try int(1)[1]), TypeError)
-assert_eq(type(try [0][5]), IndexError)
-assert_eq(try 5, 5)
-
-
-assert_eq((try 5)?.($+1)?(), 6)
-assert_eq(type((try x)?.($+1)?()), NameError)

koatl-0.1.26/koatl/tests/e2e/base/loops.tl

@@ -0,0 +1,25 @@
+import util.assert_eq
+
+x = []
+for i in [1, 2, 3]:
+    x = [*x, i]
+
+assert_eq(x, [1, 2, 3])
+
+i = True
+while (x => x)(i):
+    if i === False:
+        assert False
+
+    i = False
+
+counts = []
+counter = 0
+while (
+    counter = counter + 1
+    counter < 5
+):
+    counts.append(counter)
+
+assert_eq(counter, 5)
+assert_eq(counts, [1, 2, 3, 4])

{koatl-0.1.24 → koatl-0.1.26}/koatl/tests/e2e/base/match.tl

@@ -73,8 +73,6 @@ x = 1
 assert_eq([1, 2, 3] matches [1, 2, 3], True)
 assert_eq([1, 2, 3] matches [.x, _, 3], True)
 
-assert_eq(try 1 matches 1, True)
-
 f = () =>
     if [1, 2, 3] matches [1, 2, x]:
         assert_eq(x, 3)

koatl-0.1.26/koatl/tests/e2e/base/short_circuit.tl

@@ -0,0 +1,42 @@
+import util.assert_eq
+
+assert_eq(
+    True and False
+    False
+)
+
+# No short-circuiting here.
+
+flag = 0
+assert_eq(
+    True and (
+        flag = 1
+        True
+    )
+    True
+)
+assert_eq(flag, 1)
+
+# This needs to short-circuit.
+
+flag = 0
+assert_eq(
+    False and (
+        flag = 1
+        True
+    )
+    False
+)
+assert_eq(flag, 0)
+
+# Same with or
+
+flag = 0
+assert_eq(
+    True or (
+        flag = 1
+        True
+    )
+    True
+)
+assert_eq(flag, 0)

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

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

{koatl-0.1.24/koatl/tests/e2e/base → koatl-0.1.26/koatl/tests/e2e/prelude}/try.tl

@@ -3,12 +3,14 @@ import util.assert_eq
 # precedence
 assert_eq(try 1 ?? 2, 1)
 assert_eq(try z ?? 2, 2)
-assert_eq(type(try z), NameError)
+assert_eq(try z matches Err(), True)
+assert_eq((try z).value matches NameError(), True)
 assert_eq(try z ?? try 1 ?? 2, 1)
-assert_eq(try z ?? try None ?? 2, 2)
+assert_eq(try z ?? try None ?? 2, None)
+assert_eq(try z ?? Err(None) ?? 2, 2)
 
 err_type = NameError
-assert_eq(type(try a except err_type()), err_type)
+assert_eq(try a except err_type() matches Err(), True)
 
 # handlers
 assert_eq(try 1 except ValueError() ?? 2, 1)
@@ -19,4 +21,9 @@ try:
     try a except (ValueError() | StopIteration())
     assert False
 except:
-    None
+    None
+
+assert_eq(try 1 matches Ok(1), True)
+
+assert_eq((try 5)?.($+1)?(), Ok(6))
+assert_eq((try x)?.($+1)?() matches Err(), True)

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

@@ -30,7 +30,7 @@ impl<T> IntoIndirect<T> for T {
     }
 }
 
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum BinaryOp {
     Add,
     Sub,

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

@@ -210,7 +210,6 @@ where
             if items.len() == 1 && last_comma.is_none() {
                 let item = items.into_iter().next().unwrap();
                 if let PatternSequenceItem::Item(inner) = item {
-                    // TODO ???
                     inner.extract()
                 } else {
                     Pattern::Sequence(vec![item]).spanned(e.span())

{koatl-0.1.24 → koatl-0.1.26}/koatl-core/src/py/emit.rs

@@ -456,21 +456,18 @@ impl SPyExpr<'_> {
                 ctx.emit("]");
             }
             PyExpr::Yield(expr) => {
-                set_prec(-0.5);
                 ctx.emit("(");
                 ctx.emit("yield ");
                 expr.emit_to(ctx, LOW_PREC)?;
                 ctx.emit(")");
             }
             PyExpr::Await(expr) => {
-                set_prec(-0.5);
-                ctx.emit_indent();
+                ctx.emit("(");
                 ctx.emit("await ");
                 expr.emit_to(ctx, LOW_PREC)?;
-                ctx.emit_endl();
+                ctx.emit(")");
             }
             PyExpr::YieldFrom(expr) => {
-                set_prec(-0.5); // TODO is this precedence correct?
                 ctx.emit("(");
                 ctx.emit("yield from ");
                 expr.emit_to(ctx, LOW_PREC)?;
@@ -511,7 +508,6 @@ impl SPyExpr<'_> {
                 }
             }
             PyExpr::IfExpr(cond, if_, else_) => {
-                // TODO precedence here?
                 ctx.emit("(");
                 if_.emit_to(ctx, LOW_PREC)?;
                 ctx.emit(" if ");