koatl 0.1.24__tar.gz → 0.1.25__tar.gz

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

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

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

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

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

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

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

@@ -22,6 +22,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 +51,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 +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.24 → koatl-0.1.25/koatl}/python/koatl/prelude/functional/monad.tl

@@ -1,5 +1,6 @@
 import abc
 
+# TODO: this should be really called MonadOnce.
 export Monad = class(abc.ABC):
     __slots__ = ()
 
@@ -13,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.24 → koatl-0.1.25/koatl}/python/koatl/prelude/functional/result.tl

@@ -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.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.24 → 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.24 → koatl-0.1.25}/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.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.24 → 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.24 → 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.24/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.24 → 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,

{koatl-0.1.24 → koatl-0.1.25}/koatl-core/src/resolve_scopes.rs

@@ -36,9 +36,20 @@ pub struct ResolveState<'src> {
     pub export_stars: Vec<SIdent<'src>>,
 
     pub resolutions: HashMap<RefHash, DeclarationKey>,
-    pub functions: HashMap<RefHash, FnInfo>,
     pub patterns: HashMap<RefHash, PatternInfo>,
-    pub memo_captures: HashMap<RefHash, FnInfo>,
+
+    // TODO: these should all be collapsed into the same thing...
+    pub functions: HashMap<RefHash, FnInfo>,
+    pub memo_fninfo: HashMap<RefHash, FnInfo>,
+    // ...but before that, mapped_fninfo needs to be fixed.
+    // CallItems and ListItems nodes inside MappedCall and MappedSubscript
+    // are not boxed, so I've been pointing to the upper-level MappedX nodes
+    // instead, but that will cause a conflict with memo_fninfo, specifically
+    // "memo a?.x" will try to use the same refhash for both.
+    // So, is it safe to just point to the reference of the bare CallItem/ListItem?
+    // Or do we just box it?
+    pub mapped_fninfo: HashMap<RefHash, FnInfo>,
+    pub coal_fninfo: HashMap<RefHash, FnInfo>,
 
     pub declarations: SlotMap<DeclarationKey, Declaration<'src>>,
     pub scopes: SlotMap<ScopeKey, Scope>,
@@ -88,7 +99,9 @@ impl<'src> ResolveState<'src> {
             resolutions: HashMap::new(),
             functions: HashMap::new(),
             patterns: HashMap::new(),
-            memo_captures: HashMap::new(),
+            memo_fninfo: HashMap::new(),
+            mapped_fninfo: HashMap::new(),
+            coal_fninfo: HashMap::new(),
 
             declarations: SlotMap::with_key(),
             scopes,
@@ -388,6 +401,7 @@ pub struct FnInfo {
     pub is_generator: bool,
     pub is_placeholder: bool,
     pub is_memo: bool,
+    pub is_mapped_rhs: bool,
 
     pub arg_names: Vec<DeclarationKey>,
     pub captures: HashSet<DeclarationKey>,
@@ -401,6 +415,7 @@ impl FnInfo {
             is_generator: false,
             is_placeholder: false,
             is_memo: false,
+            is_mapped_rhs: false,
             arg_names: Vec::new(),
             captures: HashSet::new(),
         }
@@ -836,6 +851,31 @@ fn pattern_scoped<'src>(
     (pattern, scope_key, meta)
 }
 
+fn with_phantom_fninfo<'src, F, O>(state: &mut ResolveState<'src>, span: Span, f: F) -> (O, FnInfo)
+where
+    F: FnOnce(&mut ResolveState<'src>) -> O,
+{
+    let fn_ctx = FnInfo::new();
+
+    state.fn_stack.push(fn_ctx);
+
+    let ret = f(state);
+
+    let fn_ctx = state.fn_stack.pop().unwrap();
+
+    if fn_ctx.is_async {
+        state.set_async(span);
+    }
+    if fn_ctx.is_generator {
+        state.set_generator(span);
+    }
+    if fn_ctx.is_do {
+        state.set_do(span);
+    }
+
+    (ret, fn_ctx)
+}
+
 trait SExprExt<'src> {
     fn traverse(self, state: &mut ResolveState<'src>) -> Indirect<SExpr<'src>>;
     fn traverse_expecting_scope(self, state: &mut ResolveState<'src>) -> Indirect<SExpr<'src>>;
@@ -1239,42 +1279,99 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
             ),
 
             // special case for pipe
-            Expr::Binary(binary_op, mut x, mut y) => {
-                if let BinaryOp::Pipe = binary_op {
-                    x = x.traverse_guarded(state);
-                    y = y.traverse_guarded(state);
-                } else {
-                    x = x.traverse(state);
-                    y = y.traverse(state);
-                }
+            Expr::Binary(binary_op, x, y) => {
+                let (x, y) = match binary_op {
+                    BinaryOp::Pipe => (x.traverse_guarded(state), y.traverse_guarded(state)),
+                    BinaryOp::Coalesce => {
+                        let (y, fn_ctx) =
+                            with_phantom_fninfo(state, span, |state| y.traverse(state));
+
+                        state.coal_fninfo.insert(y.as_ref().into(), fn_ctx);
+
+                        (x.traverse(state), y)
+                    }
+                    _ => (x.traverse(state), y.traverse(state)),
+                };
 
                 Expr::Binary(binary_op, x, y)
             }
 
             // postfix
             Expr::Attribute(expr, attr) => Expr::Attribute(expr.traverse(state), attr.clone()),
-            Expr::MappedAttribute(expr, attr) => Expr::MappedAttribute(expr.traverse(state), attr),
+            Expr::MappedAttribute(expr, attr) => {
+                let traversed = Expr::MappedAttribute(expr.traverse(state), attr)
+                    .spanned(span)
+                    .indirect();
+
+                state
+                    .mapped_fninfo
+                    .insert(traversed.as_ref().into(), FnInfo::new());
+
+                return traversed;
+            }
             Expr::RawAttribute(expr, attr) => Expr::RawAttribute(expr.traverse(state), attr),
             Expr::MappedRawAttribute(expr, spanned) => {
-                Expr::MappedRawAttribute(expr.traverse(state), spanned)
+                let traversed = Expr::MappedRawAttribute(expr.traverse(state), spanned)
+                    .spanned(span)
+                    .indirect();
+
+                state
+                    .mapped_fninfo
+                    .insert(traversed.as_ref().into(), FnInfo::new());
+
+                return traversed;
             }
             Expr::ScopedAttribute(expr, value) => {
                 Expr::ScopedAttribute(expr.traverse(state), value.traverse_guarded(state))
             }
             Expr::MappedScopedAttribute(expr, value) => {
-                Expr::MappedScopedAttribute(expr.traverse(state), value.traverse_guarded(state))
+                let (rhs, fn_ctx) =
+                    with_phantom_fninfo(state, span, |state| value.traverse_guarded(state));
+
+                let traversed = Expr::MappedScopedAttribute(expr.traverse(state), rhs)
+                    .spanned(span)
+                    .indirect();
+
+                state
+                    .mapped_fninfo
+                    .insert(traversed.as_ref().into(), fn_ctx);
+
+                return traversed;
             }
             Expr::Call(a, items) => {
                 Expr::Call(a.traverse(state), traverse_call_items(state, items))
             }
             Expr::MappedCall(a, call_items) => {
-                Expr::MappedCall(a.traverse(state), traverse_call_items(state, call_items))
+                let (rhs, fn_ctx) = with_phantom_fninfo(state, span, |state| {
+                    traverse_call_items(state, call_items)
+                });
+
+                let traversed = Expr::MappedCall(a.traverse(state), rhs)
+                    .spanned(span)
+                    .indirect();
+
+                state
+                    .mapped_fninfo
+                    .insert(traversed.as_ref().into(), fn_ctx);
+
+                return traversed;
             }
             Expr::Subscript(x, list_items) => {
                 Expr::Subscript(x.traverse(state), traverse_list_items(state, list_items))
             }
             Expr::MappedSubscript(expr, list_items) => {
-                Expr::MappedSubscript(expr.traverse(state), traverse_list_items(state, list_items))
+                let (rhs, fn_ctx) = with_phantom_fninfo(state, span, |state| {
+                    traverse_list_items(state, list_items)
+                });
+                let traversed = Expr::MappedSubscript(expr.traverse(state), rhs)
+                    .spanned(span)
+                    .indirect();
+
+                state
+                    .mapped_fninfo
+                    .insert(traversed.as_ref().into(), fn_ctx);
+
+                return traversed;
             }
             Expr::Tuple(items) => Expr::Tuple(traverse_list_items(state, items)),
             Expr::List(items) => Expr::List(traverse_list_items(state, items)),
@@ -1305,29 +1402,27 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
             Expr::Memo(inner) => {
                 state.set_do(span);
 
-                let mut fn_ctx = FnInfo::new();
-                fn_ctx.is_memo = true;
-
                 let mut scope = Scope::new(state.top_scope_key());
-                scope.is_fn = true;
-
                 // TODO it's confusing that we need to
                 // set scope.is_fn = true all the time in order
                 // for captures to be found properly.
                 // is there any better way?
-
+                scope.is_fn = true;
                 let scope = state.scopes.insert(scope);
-                state.fn_stack.push(fn_ctx);
 
-                let scoped = state.scoped(scope, |state| {
-                    state.placeholder_guarded(span, |state| inner.traverse_expecting_scope(state))
+                let (inner, mut fn_ctx) = with_phantom_fninfo(state, span, |state| {
+                    state
+                        .scoped(scope, |state| {
+                            state.placeholder_guarded(span, |state| {
+                                inner.traverse_expecting_scope(state)
+                            })
+                        })
+                        .value
                 });
 
-                let inner = scoped.value;
-
-                let fn_ctx = state.fn_stack.pop().unwrap();
+                fn_ctx.is_memo = true;
 
-                state.memo_captures.insert(inner.as_ref().into(), fn_ctx);
+                state.memo_fninfo.insert(inner.as_ref().into(), fn_ctx);
 
                 Expr::Memo(inner)
             }