koatl 0.1.21__tar.gz → 0.1.22__tar.gz

{koatl-0.1.21 → koatl-0.1.22}/Cargo.lock

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

{koatl-0.1.21 → koatl-0.1.22}/PKG-INFO

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

{koatl-0.1.21 → koatl-0.1.22}/koatl/Cargo.toml

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

{koatl-0.1.21 → koatl-0.1.22}/koatl/python/koatl/runtime/helpers.py

@@ -76,7 +76,7 @@ def do(f):
 
         try:
             # TODO: this is a workaround to avoid recursion.
-            # is it possible to get bind_gen directly from bind_once?
+            # is it possible to derive bind_gen directly from bind_once?
 
             return vget(m, "bind_gen")(gen)
         except (NotImplementedError, AttributeError):

{koatl-0.1.21 → koatl-0.1.22}/koatl-core/src/resolve_scopes.rs

@@ -213,13 +213,6 @@ impl<'src> ResolveState<'src> {
         let placeholder_ctx = self.placeholder_stack.pop().unwrap();
 
         if placeholder_ctx.activated {
-            if ph_fn_ctx.is_async || ph_fn_ctx.is_generator || ph_fn_ctx.is_do {
-                self.errors.extend(simple_err(
-                    "Await, bind, and yield are not allowed in placeholder functions",
-                    placeholder_ctx.span,
-                ));
-            }
-
             ph_fn_ctx.is_placeholder = true;
 
             ph_fn_ctx.arg_names.push(placeholder_ctx.arg_decl);
@@ -1323,13 +1316,6 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
 
                 let fn_ctx = state.fn_stack.pop().unwrap();
 
-                if fn_ctx.is_async || fn_ctx.is_generator || fn_ctx.is_do {
-                    state.errors.extend(simple_err(
-                        "Memo expressions cannot be async, generator, or do",
-                        span,
-                    ));
-                }
-
                 state.memo_captures.insert(inner.as_ref().into(), fn_ctx);
 
                 Expr::Memo(inner)

{koatl-0.1.21 → koatl-0.1.22}/koatl-core/src/transform.rs

@@ -15,6 +15,7 @@ use crate::{
 use once_cell::sync::Lazy;
 use parser::ast::*;
 use slotmap::SlotMap;
+use std::hash::{Hash, Hasher};
 
 static PY_KWS: &[&str] = &[
     "and", "as", "assert", "break", "class", "continue", "def", "del", "elif", "else", "except",
@@ -2279,20 +2280,26 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
 
                 let callback = pre.bind(make_fn_exp(
                     ctx,
-                    FnDef::PyFnDef(vec![], py_body, false, false),
+                    FnDef::PyFnDef(vec![], py_body, memo_captures.is_do, memo_captures.is_async),
                     &span,
                 )?);
 
                 let linecol = ctx.line_cache.linecol(span.start);
 
-                a.yield_(a.call(
+                let memo_call = a.call(
                     a.tl_builtin("memo"),
                     vec![
-                        PyCallItem::Arg(
-                            a.str(
-                                format!("{}:{}:{}", ctx.filename, linecol.0, linecol.1)
-                            )
-                        ),
+                        PyCallItem::Arg(a.str(format!(
+                            "{}:{}:{}:{:08x}",
+                            ctx.filename,
+                            linecol.0,
+                            linecol.1,
+                            {
+                                let mut hasher = std::collections::hash_map::DefaultHasher::new();
+                                ctx.source[span.start..span.end].hash(&mut hasher);
+                                hasher.finish() as u32
+                            }
+                        ))),
                         PyCallItem::Arg(
                             a.tuple(
                                 nonlocals
@@ -2304,7 +2311,14 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
                         ),
                         PyCallItem::Arg(callback),
                     ],
-                ))
+                );
+
+                if memo_captures.is_do {
+                    // TODO should we really automatically bind a monadic expression for convenience?
+                    a.yield_(a.yield_(memo_call))
+                } else {
+                    a.yield_(memo_call)
+                }
             }
             Expr::Await(expr) => a.await_(pre.bind(expr.transform(ctx)?)),
             Expr::Yield(expr) => a.yield_(pre.bind(expr.transform(ctx)?)),

{koatl-0.1.21 → koatl-0.1.22}/python/koatl/runtime/helpers.py

@@ -76,7 +76,7 @@ def do(f):
 
         try:
             # TODO: this is a workaround to avoid recursion.
-            # is it possible to get bind_gen directly from bind_once?
+            # is it possible to derive bind_gen directly from bind_once?
 
             return vget(m, "bind_gen")(gen)
         except (NotImplementedError, AttributeError):