koatl 0.1.19__tar.gz → 0.1.20__tar.gz

{koatl-0.1.19 → koatl-0.1.20}/Cargo.lock

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

{koatl-0.1.19 → koatl-0.1.20}/PKG-INFO

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

{koatl-0.1.19 → koatl-0.1.20}/koatl/Cargo.toml

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

koatl-0.1.20/koatl/python/koatl/prelude/functional/memo.tl

@@ -0,0 +1,63 @@
+import collections.defaultdict
+import functools.wraps
+import .result.Ok
+import .Monad
+
+export Memo = class(Monad):
+    Cache = class:
+        __init__ = self =>
+            self.cache = defaultdict(dict)
+
+        get_or_compute = (self, name, deps, f) =>
+            if try self.cache[name][deps] except KeyError() matches (Ok() as v):
+                return v
+
+            let value = f()
+            self.cache[name][deps] = value
+            value
+
+        __repr__ = self => f"Memo.Cache({self.cache})"
+
+    __init__ = (self, f) => self.f = f
+
+    __repr__ = self => f"Memo(...)"
+
+    value = staticmethod& (id, deps, f) =>
+        Memo(ctx => ctx.get_or_compute(id, tuple(deps), f))
+
+    fn = staticmethod& f => wraps(f)& (*args, **kwargs) =>
+        let id = f"{f.__module__}.{f.__qualname__}"
+        let deps = (tuple(args), tuple(kwargs.items()))
+
+        Memo(ctx =>
+            ctx.get_or_compute(id, deps, () =>
+                let v = f(*args, **kwargs)
+                if v matches Memo():
+                    v = v.run(ctx)
+                v
+            )
+        )
+
+    run = (self, ctx=Cache()) => self.f(ctx)
+
+    pure = staticmethod& value => Memo(ctx => value)
+
+    bind_once = (self, f) => Memo(ctx =>
+        let value = f(self.run(ctx))
+        if value matches Memo():
+            value = value.run(ctx)
+        value
+    )
+
+    bind_gen = (self, gen) => Memo(ctx =>
+        self = self.run(ctx)
+        try:
+            while True:
+                self = gen.send(self)
+                if self matches Memo():
+                    self = self.run(ctx)
+        except StopIteration(value=value):
+            return value
+    )
+
+__tl__.memo = Memo.value

{koatl-0.1.19 → koatl-0.1.20}/koatl/tests/e2e/prelude/memo.tl

@@ -23,8 +23,9 @@ f = x =>
         counts = counts + 1
         x * 2
 
-ctx = MemoCtx()
+ctx = Memo.Cache()
 assert_eq(f(10).run(ctx), 20)
 assert_eq(f(10).run(ctx), 20)
 assert_eq(f(5).run(ctx), 10)
+assert_eq(f(5).run(ctx), 10)
 assert_eq(counts, 2)

{koatl-0.1.19 → koatl-0.1.20}/koatl-core/src/resolve_scopes.rs

@@ -1142,17 +1142,18 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
 
                 let mut fn_info = FnInfo::new();
                 for (i, decl) in decls.iter().enumerate() {
-                    if let Some(found) = decls[..i]
-                        .iter()
-                        .find(|x| state.declarations[**x].name == state.declarations[*decl].name)
-                    {
-                        state.errors.extend(
-                            TlErrBuilder::new()
-                                .message("Duplicate declaration in function arguments")
-                                .context("First declared here", state.declarations[*found].loc)
-                                .span(state.declarations[*decl].loc)
-                                .build(),
-                        );
+                    if state.declarations[*decl].name.0 != "_" {
+                        if let Some(found) = decls[..i].iter().find(|x| {
+                            state.declarations[**x].name == state.declarations[*decl].name
+                        }) {
+                            state.errors.extend(
+                                TlErrBuilder::new()
+                                    .message("Duplicate declaration in function arguments")
+                                    .context("First declared here", state.declarations[*found].loc)
+                                    .span(state.declarations[*decl].loc)
+                                    .build(),
+                            );
+                        }
                     }
 
                     fn_info.arg_names.push(*decl);

{koatl-0.1.19 → koatl-0.1.20}/koatl-core/src/transform.rs

@@ -1026,7 +1026,7 @@ fn create_throwing_matcher<'src, 'ast>(
     pattern: &'ast SPattern<'src>,
     pattern_meta: &'ast PatternInfo,
 ) -> TlResult<(PyBlock<'src>, PyIdent<'src>)> {
-    if let Pattern::Capture(Some(_)) = &pattern.value {
+    if let Pattern::Capture(Some(ident)) = &pattern.value {
         if pattern_meta.decls.len() != 1 {
             return Err(simple_err(
                 "Internal: expected exactly one decl",
@@ -1034,8 +1034,10 @@ fn create_throwing_matcher<'src, 'ast>(
             ));
         }
 
-        let decl = pattern_meta.decls.iter().next().unwrap();
-        return Ok((PyBlock::new(), ctx.decl_py_ident(*decl)?));
+        if ident.value.0 != "_" {
+            let decl = pattern_meta.decls.iter().next().unwrap();
+            return Ok((PyBlock::new(), ctx.decl_py_ident(*decl)?));
+        }
     }
 
     let cursor = ctx.create_aux_var("matcher", pattern.span.start);
@@ -1290,7 +1292,15 @@ fn make_arglist<'src, 'ast>(
                     .iter()
                     .find(|key| ctx.declarations[**key].name == name.value)
                     .ok_or_else(|| simple_err("Internal: missing arg name", name.span))?;
-                PyArgDefItem::ArgSpread(ctx.decl_py_ident(*decl)?)
+
+                let decl_value = &ctx.declarations[*decl];
+
+                if decl_value.name.0 == "_" {
+                    // need to create a unique name to prevent python complaining
+                    PyArgDefItem::ArgSpread(ctx.create_aux_var("_", name.span.start))
+                } else {
+                    PyArgDefItem::ArgSpread(ctx.decl_py_ident(*decl)?)
+                }
             }
             ArgDefItem::KwargSpread(name) => {
                 let decl = info
@@ -1298,7 +1308,14 @@ fn make_arglist<'src, 'ast>(
                     .iter()
                     .find(|key| ctx.declarations[**key].name == name.value)
                     .ok_or_else(|| simple_err("Internal: missing arg name", name.span))?;
-                PyArgDefItem::KwargSpread(ctx.decl_py_ident(*decl)?)
+
+                let decl_value = &ctx.declarations[*decl];
+
+                if decl_value.name.0 == "_" {
+                    PyArgDefItem::KwargSpread(ctx.create_aux_var("_", name.span.start))
+                } else {
+                    PyArgDefItem::KwargSpread(ctx.decl_py_ident(*decl)?)
+                }
             }
         };
         args_vec.push(arg);
@@ -1390,7 +1407,8 @@ fn prepare_py_fn<'src, 'ast>(
             let mut globals = vec![];
 
             for capture in fn_info.captures.iter() {
-                if ctx.scopes[ctx.declarations[*capture].scope].is_global {
+                let scope = &ctx.scopes[ctx.declarations[*capture].scope];
+                if scope.is_global || scope.is_class {
                     globals.push(ctx.decl_py_ident(*capture)?);
                 } else {
                     nonlocals.push(ctx.decl_py_ident(*capture)?);

koatl-0.1.20/python/koatl/prelude/functional/memo.tl

@@ -0,0 +1,63 @@
+import collections.defaultdict
+import functools.wraps
+import .result.Ok
+import .Monad
+
+export Memo = class(Monad):
+    Cache = class:
+        __init__ = self =>
+            self.cache = defaultdict(dict)
+
+        get_or_compute = (self, name, deps, f) =>
+            if try self.cache[name][deps] except KeyError() matches (Ok() as v):
+                return v
+
+            let value = f()
+            self.cache[name][deps] = value
+            value
+
+        __repr__ = self => f"Memo.Cache({self.cache})"
+
+    __init__ = (self, f) => self.f = f
+
+    __repr__ = self => f"Memo(...)"
+
+    value = staticmethod& (id, deps, f) =>
+        Memo(ctx => ctx.get_or_compute(id, tuple(deps), f))
+
+    fn = staticmethod& f => wraps(f)& (*args, **kwargs) =>
+        let id = f"{f.__module__}.{f.__qualname__}"
+        let deps = (tuple(args), tuple(kwargs.items()))
+
+        Memo(ctx =>
+            ctx.get_or_compute(id, deps, () =>
+                let v = f(*args, **kwargs)
+                if v matches Memo():
+                    v = v.run(ctx)
+                v
+            )
+        )
+
+    run = (self, ctx=Cache()) => self.f(ctx)
+
+    pure = staticmethod& value => Memo(ctx => value)
+
+    bind_once = (self, f) => Memo(ctx =>
+        let value = f(self.run(ctx))
+        if value matches Memo():
+            value = value.run(ctx)
+        value
+    )
+
+    bind_gen = (self, gen) => Memo(ctx =>
+        self = self.run(ctx)
+        try:
+            while True:
+                self = gen.send(self)
+                if self matches Memo():
+                    self = self.run(ctx)
+        except StopIteration(value=value):
+            return value
+    )
+
+__tl__.memo = Memo.value

koatl-0.1.19/koatl/python/koatl/prelude/functional/memo.tl

@@ -1,57 +0,0 @@
-import collections.defaultdict
-import functools.wraps
-import .result.Ok
-
-export MemoCtx = class:
-    __init__ = self =>
-        self.cache = defaultdict(dict)
-
-    get_or_compute = (self, name, args, f) =>
-        if try self.cache[name][args] except KeyError() matches (Ok() as v):
-            return v
-
-        let value = f()
-        self.cache[name][args] = value
-        value
-
-    __repr__ = self => f"MemoCtx({self.cache})"
-
-export Memo = class:
-    __init__ = (self, id, deps, f) =>
-        self.id = id
-        self.deps = deps
-        self.f = f
-
-    __repr__ = self => f"Memo(...)"
-
-    run = (self, ctx=MemoCtx()) =>
-        ctx.get_or_compute(self.id, tuple(self.deps), self.f)
-
-    fn = staticmethod& f => wraps(f)& (*args, **kwargs) =>
-        let m = object.__new__(Memo)
-        let name = f"{f.__module__}.{f.__qualname__}"
-        m.run = (ctx=MemoCtx()) =>
-            let arg_key = (tuple(args), tuple(kwargs.items()))
-
-            ctx.get_or_compute(name, arg_key, () =>
-                let v = f(*args, **kwargs)
-                if v matches Memo():
-                    v = v.run(ctx)
-                v
-            )
-        m
-
-    bind_gen = (self, gen) =>
-        let m = object.__new__(Memo)
-        m.run = (ctx=MemoCtx()) =>
-            self = self.run(ctx)
-            try:
-                while True:
-                    self = gen.send(self)
-                    if self matches Memo():
-                        self = self.run(ctx)
-            except StopIteration(value=value):
-                return value
-        m
-
-__tl__.memo = Memo

koatl-0.1.19/python/koatl/prelude/functional/memo.tl

@@ -1,57 +0,0 @@
-import collections.defaultdict
-import functools.wraps
-import .result.Ok
-
-export MemoCtx = class:
-    __init__ = self =>
-        self.cache = defaultdict(dict)
-
-    get_or_compute = (self, name, args, f) =>
-        if try self.cache[name][args] except KeyError() matches (Ok() as v):
-            return v
-
-        let value = f()
-        self.cache[name][args] = value
-        value
-
-    __repr__ = self => f"MemoCtx({self.cache})"
-
-export Memo = class:
-    __init__ = (self, id, deps, f) =>
-        self.id = id
-        self.deps = deps
-        self.f = f
-
-    __repr__ = self => f"Memo(...)"
-
-    run = (self, ctx=MemoCtx()) =>
-        ctx.get_or_compute(self.id, tuple(self.deps), self.f)
-
-    fn = staticmethod& f => wraps(f)& (*args, **kwargs) =>
-        let m = object.__new__(Memo)
-        let name = f"{f.__module__}.{f.__qualname__}"
-        m.run = (ctx=MemoCtx()) =>
-            let arg_key = (tuple(args), tuple(kwargs.items()))
-
-            ctx.get_or_compute(name, arg_key, () =>
-                let v = f(*args, **kwargs)
-                if v matches Memo():
-                    v = v.run(ctx)
-                v
-            )
-        m
-
-    bind_gen = (self, gen) =>
-        let m = object.__new__(Memo)
-        m.run = (ctx=MemoCtx()) =>
-            self = self.run(ctx)
-            try:
-                while True:
-                    self = gen.send(self)
-                    if self matches Memo():
-                        self = self.run(ctx)
-            except StopIteration(value=value):
-                return value
-        m
-
-__tl__.memo = Memo