koatl 0.1.18__tar.gz → 0.1.19__tar.gz

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

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

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

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

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

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

{koatl-0.1.18 → koatl-0.1.19/koatl}/python/koatl/prelude/functional/__init__.tl

@@ -2,6 +2,7 @@ export import .monad.*
 export import .result.*
 export import .async.*
 export import .reader.*
+export import .memo.*
 
 export Fn = class:
     compose = staticmethod& (*args) =>

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

@@ -0,0 +1,57 @@
+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.18 → koatl-0.1.19/koatl}/python/koatl/runtime/__init__.py

@@ -21,11 +21,18 @@ from .record import *
 from .helpers import *
 
 
+def dummy_memo(*args, **kwargs):
+    raise RuntimeError(
+        "memo is not available without the prelude. Please import koatl.prelude."
+    )
+
+
 __tl__ = SimpleNamespace(
     Exception=Exception,
     slice=slice,
     vget=virtual.vget,
     vhas=virtual.vhas,
+    memo=dummy_memo,
     unpack_record=helpers.unpack_record,
     set_exports=helpers.set_exports,
     do=helpers.do,

{koatl-0.1.18 → koatl-0.1.19}/koatl/src/lib.rs

@@ -29,7 +29,7 @@ fn get_option(mode: &str) -> PyResult<TranspileOptions> {
 fn transpile(src: &str, mode: &str, filename: &str) -> PyResult<PyObject> {
     let options = get_option(mode)?;
 
-    let py_ast = transpile_to_py_ast(src, options).map_err(|e| {
+    let py_ast = transpile_to_py_ast(src, filename, options).map_err(|e| {
         PyErr::new::<pyo3::exceptions::PySyntaxError, _>(format_errs(&e, filename, src))
     })?;
 
@@ -43,7 +43,7 @@ fn transpile(src: &str, mode: &str, filename: &str) -> PyResult<PyObject> {
 fn transpile_raw(src: &str, mode: &str, filename: &str) -> PyResult<PyObject> {
     let options = get_option(mode)?;
 
-    let ctx = transpile_to_source(src, options).map_err(|e| {
+    let ctx = transpile_to_source(src, filename, options).map_err(|e| {
         PyErr::new::<pyo3::exceptions::PySyntaxError, _>(format_errs(&e, filename, src))
     })?;
 

koatl-0.1.19/koatl/tests/e2e/prelude/memo.tl

@@ -0,0 +1,30 @@
+import util.assert_eq
+
+counts = 0
+
+fib = Memo.fn& x =>
+    if x < 2:
+        return 1
+
+    counts = counts + 1
+
+    let a = @fib(x - 1)
+    let b = @fib(x - 2)
+
+    a + b
+
+assert_eq(fib(10).run(), 89)
+assert_eq(counts < 20, True)
+
+counts = 0
+
+f = x =>
+    memo:
+        counts = counts + 1
+        x * 2
+
+ctx = MemoCtx()
+assert_eq(f(10).run(ctx), 20)
+assert_eq(f(10).run(ctx), 20)
+assert_eq(f(5).run(ctx), 10)
+assert_eq(counts, 2)

{koatl-0.1.18 → koatl-0.1.19}/koatl-core/parser/src/ast.rs

@@ -203,6 +203,7 @@ pub enum Expr<'a, TTree: Tree> {
     Await(TTree::Expr),
     Yield(TTree::Expr),
     YieldFrom(TTree::Expr),
+    Memo(TTree::Expr),
 
     If(TTree::Expr, TTree::Expr, Option<TTree::Expr>),
     Match(TTree::Expr, Vec<MatchCase<TTree>>),

{koatl-0.1.18 → koatl-0.1.19}/koatl-core/parser/src/parser.rs

@@ -781,8 +781,17 @@ where
     })
     .labelled("control-expression");
 
+    let memo_expr = just(Token::Ident("memo"))
+        .then(just(START_BLOCK).or_not())
+        .ignore_then(expr_or_inline_stmt_or_block.clone())
+        .map(|x| Expr::Memo(x.indirect()))
+        .spanned_expr()
+        .labelled("memo-expression")
+        .boxed();
+
     atom.define(
         choice((
+            memo_expr,
             ident_expr.clone(),
             classic_if,
             classic_match,

{koatl-0.1.18 → koatl-0.1.19}/koatl-core/src/inference.rs

@@ -152,15 +152,7 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for Indirect<SExpr<'src>> {
                 b.traverse(ctx);
                 Type::Any
             }
-            Expr::Await(expr) => {
-                expr.traverse(ctx);
-                Type::Any
-            }
-            Expr::Yield(expr) => {
-                expr.traverse(ctx);
-                Type::Any
-            }
-            Expr::YieldFrom(expr) => {
+            Expr::Await(expr) | Expr::Yield(expr) | Expr::Memo(expr) | Expr::YieldFrom(expr) => {
                 expr.traverse(ctx);
                 Type::Any
             }

{koatl-0.1.18 → koatl-0.1.19}/koatl-core/src/lib.rs

@@ -60,6 +60,7 @@ impl TranspileOptions {
 
 pub fn transpile_to_py_ast<'src>(
     src: &'src str,
+    filename: &'src str,
     options: TranspileOptions,
 ) -> TlResult<PyBlock<'src>> {
     let tl_ast = parse_tl(src)?;
@@ -79,7 +80,7 @@ pub fn transpile_to_py_ast<'src>(
         }
     };
 
-    let output = match transform_ast(&src, &tl_ast, &resolve_state, &inference) {
+    let output = match transform_ast(&src, &filename, &tl_ast, &resolve_state, &inference) {
         Ok(output) => Some(output),
         Err(e) => {
             errs.extend(e);
@@ -173,8 +174,12 @@ pub fn transpile_to_py_ast<'src>(
     Ok(py_ast)
 }
 
-pub fn transpile_to_source(src: &str, options: TranspileOptions) -> TlResult<EmitCtx> {
-    let mut py_ast = transpile_to_py_ast(src, options)?;
+pub fn transpile_to_source(
+    src: &str,
+    filename: &str,
+    options: TranspileOptions,
+) -> TlResult<EmitCtx> {
+    let mut py_ast = transpile_to_py_ast(src, filename, options)?;
 
     let mut ctx = EmitCtx::new();
     py_ast.emit_to(&mut ctx, 0).map_err(|e| {

{koatl-0.1.18 → koatl-0.1.19}/koatl-core/src/main.rs

@@ -13,7 +13,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let filename = std::env::args().nth(2).ok_or("Missing filename argument")?;
     let src = std::fs::read_to_string(&filename).unwrap();
 
-    match transpile_to_source(&src, TranspileOptions::module()) {
+    match transpile_to_source(&src, &filename, TranspileOptions::module()) {
         Ok(ctx) => match cmd.as_str() {
             "trans" => {
                 println!("{}", ctx.source);

{koatl-0.1.18 → koatl-0.1.19}/koatl-core/src/py/util.rs

@@ -334,11 +334,11 @@ impl PyAstBuilder {
     }
 
     // Utility builders for tuple items
-    pub fn tuple_item<'src>(&self, expr: SPyExpr<'src>) -> PyListItem<'src> {
+    pub fn list_item<'src>(&self, expr: SPyExpr<'src>) -> PyListItem<'src> {
         PyListItem::Item(expr)
     }
 
-    pub fn tuple_spread<'src>(&self, expr: SPyExpr<'src>) -> PyListItem<'src> {
+    pub fn list_spread<'src>(&self, expr: SPyExpr<'src>) -> PyListItem<'src> {
         PyListItem::Spread(expr)
     }
 

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

@@ -37,6 +37,7 @@ pub struct ResolveState<'src> {
     pub resolutions: HashMap<RefHash, DeclarationKey>,
     pub functions: HashMap<RefHash, FnInfo>,
     pub patterns: HashMap<RefHash, PatternInfo>,
+    pub memo_captures: HashMap<RefHash, FnInfo>,
 
     pub declarations: SlotMap<DeclarationKey, Declaration<'src>>,
     pub scopes: SlotMap<ScopeKey, Scope>,
@@ -86,6 +87,7 @@ impl<'src> ResolveState<'src> {
             resolutions: HashMap::new(),
             functions: HashMap::new(),
             patterns: HashMap::new(),
+            memo_captures: HashMap::new(),
 
             declarations: SlotMap::with_key(),
             scopes,
@@ -116,6 +118,7 @@ impl<'src> ResolveState<'src> {
             }
 
             let Some(fn_ctx) = self.fn_stack.last_mut() else {
+                // This should never happen since if not fn_local, there must be at least one function context
                 return Err(simple_err("Internal error: no function context", ident.span).into());
             };
 
@@ -374,12 +377,19 @@ impl PlaceholderGuard {
     }
 }
 
+// This is a bit of a misuse, since during traversal,
+// FnInfo represents a "capture context" rather than a function
+// (i.e., it logs captures and monadic constructs like Async)
+
+// ...but it becomes a real function context once it gets added
+// to the hashmap.
 #[derive(Debug, Clone)]
 pub struct FnInfo {
     pub is_do: bool,
     pub is_async: bool,
     pub is_generator: bool,
     pub is_placeholder: bool,
+    pub is_memo: bool,
 
     pub arg_names: Vec<DeclarationKey>,
     pub captures: HashSet<DeclarationKey>,
@@ -392,6 +402,7 @@ impl FnInfo {
             is_async: false,
             is_generator: false,
             is_placeholder: false,
+            is_memo: false,
             arg_names: Vec::new(),
             captures: HashSet::new(),
         }
@@ -1286,6 +1297,42 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
 
                 Expr::Unary(unary_op, expr.traverse(state))
             }
+            Expr::Memo(inner) => {
+                state.set_do(span);
+
+                let mut fn_ctx = FnInfo::new();
+                fn_ctx.is_memo = true;
+
+                let mut scope = Scope::new();
+                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?
+
+                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 = scoped.value;
+
+                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)
+            }
             Expr::Await(x) => {
                 state.set_async(span);
                 Expr::Await(x.traverse(state))

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

@@ -51,8 +51,9 @@ struct PyDecl<'src> {
 #[allow(dead_code)]
 struct TlCtx<'src, 'ast> {
     source: &'src str,
-    export_stars: Vec<PyIdent<'src>>,
+    filename: &'src str,
     line_cache: LineColCache,
+    export_stars: Vec<PyIdent<'src>>,
 
     ident_counts: HashMap<Ident<'src>, usize>,
     py_decls: HashMap<DeclarationKey, PyDecl<'src>>,
@@ -60,6 +61,7 @@ struct TlCtx<'src, 'ast> {
     functions: &'ast HashMap<RefHash, FnInfo>,
     patterns: &'ast HashMap<RefHash, PatternInfo>,
     resolutions: &'ast HashMap<RefHash, DeclarationKey>,
+    memo_captures: &'ast HashMap<RefHash, FnInfo>,
 
     scopes: &'ast SlotMap<ScopeKey, Scope>,
     declarations: &'ast SlotMap<DeclarationKey, Declaration<'src>>,
@@ -70,11 +72,13 @@ struct TlCtx<'src, 'ast> {
 impl<'src, 'ast> TlCtx<'src, 'ast> {
     fn new(
         source: &'src str,
+        filename: &'src str,
         resolve_state: &'ast ResolveState<'src>,
         inference: &'ast InferenceCtx<'src, 'ast>,
     ) -> TlResult<Self> {
         Ok(TlCtx {
             source,
+            filename,
             export_stars: Vec::new(),
             line_cache: LineColCache::new(source),
 
@@ -84,6 +88,7 @@ impl<'src, 'ast> TlCtx<'src, 'ast> {
             functions: &resolve_state.functions,
             patterns: &resolve_state.patterns,
             resolutions: &resolve_state.resolutions,
+            memo_captures: &resolve_state.memo_captures,
 
             scopes: &resolve_state.scopes,
             declarations: &resolve_state.declarations,
@@ -1314,7 +1319,9 @@ struct PartialPyFnDef<'a> {
 }
 
 enum FnDef<'src, 'ast> {
-    // Args, body, is_do, is_async
+    /**
+     * Args, body, is_do, is_async
+     */
     PyFnDef(Vec<PyArgDefItem<'src>>, PyBlock<'src>, bool, bool),
 
     // Expr::Fn, args, body
@@ -1600,7 +1607,7 @@ fn transform_postfix_expr<'src, 'ast>(
     expr: &'ast SExpr<'src>,
     access_ctx: PyAccessCtx,
 ) -> TlResult<SPyExprWithPre<'src>> {
-    let (lift_lhs, lhs_node) = match &expr.value {
+    let (mapped, lhs_node) = match &expr.value {
         Expr::RawAttribute(obj, _) => (false, obj),
         Expr::Subscript(obj, _) => (false, obj),
         Expr::Call(obj, _) => (false, obj),
@@ -1619,20 +1626,17 @@ fn transform_postfix_expr<'src, 'ast>(
         }
     };
 
-    if let Expr::Attribute(..) | Expr::RawAttribute(..) = &expr.value {
+    if let Expr::Attribute(..) | Expr::RawAttribute(..) | Expr::Subscript(..) = &expr.value {
     } else {
         if access_ctx != PyAccessCtx::Load {
-            return Err(simple_err(
-                "Internal error: Cannot use null-coalescing in a non-Load context",
-                expr.span,
-            ));
+            return Err(simple_err("Illegal assignment target", expr.span));
         }
     }
 
     let mut pre = PyBlock::new();
     let a = PyAstBuilder::new(expr.span);
 
-    let lhs = if lift_lhs {
+    let lhs = if mapped {
         pre.bind(lhs_node.transform_lifted(ctx)?)
     } else {
         pre.bind(lhs_node.transform(ctx)?)
@@ -2226,6 +2230,70 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
 
                 a.binary(py_op, lhs, rhs)
             }
+            Expr::Memo(expr) => {
+                let memo_captures =
+                    ctx.memo_captures
+                        .get(&expr.as_ref().into())
+                        .ok_or_else(|| {
+                            simple_err(
+                                "Internal error: Memo expression not found in memo captures",
+                                expr.span,
+                            )
+                        })?;
+
+                let py_expr = expr.transform(ctx)?;
+                let mut py_body = PyBlock::new();
+
+                let mut nonlocals = vec![];
+                let mut globals = vec![];
+
+                for capture in memo_captures.captures.iter() {
+                    if ctx.scopes[ctx.declarations[*capture].scope].is_global {
+                        globals.push(ctx.decl_py_ident(*capture)?);
+                    } else {
+                        nonlocals.push(ctx.decl_py_ident(*capture)?);
+                    }
+                }
+
+                if !nonlocals.is_empty() {
+                    py_body.push(a.nonlocal(nonlocals.iter().map(|x| x.clone()).collect()));
+                }
+                if !globals.is_empty() {
+                    py_body.push(a.global(globals.iter().map(|x| x.clone()).collect()));
+                }
+
+                py_body.extend(py_expr.pre);
+                py_body.push(a.return_(py_expr.value));
+
+                let callback = pre.bind(make_fn_exp(
+                    ctx,
+                    FnDef::PyFnDef(vec![], py_body, false, false),
+                    &span,
+                )?);
+
+                let linecol = ctx.line_cache.linecol(span.start);
+
+                a.yield_(a.call(
+                    a.tl_builtin("memo"),
+                    vec![
+                        PyCallItem::Arg(
+                            a.str(
+                                format!("{}:{}:{}", ctx.filename, linecol.0, linecol.1)
+                            )
+                        ),
+                        PyCallItem::Arg(
+                            a.tuple(
+                                nonlocals
+                                    .iter()
+                                    .map(|x| a.list_item(a.load_ident(x.clone())))
+                                    .collect(),
+                                PyAccessCtx::Load,
+                            ),
+                        ),
+                        PyCallItem::Arg(callback),
+                    ],
+                ))
+            }
             Expr::Await(expr) => a.await_(pre.bind(expr.transform(ctx)?)),
             Expr::Yield(expr) => a.yield_(pre.bind(expr.transform(ctx)?)),
             Expr::YieldFrom(expr) => a.yield_from(a.call(
@@ -2344,11 +2412,12 @@ pub struct TransformOutput<'src> {
 
 pub fn transform_ast<'src, 'ast>(
     source: &'src str,
+    filename: &'src str,
     block: &'ast SExpr<'src>,
     resolve_state: &'ast ResolveState<'src>,
     inference: &'ast InferenceCtx<'src, 'ast>,
 ) -> TlResult<TransformOutput<'src>> {
-    let mut ctx = TlCtx::new(source, resolve_state, inference)?;
+    let mut ctx = TlCtx::new(source, filename, resolve_state, inference)?;
 
     let mut py_block = PyBlock::new();
     let expr = py_block.bind(block.transform(&mut ctx)?);

{koatl-0.1.18/koatl → koatl-0.1.19}/python/koatl/prelude/functional/__init__.tl

@@ -2,6 +2,7 @@ export import .monad.*
 export import .result.*
 export import .async.*
 export import .reader.*
+export import .memo.*
 
 export Fn = class:
     compose = staticmethod& (*args) =>

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

@@ -0,0 +1,57 @@
+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.18/koatl → koatl-0.1.19}/python/koatl/runtime/__init__.py

@@ -21,11 +21,18 @@ from .record import *
 from .helpers import *
 
 
+def dummy_memo(*args, **kwargs):
+    raise RuntimeError(
+        "memo is not available without the prelude. Please import koatl.prelude."
+    )
+
+
 __tl__ = SimpleNamespace(
     Exception=Exception,
     slice=slice,
     vget=virtual.vget,
     vhas=virtual.vhas,
+    memo=dummy_memo,
     unpack_record=helpers.unpack_record,
     set_exports=helpers.set_exports,
     do=helpers.do,