koatl 0.1.20__tar.gz → 0.1.21__tar.gz

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

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

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

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

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

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

{koatl-0.1.20 → koatl-0.1.21/koatl}/python/koatl/prelude/functional/memo.tl

@@ -8,37 +8,46 @@ export Memo = class(Monad):
         __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
+        __repr__ = self => f"Memo.Cache({self.cache})"
+
+        try_get = (self, name, deps) =>
+            try self.cache[name][deps] except KeyError()
 
-            let value = f()
+        update = (self, name, deps, value) =>
             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))
+        Memo(ctx =>
+            if ctx.try_get(id, tuple(deps)) matches Ok() as value:
+                return value
+
+            ctx.update(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
-            )
+            if ctx.try_get(id, deps) matches Ok() as value:
+                return value
+
+            let v = f(*args, **kwargs)
+            if v matches Memo():
+                v = v.run(ctx)
+
+            ctx.update(id, deps, v)
         )
 
-    run = (self, ctx=Cache()) => self.f(ctx)
+    run = (self, ctx=None) =>
+        if ctx === None:
+            ctx = Memo.Cache()
+        self.f(ctx)
 
     pure = staticmethod& value => Memo(ctx => value)
 

{koatl-0.1.20 → koatl-0.1.21}/koatl-core/Cargo.toml

@@ -8,3 +8,7 @@ ariadne = "0.5.1"
 parser = { path = "parser" }
 once_cell = "1.19.0"
 slotmap = "1.0.7"
+
+[[bin]]
+name = "parse_timer"
+path = "src/parse_timer.rs"

{koatl-0.1.20 → koatl-0.1.21}/koatl-core/parser/src/ast.rs

@@ -120,7 +120,6 @@ pub enum DeclType {
 
 #[derive(Debug, Clone)]
 pub enum Stmt<'a, TTree: Tree> {
-    Module,
     Decl(Vec<SIdent<'a>>, DeclType),
     Assign(TTree::Expr, TTree::Expr, Option<DeclType>),
     Expr(TTree::Expr),

{koatl-0.1.20 → koatl-0.1.21}/koatl-core/parser/src/parser.rs

@@ -131,6 +131,7 @@ pub fn match_pattern<'tokens, 'src: 'tokens, TInput, PIdent, PQualIdent, PExpr,
 ) -> (
     impl Parser<'tokens, TInput, SPattern<'src>, TExtra<'tokens, 'src>> + Clone,
     impl Parser<'tokens, TInput, SPattern<'src>, TExtra<'tokens, 'src>> + Clone,
+    impl Parser<'tokens, TInput, SPattern<'src>, TExtra<'tokens, 'src>> + Clone,
 )
 where
     TInput: ValueInput<'tokens, Token = Token<'src>, Span = Span>,
@@ -311,7 +312,7 @@ where
 
     pattern.define(
         choice((
-            as_pattern,
+            as_pattern.clone(),
             value_pattern,
             closed_pattern.clone(),
             symbol("_")
@@ -323,6 +324,7 @@ where
 
     (
         closed_pattern.labelled("pattern").as_context(),
+        as_pattern.labelled("pattern").as_context(),
         nary_sequence_pattern.labelled("pattern").as_context(),
     )
 }
@@ -475,6 +477,245 @@ where
     })
 }
 
+pub fn statement<'tokens, 'src: 'tokens, TInput, PBody, PTuple, PExpr, PIdent, PPattern>(
+    expr_or_inline_stmt_or_block: PBody,
+    nary_tuple: PTuple,
+    expr: PExpr,
+    ident: PIdent,
+    nary_pattern: PPattern,
+) -> (
+    impl Parser<'tokens, TInput, SStmt<'src>, TExtra<'tokens, 'src>> + Clone,
+    impl Parser<'tokens, TInput, SStmt<'src>, TExtra<'tokens, 'src>> + Clone,
+)
+where
+    TInput: ValueInput<'tokens, Token = Token<'src>, Span = Span>,
+    PBody: Parser<'tokens, TInput, SExpr<'src>, TExtra<'tokens, 'src>> + Clone + 'tokens,
+    PTuple: Parser<'tokens, TInput, SExpr<'src>, TExtra<'tokens, 'src>> + Clone + 'tokens,
+    PExpr: Parser<'tokens, TInput, SExpr<'src>, TExtra<'tokens, 'src>> + Clone + 'tokens,
+    PIdent: Parser<'tokens, TInput, SIdent<'src>, TExtra<'tokens, 'src>> + Clone + 'tokens,
+    PPattern: Parser<'tokens, TInput, SPattern<'src>, TExtra<'tokens, 'src>> + Clone + 'tokens,
+{
+    let mut stmt = Recursive::<chumsky::recursive::Indirect<TInput, SStmt, TExtra>>::declare();
+    let mut inline_stmt =
+        Recursive::<chumsky::recursive::Indirect<TInput, SStmt, TExtra>>::declare();
+
+    let decl_mod = choice((
+        just(Token::Kw("export")).to(DeclType::Export),
+        just(Token::Kw("global")).to(DeclType::Global),
+        just(Token::Kw("let")).to(DeclType::Let),
+        just(Token::Kw("const")).to(DeclType::Const),
+    ));
+
+    let decl_stmt = decl_mod
+        .clone()
+        .then(ident.clone().separated_by(symbol(",")).collect())
+        .map(|(decl, idents)| SStmtInner::Decl(idents, decl))
+        .boxed();
+
+    let assign_lhs = nary_tuple.clone();
+    let inline_assign_lhs = expr.clone();
+
+    let assign_stmt = group((
+        decl_mod.clone().or_not(),
+        assign_lhs.clone(),
+        symbol("=").ignore_then(nary_tuple.clone()),
+    ))
+    .map(|(decl, lhs, rhs)| SStmtInner::Assign(lhs.indirect(), rhs.indirect(), decl))
+    .boxed();
+
+    let inline_assign_stmt = group((
+        decl_mod.clone().or_not(),
+        inline_assign_lhs.clone(),
+        symbol("=").ignore_then(expr.clone()),
+    ))
+    .map(|(decl, lhs, rhs)| SStmtInner::Assign(lhs.indirect(), rhs.indirect(), decl))
+    .boxed();
+
+    let expr_stmt = assign_lhs
+        .clone()
+        .map(|x| SStmtInner::Expr(x.indirect()))
+        .boxed();
+
+    let inline_expr_stmt = inline_assign_lhs
+        .clone()
+        .map(|x| SStmtInner::Expr(x.indirect()))
+        .boxed();
+
+    let while_stmt = just(Token::Kw("while"))
+        .ignore_then(expr.clone())
+        .then_ignore(just(START_BLOCK))
+        .then(expr_or_inline_stmt_or_block.clone())
+        .map(|(cond, body)| SStmtInner::While(cond.indirect(), body.indirect()))
+        .labelled("while statement")
+        .boxed();
+
+    let except_block = just(Token::Eol)
+        .then(just(Token::Kw("except")))
+        .ignore_then(nary_pattern.clone().or_not())
+        .boxed()
+        .then(just(START_BLOCK).ignore_then(expr_or_inline_stmt_or_block.clone()))
+        .map(|(pattern, body)| SMatchCase {
+            pattern: pattern.map(|x| x.indirect()),
+            guard: None,
+            body: body.indirect(),
+        })
+        .labelled("except block")
+        .boxed();
+
+    let finally_block = one_of([Token::Eol])
+        .then(just(Token::Kw("finally")))
+        .then(just(START_BLOCK))
+        .ignore_then(expr_or_inline_stmt_or_block.clone())
+        .labelled("finally block")
+        .boxed();
+
+    let try_stmt = just(Token::Kw("try"))
+        .then(just(START_BLOCK))
+        .ignore_then(group((
+            expr_or_inline_stmt_or_block.clone(),
+            except_block.repeated().collect(),
+            finally_block.or_not(),
+        )))
+        .map(|(body, excepts, finally)| {
+            SStmtInner::Try(body.indirect(), excepts, finally.map(|x| x.indirect()))
+        })
+        .labelled("try statement")
+        .boxed();
+
+    let for_stmt = just(Token::Kw("for"))
+        .ignore_then(group((
+            nary_pattern.clone().then_ignore(just(Token::Kw("in"))),
+            expr.clone().then_ignore(just(START_BLOCK)),
+            expr_or_inline_stmt_or_block.clone(),
+        )))
+        .map(|(decl, iter, body)| {
+            SStmtInner::For(decl.indirect(), iter.indirect(), body.indirect())
+        })
+        .labelled("for statement")
+        .boxed();
+
+    let return_stmt = just(Token::Kw("return"))
+        .ignore_then(nary_tuple.clone())
+        .map(|x| SStmtInner::Return(x.indirect()))
+        .labelled("return statement")
+        .boxed();
+
+    let inline_return_stmt = just(Token::Kw("return"))
+        .ignore_then(expr.clone())
+        .map(|x| SStmtInner::Return(x.indirect()))
+        .labelled("inline return statement")
+        .boxed();
+
+    let assert_stmt = just(Token::Ident("assert"))
+        .ignore_then(expr.clone())
+        .then(symbol(",").ignore_then(expr.clone()).or_not())
+        .map(|(x, y)| SStmtInner::Assert(x.indirect(), y.map(|y| y.indirect())))
+        .labelled("assert statement")
+        .boxed();
+
+    let raise_stmt = just(Token::Kw("raise"))
+        .ignore_then(nary_tuple.clone().or_not())
+        .map(|x| SStmtInner::Raise(x.map(|x| x.indirect())))
+        .labelled("raise statement")
+        .boxed();
+
+    let inline_raise_stmt = just(Token::Kw("raise"))
+        .ignore_then(expr.clone().or_not())
+        .map(|x| SStmtInner::Raise(x.map(|x| x.indirect())))
+        .labelled("inline raise statement")
+        .boxed();
+
+    let break_stmt = just(Token::Kw("break"))
+        .map(|_| SStmtInner::Break)
+        .labelled("break statement")
+        .boxed();
+
+    let continue_stmt = just(Token::Kw("continue"))
+        .map(|_| SStmtInner::Continue)
+        .labelled("continue statement")
+        .boxed();
+
+    let import_stmt = just(Token::Kw("export"))
+        .to(1)
+        .or_not()
+        .then_ignore(just(Token::Kw("import")))
+        .then(group((
+            symbol(".").repeated().count(),
+            ident
+                .clone()
+                .then_ignore(symbol("."))
+                .repeated()
+                .collect()
+                .boxed(),
+            choice((
+                enumeration(
+                    ident
+                        .clone()
+                        .then(just(Token::Kw("as")).ignore_then(ident.clone()).or_not()),
+                    symbol(","),
+                )
+                .delimited_by_with_eol(symbol("("), symbol(")"))
+                .map(ImportList::Leaves)
+                .boxed(),
+                just(Token::Symbol("*")).map(|_| ImportList::Star),
+                ident
+                    .clone()
+                    .then(just(Token::Kw("as")).ignore_then(ident.clone()).or_not())
+                    .map(|x| ImportList::Leaves(vec![x]))
+                    .boxed(),
+            ))
+            .boxed(),
+        )))
+        .map(|(reexport, (level, trunk, import_list))| {
+            SStmtInner::Import(ImportStmt {
+                trunk,
+                imports: import_list,
+                level,
+                reexport: reexport.is_some(),
+            })
+        })
+        .labelled("import statement")
+        .boxed();
+
+    stmt.define(
+        choice((
+            decl_stmt.then_ignore(just(Token::Eol)),
+            assign_stmt.then_ignore(just(Token::Eol)),
+            expr_stmt.then_ignore(just(Token::Eol)),
+            while_stmt.clone().then_ignore(just(Token::Eol)),
+            for_stmt.clone().then_ignore(just(Token::Eol)),
+            return_stmt.then_ignore(just(Token::Eol)),
+            assert_stmt.then_ignore(just(Token::Eol)),
+            raise_stmt.then_ignore(just(Token::Eol)),
+            break_stmt.clone().then_ignore(just(Token::Eol)),
+            continue_stmt.clone().then_ignore(just(Token::Eol)),
+            import_stmt.then_ignore(just(Token::Eol)),
+            try_stmt.then_ignore(just(Token::Eol)),
+        ))
+        .labelled("statement")
+        .map_with(|x, e| x.spanned(e.span()))
+        .boxed(),
+    );
+
+    inline_stmt.define(
+        choice((
+            inline_assign_stmt,
+            inline_expr_stmt,
+            while_stmt,
+            for_stmt,
+            inline_return_stmt,
+            inline_raise_stmt,
+            break_stmt,
+            continue_stmt,
+        ))
+        .labelled("inline-statement")
+        .map_with(|x, e| x.spanned(e.span()))
+        .boxed(),
+    );
+
+    (stmt, inline_stmt)
+}
+
 pub fn parser<'tokens, 'src: 'tokens, TInput>()
 -> impl Parser<'tokens, TInput, SExpr<'src>, TExtra<'tokens, 'src>> + Clone
 where
@@ -483,6 +724,7 @@ where
     let mut stmt = Recursive::<chumsky::recursive::Indirect<TInput, SStmt, TExtra>>::declare();
     let mut inline_stmt =
         Recursive::<chumsky::recursive::Indirect<TInput, SStmt, TExtra>>::declare();
+
     let mut atom = Recursive::<chumsky::recursive::Indirect<TInput, SExpr, TExtra>>::declare();
     let mut expr = Recursive::<chumsky::recursive::Indirect<TInput, SExpr, TExtra>>::declare();
     let mut unary = Recursive::<chumsky::recursive::Indirect<TInput, SExpr, TExtra>>::declare();
@@ -722,7 +964,7 @@ where
         )
         .boxed();
 
-    let (closed_pattern, nary_pattern) = match_pattern(
+    let (closed_pattern, as_pattern, nary_pattern) = match_pattern(
         ident.clone(),
         qualified_ident.clone(),
         expr.clone(),
@@ -1113,7 +1355,7 @@ where
         .then(
             just(Token::Ident("matches"))
                 .ignore_then(just(Token::Kw("not")).to(0).or_not())
-                .then(closed_pattern.clone())
+                .then(as_pattern.clone())
                 .or_not(),
         )
         .map_with(|(expr, matches_part), e| {
@@ -1181,218 +1423,16 @@ where
         binary6.labelled("expression").as_context().boxed(), // .memoized(),
     );
 
-    // Statements
-
-    let decl_mod = choice((
-        just(Token::Kw("export")).to(DeclType::Export),
-        just(Token::Kw("global")).to(DeclType::Global),
-        just(Token::Kw("let")).to(DeclType::Let),
-        just(Token::Kw("const")).to(DeclType::Const),
-    ));
-
-    let decl_stmt = decl_mod
-        .clone()
-        .then(ident.clone().separated_by(symbol(",")).collect())
-        .map(|(decl, idents)| SStmtInner::Decl(idents, decl))
-        .boxed();
-
-    let assign_stmt = group((
-        decl_mod.clone().or_not(),
+    let (stmt_, inline_stmt_) = statement(
+        expr_or_inline_stmt_or_block.clone(),
         nary_tuple.clone(),
-        symbol("=").ignore_then(nary_tuple.clone()),
-    ))
-    .map(|(decl, lhs, rhs)| SStmtInner::Assign(lhs.indirect(), rhs.indirect(), decl))
-    .boxed();
-
-    let inline_assign_stmt = group((
-        decl_mod.clone().or_not(),
         expr.clone(),
-        symbol("=").ignore_then(expr.clone()),
-    ))
-    .map(|(decl, lhs, rhs)| SStmtInner::Assign(lhs.indirect(), rhs.indirect(), decl))
-    .boxed();
-
-    let expr_stmt = nary_tuple
-        .clone()
-        .map(|x| SStmtInner::Expr(x.indirect()))
-        .boxed();
-
-    let inline_expr_stmt = expr.clone().map(|x| SStmtInner::Expr(x.indirect())).boxed();
-
-    let while_stmt = just(Token::Kw("while"))
-        .ignore_then(expr.clone())
-        .then_ignore(just(START_BLOCK))
-        .then(expr_or_inline_stmt_or_block.clone())
-        .map(|(cond, body)| SStmtInner::While(cond.indirect(), body.indirect()))
-        .labelled("while statement")
-        .boxed();
-
-    let except_block = just(Token::Eol)
-        .then(just(Token::Kw("except")))
-        .ignore_then(nary_pattern.clone().or_not())
-        .boxed()
-        .then(just(START_BLOCK).ignore_then(expr_or_inline_stmt_or_block.clone()))
-        .map(|(pattern, body)| SMatchCase {
-            pattern: pattern.map(|x| x.indirect()),
-            guard: None,
-            body: body.indirect(),
-        })
-        .labelled("except block")
-        .boxed();
-
-    let finally_block = one_of([Token::Eol])
-        .then(just(Token::Kw("finally")))
-        .then(just(START_BLOCK))
-        .ignore_then(expr_or_inline_stmt_or_block.clone())
-        .labelled("finally block")
-        .boxed();
-
-    let try_stmt = just(Token::Kw("try"))
-        .then(just(START_BLOCK))
-        .ignore_then(group((
-            expr_or_inline_stmt_or_block.clone(),
-            except_block.repeated().collect(),
-            finally_block.or_not(),
-        )))
-        .map(|(body, excepts, finally)| {
-            SStmtInner::Try(body.indirect(), excepts, finally.map(|x| x.indirect()))
-        })
-        .labelled("try statement")
-        .boxed();
-
-    let for_stmt = just(Token::Kw("for"))
-        .ignore_then(group((
-            nary_pattern.clone().then_ignore(just(Token::Kw("in"))),
-            expr.clone().then_ignore(just(START_BLOCK)),
-            expr_or_inline_stmt_or_block.clone(),
-        )))
-        .map(|(decl, iter, body)| {
-            SStmtInner::For(decl.indirect(), iter.indirect(), body.indirect())
-        })
-        .labelled("for statement")
-        .boxed();
-
-    let return_stmt = just(Token::Kw("return"))
-        .ignore_then(nary_tuple.clone())
-        .map(|x| SStmtInner::Return(x.indirect()))
-        .labelled("return statement")
-        .boxed();
-
-    let inline_return_stmt = just(Token::Kw("return"))
-        .ignore_then(expr.clone())
-        .map(|x| SStmtInner::Return(x.indirect()))
-        .labelled("inline return statement")
-        .boxed();
-
-    let assert_stmt = just(Token::Ident("assert"))
-        .ignore_then(expr.clone())
-        .then(symbol(",").ignore_then(expr.clone()).or_not())
-        .map(|(x, y)| SStmtInner::Assert(x.indirect(), y.map(|y| y.indirect())))
-        .labelled("assert statement")
-        .boxed();
-
-    let raise_stmt = just(Token::Kw("raise"))
-        .ignore_then(nary_tuple.clone().or_not())
-        .map(|x| SStmtInner::Raise(x.map(|x| x.indirect())))
-        .labelled("raise statement")
-        .boxed();
-
-    let inline_raise_stmt = just(Token::Kw("raise"))
-        .ignore_then(expr.clone().or_not())
-        .map(|x| SStmtInner::Raise(x.map(|x| x.indirect())))
-        .labelled("inline raise statement")
-        .boxed();
-
-    let break_stmt = just(Token::Kw("break"))
-        .map(|_| SStmtInner::Break)
-        .labelled("break statement")
-        .boxed();
-
-    let continue_stmt = just(Token::Kw("continue"))
-        .map(|_| SStmtInner::Continue)
-        .labelled("continue statement")
-        .boxed();
-
-    let import_stmt = just(Token::Kw("export"))
-        .to(1)
-        .or_not()
-        .then_ignore(just(Token::Kw("import")))
-        .then(group((
-            symbol(".").repeated().count(),
-            ident
-                .clone()
-                .then_ignore(symbol("."))
-                .repeated()
-                .collect()
-                .boxed(),
-            choice((
-                enumeration(
-                    ident
-                        .clone()
-                        .then(just(Token::Kw("as")).ignore_then(ident.clone()).or_not()),
-                    symbol(","),
-                )
-                .delimited_by_with_eol(symbol("("), symbol(")"))
-                .map(ImportList::Leaves)
-                .boxed(),
-                just(Token::Symbol("*")).map(|_| ImportList::Star),
-                ident
-                    .clone()
-                    .then(just(Token::Kw("as")).ignore_then(ident.clone()).or_not())
-                    .map(|x| ImportList::Leaves(vec![x]))
-                    .boxed(),
-            ))
-            .boxed(),
-        )))
-        .map(|(reexport, (level, trunk, import_list))| {
-            SStmtInner::Import(ImportStmt {
-                trunk,
-                imports: import_list,
-                level,
-                reexport: reexport.is_some(),
-            })
-        })
-        .labelled("import statement")
-        .boxed();
-
-    let module_stmt = just(Token::Kw("module")).map(|_| SStmtInner::Module);
-
-    stmt.define(
-        choice((
-            decl_stmt.then_ignore(just(Token::Eol)),
-            assign_stmt.then_ignore(just(Token::Eol)),
-            expr_stmt.then_ignore(just(Token::Eol)),
-            module_stmt.then_ignore(just(Token::Eol)),
-            while_stmt.clone().then_ignore(just(Token::Eol)),
-            for_stmt.clone().then_ignore(just(Token::Eol)),
-            return_stmt.then_ignore(just(Token::Eol)),
-            assert_stmt.then_ignore(just(Token::Eol)),
-            raise_stmt.then_ignore(just(Token::Eol)),
-            break_stmt.clone().then_ignore(just(Token::Eol)),
-            continue_stmt.clone().then_ignore(just(Token::Eol)),
-            import_stmt.then_ignore(just(Token::Eol)),
-            try_stmt.then_ignore(just(Token::Eol)),
-        ))
-        .labelled("statement")
-        .map_with(|x, e| x.spanned(e.span()))
-        .boxed(),
+        ident.clone(),
+        nary_pattern.clone(),
     );
 
-    inline_stmt.define(
-        choice((
-            inline_assign_stmt,
-            inline_expr_stmt,
-            while_stmt,
-            for_stmt,
-            inline_return_stmt,
-            inline_raise_stmt,
-            break_stmt,
-            continue_stmt,
-        ))
-        .labelled("inline-statement")
-        .map_with(|x, e| x.spanned(e.span()))
-        .boxed(),
-    );
+    stmt.define(stmt_.labelled("statement").boxed());
+    inline_stmt.define(inline_stmt_.labelled("inline-statement").boxed());
 
     block.labelled("program")
 }

{koatl-0.1.20 → koatl-0.1.21}/koatl-core/src/inference.rs

@@ -53,7 +53,6 @@ impl<'src, 'ast> SStmtExt<'src, 'ast> for Indirect<SStmt<'src>> {
             }
             Stmt::Raise(..) | Stmt::Return(..) | Stmt::Break | Stmt::Continue => Type::Bottom,
             Stmt::Import(..) => Type::NoReturn,
-            Stmt::Module => Type::NoReturn,
             Stmt::Decl(..) => Type::NoReturn,
         }
     }

{koatl-0.1.20 → koatl-0.1.21}/koatl-core/src/main.rs

@@ -1,5 +1,3 @@
-#![allow(unused_variables)]
-
 use std::{
     io::Write,
     process::{Command, Stdio},

koatl-0.1.21/koatl-core/src/parse_timer.rs

@@ -0,0 +1,35 @@
+use std::time::Instant;
+
+use koatl_core::parse_tl;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let filename = std::env::args().nth(1).ok_or("Missing filename argument")?;
+    let src = std::fs::read_to_string(&filename).unwrap();
+
+    let now = Instant::now();
+
+    let n = 1000;
+
+    for _ in 0..n {
+        match parse_tl(&src) {
+            Ok(_) => {}
+            Err(errs) => {
+                errs.0.into_iter().for_each(|e| {
+                    eprintln!("Error: {}", e.message);
+                    if let Some(span) = e.span {
+                        eprintln!("At span: {:?}", span);
+                    }
+                });
+                return Err("Parsing failed".into());
+            }
+        }
+    }
+
+    println!(
+        "Parsed {} in {}us",
+        filename,
+        now.elapsed().as_nanos() as f64 / 1000.0 / n as f64
+    );
+
+    Ok(())
+}

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

@@ -1555,7 +1555,6 @@ impl<'src> SStmtExt<'src> for Indirect<SStmt<'src>> {
                 Stmt::Import(import_stmt)
             }
             Stmt::Break => Stmt::Break,
-            Stmt::Module => Stmt::Module,
             Stmt::Continue => Stmt::Continue,
         };
 

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

@@ -1978,12 +1978,6 @@ impl<'src> SStmtExt<'src> for SStmt<'src> {
                     pre.push(a.import(aliases));
                 };
             }
-            Stmt::Module => {
-                return Err(simple_err(
-                    "Module statements are not allowed in the transform phase",
-                    span,
-                ));
-            }
         };
 
         Ok(pre)

{koatl-0.1.20/koatl → koatl-0.1.21}/python/koatl/prelude/functional/memo.tl

@@ -8,37 +8,46 @@ export Memo = class(Monad):
         __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
+        __repr__ = self => f"Memo.Cache({self.cache})"
+
+        try_get = (self, name, deps) =>
+            try self.cache[name][deps] except KeyError()
 
-            let value = f()
+        update = (self, name, deps, value) =>
             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))
+        Memo(ctx =>
+            if ctx.try_get(id, tuple(deps)) matches Ok() as value:
+                return value
+
+            ctx.update(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
-            )
+            if ctx.try_get(id, deps) matches Ok() as value:
+                return value
+
+            let v = f(*args, **kwargs)
+            if v matches Memo():
+                v = v.run(ctx)
+
+            ctx.update(id, deps, v)
         )
 
-    run = (self, ctx=Cache()) => self.f(ctx)
+    run = (self, ctx=None) =>
+        if ctx === None:
+            ctx = Memo.Cache()
+        self.f(ctx)
 
     pure = staticmethod& value => Memo(ctx => value)