koatl 0.1.23__tar.gz → 0.1.25__tar.gz

{koatl-0.1.23 → koatl-0.1.25}/Cargo.lock

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

{koatl-0.1.23 → koatl-0.1.25}/PKG-INFO

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

{koatl-0.1.23 → koatl-0.1.25}/koatl/Cargo.toml

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

{koatl-0.1.23 → koatl-0.1.25/koatl}/python/koatl/prelude/functional/memo.tl

@@ -1,6 +1,6 @@
 import collections.defaultdict
 import functools.wraps
-import .result.Ok
+import .result.(Result, Ok)
 import .Monad
 
 export Memo = class(Monad):
@@ -11,7 +11,8 @@ export Memo = class(Monad):
         __repr__ = self => f"Memo.Cache({self.cache})"
 
         try_get = (self, name, deps) =>
-            try self.cache[name][deps] except KeyError()
+            # TODO should try operator return a Result directly?
+            Result(try self.cache[name][deps] except KeyError())
 
         update = (self, name, deps, value) =>
             self.cache[name][deps] = value
@@ -21,9 +22,20 @@ 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() as value:
+            if ctx.try_get(id, tuple(deps)) matches Ok(value):
                 return value
 
             ctx.update(id, tuple(deps), f())
@@ -34,12 +46,12 @@ export Memo = class(Monad):
         let deps = (tuple(args), tuple(kwargs.items()))
 
         Memo(ctx =>
-            if ctx.try_get(id, deps) matches Ok() as value:
+            if ctx.try_get(id, deps) matches Ok(value):
                 return value
 
             let v = f(*args, **kwargs)
             if v matches Memo():
-                v = v.run(ctx)
+                v = v.f(ctx)
 
             ctx.update(id, deps, v)
         )
@@ -52,21 +64,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.23 → koatl-0.1.25/koatl}/python/koatl/prelude/functional/monad.tl

@@ -1,6 +1,9 @@
 import abc
 
+# TODO: this should be really called MonadOnce.
 export Monad = class(abc.ABC):
+    __slots__ = ()
+
     # The default implementation required for `@` syntax that should be overridden by subclasses.
     bind_once = abc.abstractmethod& (self, f) => None
 
@@ -11,7 +14,7 @@ export Monad = class(abc.ABC):
 
     # An optional, optimized implementation of `bind` that skips deep recursion.
     # TODO: can this be automatically generated?
-    bind_gen = (self, gen) => raise NotImplementedError()
+    # bind_gen = (self, gen) => ...
 
     # Automatically generated implementations.
     map = (self, f) => self.bind(x => self.pure(f(x)))

koatl-0.1.25/koatl/python/koatl/prelude/functional/result.tl

@@ -0,0 +1,147 @@
+import functools.wraps
+import .monad.Monad
+import koatl.runtime.virtual.register_global_attr
+
+export Result = class:
+    __slots__ = ()
+    __match_args__ = ("value",)
+
+    __new__ = (cls, value) =>
+        if isinstance(value, Result):
+            return value
+        value.ok then Ok(value) else Err(value)
+
+    __init__ = (self, *args, **kwargs) =>
+        raise ValueError("Result should not be instantiated directly, use Ok or Err")
+
+    checked = staticmethod& f =>
+        """
+        Runs the function in a try block and returns a Result.
+        If the function raises an exception, it will be wrapped in an Err.
+        """
+        try:
+            return Ok(f())
+        except BaseException() as e:
+            return Err(e)
+
+    bind_once = (self, f) =>
+        self = Result(self)
+        if not self.ok:
+            return self
+
+        let v = Result(f(self.value))
+
+    bind = bind_once
+
+    bind_gen = (self, gen) =>
+        self = Result(self)
+        try:
+            while True:
+                if not self.ok:
+                    return self
+
+                self = Result(gen.send(self.value))
+        except StopIteration(value=value):
+            return Result.pure(value)
+
+    pure = staticmethod& x => Ok(x)
+
+    apply = (self, f) =>
+        self = Result(self)
+        f = Result(f)
+
+        if not self.ok:
+            return self
+        if not f.ok:
+            return f
+
+        Ok(f(self))
+
+    map = (self, f) =>
+        self = Result(self)
+        if self.ok:
+            return Ok(f(self.value))
+        return self
+
+    map_err = (self, f) =>
+        self = Result(self)
+        if not self.ok:
+            return Err(f(self.value))
+        return self
+
+    map_none = (self, f) =>
+        self = Result(self)
+        if not self.ok and self.value === None:
+            return Err(f())
+        return self
+
+export Ok = class(Result):
+    __slots__ = ("value",)
+    ok = True
+    __new__ = (cls, value) => object.__new__(cls)
+    __init__ = (self, value) =>
+        if hasattr(self, "value"):
+            # This is necessary to prevent overwriting the value
+            # since Python's Result.__new__ will call Ok.__init__ again
+            # if the object is already created.
+            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",)
+    ok = False
+    __new__ = (cls, value) => object.__new__(cls)
+    __init__ = (self, value) =>
+        if hasattr(self, "value"):
+            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
+
+__tl__.op_coal = (x, f) =>
+    if x matches Result():
+        return x.coalesce(f)
+
+    if not x.ok:
+        return f()
+    return x
+
+__tl__.op_map = (x, f) =>
+    if x matches Result():
+        return x.map(f)
+
+    if x.ok:
+        return f(x)
+    return x

{koatl-0.1.23 → koatl-0.1.25}/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.23 → koatl-0.1.25/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.23 → koatl-0.1.25/koatl}/python/koatl/runtime/helpers.py

@@ -46,6 +46,11 @@ def unpack_record(obj):
 
 
 def ok(obj):
+    try:
+        return obj.ok
+    except AttributeError:
+        pass
+
     if obj is None:
         return False
     if isinstance(obj, BaseException):
@@ -61,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):
@@ -69,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.23 → koatl-0.1.25}/koatl/src/emit_py.rs

@@ -502,7 +502,7 @@ impl<'src> PyExprExt<'src> for SPyExpr<'src> {
                 ctx.ast_node("Name", (ident, c.emit_py(ctx)?), &self.tl_span)?
             }
             PyExpr::Binary(op, left, right) => {
-                let py_op_str = match op {
+                let py_bin_op = match op {
                     PyBinaryOp::Add => Some("Add"),
                     PyBinaryOp::Sub => Some("Sub"),
                     PyBinaryOp::Mult => Some("Mult"),
@@ -512,18 +512,35 @@ impl<'src> PyExprExt<'src> for SPyExpr<'src> {
                     _ => None,
                 };
 
-                if let Some(py_op_str) = py_op_str {
+                if let Some(py_bin_op) = py_bin_op {
                     return ctx.ast_node(
                         "BinOp",
                         (
                             left.emit_py(ctx)?,
-                            ctx.ast_cls(py_op_str, ())?,
+                            ctx.ast_cls(py_bin_op, ())?,
                             right.emit_py(ctx)?,
                         ),
                         &self.tl_span,
                     );
                 }
 
+                let py_bool_op = match op {
+                    PyBinaryOp::And => Some("And"),
+                    PyBinaryOp::Or => Some("Or"),
+                    _ => None,
+                };
+
+                if let Some(py_bool_op) = py_bool_op {
+                    return ctx.ast_node(
+                        "BoolOp",
+                        (
+                            ctx.ast_cls(py_bool_op, ())?,
+                            [left.emit_py(ctx)?, right.emit_py(ctx)?],
+                        ),
+                        &self.tl_span,
+                    );
+                }
+
                 let py_cmp_op = match op {
                     PyBinaryOp::Lt => Some("Lt"),
                     PyBinaryOp::Gt => Some("Gt"),

{koatl-0.1.23 → koatl-0.1.25}/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.25/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.23 → koatl-0.1.25}/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.25/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.23 → koatl-0.1.25}/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.23/koatl/tests/e2e/base → koatl-0.1.25/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.23 → koatl-0.1.25}/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,