koatl 0.1.26__tar.gz → 0.1.27__tar.gz

{koatl-0.1.26 → koatl-0.1.27}/Cargo.lock

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

{koatl-0.1.26 → koatl-0.1.27}/PKG-INFO

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

{koatl-0.1.26 → koatl-0.1.27}/koatl/Cargo.toml

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

{koatl-0.1.26 → koatl-0.1.27}/koatl/src/emit_py.rs

@@ -279,10 +279,36 @@ impl<'src> PyStmtExt<'src> for SPyStmt<'src> {
                     .collect();
                 ctx.ast_node("Match", (subject_ast, cases_ast?), &self.tl_span)
             }
-            PyStmt::Assign(target, value) => {
+            PyStmt::Assign(target, value, op) => {
                 let target_ast = target.emit_py(ctx)?;
                 let value_ast = value.emit_py(ctx)?;
-                ctx.ast_node("Assign", ([target_ast], value_ast), &self.tl_span)
+
+                if let Some(op) = op {
+                    let py_op = match op {
+                        PyBinaryOp::Add => "Add",
+                        PyBinaryOp::Sub => "Sub",
+                        PyBinaryOp::Mult => "Mult",
+                        PyBinaryOp::Div => "Div",
+                        _ => {
+                            return Err(PyTlErr {
+                                message: format!(
+                                    "Unsupported augmented assignment operator: {:?}",
+                                    op
+                                ),
+                                py_err: None,
+                                span: Some(self.tl_span),
+                            });
+                        }
+                    };
+
+                    ctx.ast_node(
+                        "AugAssign",
+                        (target_ast, ctx.ast_cls(py_op, ())?, value_ast),
+                        &self.tl_span,
+                    )
+                } else {
+                    ctx.ast_node("Assign", ([target_ast], value_ast), &self.tl_span)
+                }
             }
             PyStmt::Return(expr) => {
                 let expr_ast = expr.emit_py(ctx)?;

{koatl-0.1.26 → koatl-0.1.27}/koatl/tests/e2e/base/destructure.tl

@@ -48,11 +48,5 @@ assert_eq([a, b, c], ["a", [2, 3], {2: "2", 3: "3"}])
 {a, **b} = {a: 42, b: 43}
 assert_eq([a, b], [42, {b: 43}])
 
-a, *b, c = 1, 2, 3, 4
-assert_eq([a, b, c], [1, (2, 3), 4])
-
 a, [*b], c, *d = 1, [2, 3], 4, 5, 6
-assert_eq([a, b, c, d], [1, [2, 3], 4, (5, 6)])
-
-# destructuring modules
-{assert_eq} = util
+assert_eq([a, b, c, d], [1, [2, 3], 4, [5, 6]])

koatl-0.1.27/koatl/tests/e2e/base/record.tl

@@ -0,0 +1,24 @@
+import util.assert_eq
+
+assert_eq(
+    {a: 0}.keys() | list
+    ["a"]
+)
+
+assert_eq(
+    {(): 0}.keys() | list
+    [()]
+)
+
+assert_eq(
+    {(1): 0}.keys() | list
+    [1]
+)
+
+assert_eq(
+    {(
+        let x = 1
+        x
+    ): 0}.keys() | list
+    [1]
+)

{koatl-0.1.26 → koatl-0.1.27}/koatl/tests/e2e/base/scopes.tl

@@ -89,4 +89,16 @@ f = () =>
 
     A().f()
     assert_eq(A, 2)
+f()
+
+# Shadowing should work
+f = () =>
+    let x = 1
+    let x = x + 1
+    assert_eq(x, 2)
+
+    # but recursion should also work
+    let x = 3
+    let x = () => x.__name__
+    assert_eq(type(x()), str)
 f()

koatl-0.1.27/koatl/tests/e2e/prelude/aug_assign.tl

@@ -0,0 +1,13 @@
+import util.assert_eq
+
+x = 1
+x += 2
+assert_eq(x, 3)
+
+x = None
+x ??= 2
+assert_eq(x, 2)
+
+x = 4
+x |= $ + 2
+assert_eq(x, 6)

{koatl-0.1.26 → koatl-0.1.27}/koatl/tests/e2e/prelude/memo.tl

@@ -29,3 +29,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)
+
+# Indirect dependencies should be tracked as well.
+
+counts = 0
+
+f = (x, y) =>
+    memo:
+        counts = counts + 1
+        let other = () => y
+        x * other()
+
+ctx = Memo.Cache()
+assert_eq(f(10, 20).run(ctx), 200)
+assert_eq(f(10, 20).run(ctx), 200)
+assert_eq(f(10, 30).run(ctx), 300)
+assert_eq(f(10, 30).run(ctx), 300)
+assert_eq(counts, 2)

{koatl-0.1.26 → koatl-0.1.27}/koatl/tests/e2e/prelude/reader.tl

@@ -1,6 +1,6 @@
 import util.assert_eq
 
-{ask} = Reader
+ask = Reader.ask
 
 g = () =>
     @ask("c")

{koatl-0.1.26 → koatl-0.1.27}/koatl-core/parser/src/ast.rs

@@ -121,7 +121,9 @@ pub enum DeclType {
 #[derive(Debug, Clone)]
 pub enum Stmt<'a, TTree: Tree> {
     Decl(Vec<SIdent<'a>>, DeclType),
-    Assign(TTree::Expr, TTree::Expr, Option<DeclType>),
+    Assign(TTree::Expr, TTree::Expr, Option<BinaryOp>),
+    PatternAssign(TTree::Pattern, TTree::Expr, Option<DeclType>),
+
     Expr(TTree::Expr),
 
     Return(TTree::Expr),

{koatl-0.1.26 → koatl-0.1.27}/koatl-core/parser/src/lexer.rs

@@ -272,7 +272,8 @@ where
 
     fn parse_symbol(&mut self) -> TResult<'src, Spanned<Token<'src>>> {
         const POLYGRAMS: &[&str] = &[
-            "===", "<=>", "=>", "..", "==", "<>", "<=", ">=", "//", "**", "??", ".=",
+            "+=", "-=", "*=", "/=", "|=", "??=", "===", "<=>", "=>", "..", "==", "<>", "<=", ">=",
+            "//", "**", "??", ".=",
         ];
         const MONOGRAMS: &str = "[](){}<>.,;:!?@$%^&*+-=|\\/`~";
 

{koatl-0.1.26 → koatl-0.1.27}/koatl-core/parser/src/parser.rs

@@ -123,10 +123,9 @@ where
     just(Token::Symbol(symbol))
 }
 
-pub fn match_pattern<'tokens, 'src: 'tokens, TInput, PIdent, PQualIdent, PExpr, PLiteral>(
+pub fn match_pattern<'tokens, 'src: 'tokens, TInput, PIdent, PQualIdent, PLiteral>(
     ident: PIdent,
     qualified_ident: PQualIdent,
-    sexpr: PExpr,
     literal: PLiteral,
 ) -> (
     impl Parser<'tokens, TInput, SPattern<'src>, TExtra<'tokens, 'src>> + Clone,
@@ -137,7 +136,6 @@ where
     TInput: ValueInput<'tokens, Token = Token<'src>, Span = Span>,
     PIdent: Parser<'tokens, TInput, SIdent<'src>, TExtra<'tokens, 'src>> + Clone + 'tokens,
     PQualIdent: Parser<'tokens, TInput, SExpr<'src>, TExtra<'tokens, 'src>> + Clone + 'tokens,
-    PExpr: Parser<'tokens, TInput, SExpr<'src>, TExtra<'tokens, 'src>> + Clone + 'tokens,
     PLiteral: Parser<'tokens, TInput, SLiteral<'src>, TExtra<'tokens, 'src>> + Clone + 'tokens,
 {
     let mut pattern =
@@ -153,24 +151,16 @@ where
         if id.value.0 == "_" { None } else { Some(id) }
     }
 
+    let capture_pattern = ident
+        .clone()
+        .map(to_wildcard)
+        .map(Pattern::Capture)
+        .spanned_pattern()
+        .boxed();
+
     let value_pattern = symbol(".")
-        .to(1)
-        .or_not()
-        .then(qualified_ident.clone())
-        .try_map(|(q, value), _e| {
-            Ok(if let Expr::RawAttribute(..) = value.value {
-                Pattern::Value(value.indirect())
-            } else if q.is_some() {
-                Pattern::Value(value.indirect())
-            } else if let Expr::Ident(id) = value.value {
-                Pattern::Capture(to_wildcard(id))
-            } else {
-                return Err(Rich::custom(
-                    value.span,
-                    "Internal error: value pattern must be an identifier or attribute",
-                ));
-            })
-        })
+        .ignore_then(qualified_ident.clone())
+        .map(|value| Pattern::Value(value.indirect()))
         .spanned_pattern()
         .boxed();
 
@@ -230,9 +220,9 @@ where
                 .map(|id| Expr::Literal(Literal::Str(id.value.0).spanned(id.span)))
                 .spanned_expr(),
             literal.clone().map(Expr::Literal).spanned_expr(),
-            sexpr
+            qualified_ident
                 .clone()
-                .delimited_by_with_eol(symbol("("), symbol(")")),
+                .delimited_by(symbol("("), symbol(")")),
         ))
         .then_ignore(symbol(":"))
         .then(pattern.clone())
@@ -275,6 +265,7 @@ where
     let closed_pattern = choice((
         literal_pattern,
         class_pattern,
+        capture_pattern,
         value_pattern.clone(),
         group_pattern,
         sequence_pattern,
@@ -476,12 +467,23 @@ where
     })
 }
 
-pub fn statement<'tokens, 'src: 'tokens, TInput, PBody, PTuple, PExpr, PIdent, PPattern>(
+pub fn statement<
+    'tokens,
+    'src: 'tokens,
+    TInput,
+    PBody,
+    PTuple,
+    PExpr,
+    PIdent,
+    PNaryPattern,
+    PPattern,
+>(
     expr_or_inline_stmt_or_block: PBody,
     nary_tuple: PTuple,
     expr: PExpr,
     ident: PIdent,
-    nary_pattern: PPattern,
+    nary_pattern: PNaryPattern,
+    pattern: PPattern,
 ) -> (
     impl Parser<'tokens, TInput, SStmt<'src>, TExtra<'tokens, 'src>> + Clone,
     impl Parser<'tokens, TInput, SStmt<'src>, TExtra<'tokens, 'src>> + Clone,
@@ -492,6 +494,7 @@ where
     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,
+    PNaryPattern: Parser<'tokens, TInput, SPattern<'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();
@@ -511,33 +514,55 @@ where
         .map(|(decl, idents)| SStmtInner::Decl(idents, decl))
         .boxed();
 
-    let assign_lhs = nary_tuple.clone();
-    let inline_assign_lhs = expr.clone();
-
-    let assign_stmt = group((
+    let pattern_assign_stmt = group((
         decl_mod.clone().or_not(),
-        assign_lhs.clone(),
+        nary_pattern.clone(),
         symbol("=").ignore_then(nary_tuple.clone()),
     ))
-    .map(|(decl, lhs, rhs)| SStmtInner::Assign(lhs.indirect(), rhs.indirect(), decl))
+    .map(|(decl, pat, rhs)| SStmtInner::PatternAssign(pat.indirect(), rhs.indirect(), decl))
     .boxed();
 
-    let inline_assign_stmt = group((
+    let inline_pattern_assign_stmt = group((
         decl_mod.clone().or_not(),
-        inline_assign_lhs.clone(),
+        pattern.clone(),
         symbol("=").ignore_then(expr.clone()),
     ))
-    .map(|(decl, lhs, rhs)| SStmtInner::Assign(lhs.indirect(), rhs.indirect(), decl))
+    .map(|(decl, pat, rhs)| SStmtInner::PatternAssign(pat.indirect(), rhs.indirect(), decl))
     .boxed();
 
-    let expr_stmt = assign_lhs
-        .clone()
-        .map(|x| SStmtInner::Expr(x.indirect()))
-        .boxed();
+    let aug_op = choice((
+        symbol("+=").to(BinaryOp::Add),
+        symbol("-=").to(BinaryOp::Sub),
+        symbol("*=").to(BinaryOp::Mul),
+        symbol("/=").to(BinaryOp::Div),
+        symbol("|=").to(BinaryOp::Pipe),
+        symbol("??=").to(BinaryOp::Coalesce),
+    ))
+    .map(Some);
 
-    let inline_expr_stmt = inline_assign_lhs
-        .clone()
-        .map(|x| SStmtInner::Expr(x.indirect()))
+    let assign_op = choice((aug_op, symbol("=").to(None)));
+
+    let assign_stmt = group((
+        nary_tuple.clone(),
+        assign_op.clone().then(nary_tuple.clone()).or_not(),
+    ))
+    .map(|(lhs, rhs)| {
+        if let Some((op, rhs)) = rhs {
+            SStmtInner::Assign(lhs.indirect(), rhs.indirect(), op)
+        } else {
+            SStmtInner::Expr(lhs.indirect())
+        }
+    })
+    .boxed();
+
+    let inline_assign_stmt = group((expr.clone(), assign_op.clone().then(expr.clone()).or_not()))
+        .map(|(lhs, rhs)| {
+            if let Some((op, rhs)) = rhs {
+                SStmtInner::Assign(lhs.indirect(), rhs.indirect(), op)
+            } else {
+                SStmtInner::Expr(lhs.indirect())
+            }
+        })
         .boxed();
 
     let while_stmt = just(Token::Kw("while"))
@@ -689,8 +714,8 @@ where
     stmt.define(
         choice((
             decl_stmt.then_ignore(just(Token::Eol)),
+            pattern_assign_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)),
@@ -708,8 +733,8 @@ where
 
     inline_stmt.define(
         choice((
+            inline_pattern_assign_stmt,
             inline_assign_stmt,
-            inline_expr_stmt,
             while_stmt,
             for_stmt,
             inline_return_stmt,
@@ -861,6 +886,25 @@ where
     .boxed();
     // .memoized();
 
+    let tuple = choice((
+        symbol("(")
+            .then(symbol(")"))
+            .map(|_| Expr::Tuple(vec![]))
+            .spanned_expr(),
+        nary_tuple
+            .clone()
+            .delimited_by_with_eol(just(Token::Symbol("(")), just(Token::Symbol(")"))),
+    ))
+    .boxed();
+
+    let round_brackets = choice((
+        tuple.clone(),
+        block
+            .clone()
+            .delimited_by_with_eol(symbol("("), symbol(")")),
+    ))
+    .boxed();
+
     let mapping = enumeration(
         choice((
             symbol("**")
@@ -872,7 +916,7 @@ where
                     .map(|id| Expr::Literal(Literal::Str(id.value.0).spanned(id.span)))
                     .spanned_expr(),
                 literal_expr.clone(),
-                expr.clone().delimited_by_with_eol(symbol("("), symbol(")")),
+                round_brackets.clone(),
             ))
             .then_ignore(symbol(":"))
             .then(expr.clone())
@@ -973,12 +1017,8 @@ where
         )
         .boxed();
 
-    let (closed_pattern, as_pattern, nary_pattern) = match_pattern(
-        ident.clone(),
-        qualified_ident.clone(),
-        expr.clone(),
-        literal.clone(),
-    );
+    let (closed_pattern, as_pattern, nary_pattern) =
+        match_pattern(ident.clone(), qualified_ident.clone(), literal.clone());
 
     let classic_match = just(Token::Kw("match"))
         .ignore_then(expr.clone())
@@ -990,17 +1030,6 @@ where
         .as_context()
         .boxed();
 
-    let tuple = choice((
-        symbol("(")
-            .then(symbol(")"))
-            .map(|_| Expr::Tuple(vec![]))
-            .spanned_expr(),
-        nary_tuple
-            .clone()
-            .delimited_by_with_eol(just(Token::Symbol("(")), just(Token::Symbol(")"))),
-    ))
-    .boxed();
-
     enum ControlKw {
         Await,
         Yield,
@@ -1053,10 +1082,7 @@ where
             list.clone(),
             mapping,
             fstr,
-            tuple.clone(),
-            block
-                .clone()
-                .delimited_by_with_eol(symbol("("), symbol(")")),
+            round_brackets.clone(),
         ))
         .labelled("atom"),
     );
@@ -1438,6 +1464,7 @@ where
         expr.clone(),
         ident.clone(),
         nary_pattern.clone(),
+        as_pattern.clone(),
     );
 
     stmt.define(stmt_.labelled("statement").boxed());

{koatl-0.1.26 → koatl-0.1.27}/koatl-core/parser/src/util.rs

@@ -33,9 +33,9 @@ impl AstBuilder {
         &self,
         target: impl Into<Indirect<SExpr<'src>>>,
         value: impl Into<Indirect<SExpr<'src>>>,
-        modifier: DeclType,
+        aug_op: Option<BinaryOp>,
     ) -> SStmt<'src> {
-        Stmt::Assign(target.into(), value.into(), Some(modifier)).spanned(self.span)
+        Stmt::Assign(target.into(), value.into(), aug_op).spanned(self.span)
     }
 
     pub fn return_<'src>(&self, expr: impl IntoIndirect<SExpr<'src>>) -> SStmt<'src> {

{koatl-0.1.26 → koatl-0.1.27}/koatl-core/src/inference.rs

@@ -22,7 +22,11 @@ impl<'src, 'ast> SStmtExt<'src, 'ast> for Indirect<SStmt<'src>> {
     fn traverse(&'ast self, ctx: &mut InferenceCtx<'src, '_>) -> Type {
         match &self.value {
             Stmt::Expr(expr) => expr.traverse(ctx),
-            Stmt::Assign(lhs, rhs, _decl_type) => {
+            Stmt::PatternAssign(_lhs, rhs, _decl_type) => {
+                rhs.traverse(ctx);
+                Type::NoReturn
+            }
+            Stmt::Assign(lhs, rhs, _op) => {
                 lhs.traverse(ctx);
                 rhs.traverse(ctx);
                 Type::NoReturn

{koatl-0.1.26 → koatl-0.1.27}/koatl-core/src/py/ast.rs

@@ -66,7 +66,7 @@ pub enum PyStmt<'a> {
     Expr(SPyExpr<'a>),
     If(SPyExpr<'a>, PyBlock<'a>, Option<PyBlock<'a>>),
     Match(SPyExpr<'a>, Vec<PyMatchCase<'a>>),
-    Assign(SPyExpr<'a>, SPyExpr<'a>),
+    Assign(SPyExpr<'a>, SPyExpr<'a>, Option<PyBinaryOp>),
     Return(SPyExpr<'a>),
     Raise(Option<SPyExpr<'a>>),
     Assert(SPyExpr<'a>, Option<SPyExpr<'a>>),

{koatl-0.1.26 → koatl-0.1.27}/koatl-core/src/py/emit.rs

@@ -572,10 +572,15 @@ impl SPyStmt<'_> {
                 expr.emit_to(ctx, LOW_PREC)?;
                 ctx.emit_endl();
             }
-            PyStmt::Assign(target, value) => {
+            PyStmt::Assign(target, value, op) => {
                 ctx.emit_indent();
                 target.emit_to(ctx, LOW_PREC)?;
-                ctx.emit(" = ");
+                ctx.emit(" ");
+                if let Some(op) = op {
+                    op.emit_to(ctx);
+                } else {
+                }
+                ctx.emit("= ");
                 value.emit_to(ctx, LOW_PREC)?;
                 ctx.emit_endl();
             }

{koatl-0.1.26 → koatl-0.1.27}/koatl-core/src/py/util.rs

@@ -18,7 +18,16 @@ impl PyAstBuilder {
     }
 
     pub fn assign<'src>(&self, target: SPyExpr<'src>, value: SPyExpr<'src>) -> SPyStmt<'src> {
-        (PyStmt::Assign(target, value), self.span).into()
+        (PyStmt::Assign(target, value, None), self.span).into()
+    }
+
+    pub fn assign_modified<'src>(
+        &self,
+        target: SPyExpr<'src>,
+        value: SPyExpr<'src>,
+        op: Option<PyBinaryOp>,
+    ) -> SPyStmt<'src> {
+        (PyStmt::Assign(target, value, op), self.span).into()
     }
 
     pub fn return_<'src>(&self, expr: SPyExpr<'src>) -> SPyStmt<'src> {