koatl 0.3.16__tar.gz → 0.3.18__tar.gz

{koatl-0.3.16 → koatl-0.3.18}/Cargo.lock

@@ -190,7 +190,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "koatl"
-version = "0.3.16"
+version = "0.3.18"
 dependencies = [
  "ariadne",
  "koatl-core",

{koatl-0.3.16 → koatl-0.3.18}/PKG-INFO

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

{koatl-0.3.16 → koatl-0.3.18}/koatl/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "koatl"
-version = "0.3.16"
+version = "0.3.18"
 edition = "2021"
 homepage = "https://koatl.org"
 

{koatl-0.3.16 → koatl-0.3.18}/koatl/python/koatl/std/iter.tl

@@ -260,6 +260,12 @@ export Iterable = class(Traversable, Trait):
     list = self =>
         list(self.iter)
 
+    set = self =>
+        set(self.iter)
+
+    tuple = self =>
+        tuple(self.iter)
+
     dict = self =>
         dict(self.iter)
 

{koatl-0.3.16 → koatl-0.3.18}/koatl/tests/e2e/base/placeholder.tl

@@ -34,4 +34,8 @@ assert_eq(3 | f($), 6)
 
 assert_eq(3 | [$, 2, 3], [3, 2, 3])
 f = [$, 2, 3]
-assert_eq(f(3), [3, 2, 3])
+assert_eq(f(3), [3, 2, 3])
+
+# placeholder guard regression
+
+assert_eq({}.($.__or__({1: 2}).__or__({3: 4})), {1: 2, 3: 4})

{koatl-0.3.16 → koatl-0.3.18}/koatl/tests/e2e/prelude/coal.tl

@@ -4,7 +4,7 @@ none = None
 assert_eq(none?(1)?(2), None)
 assert_eq(none?[1]?.a, None)
 assert_eq(none?.a, None)
-assert_eq(none?. (a), None)
+assert_eq(none?.(a), None)
 
 obj = (class:
     a = 1
@@ -13,7 +13,7 @@ obj = (class:
 assert_eq((x => x)?(1), 1)
 assert_eq([1]?[0], 1)
 assert_eq(obj?.a, 1)
-assert_eq(1?. ($ + 1), 2)
+assert_eq(1?.($ + 1), 2)
 
 assert_eq(None ?? 1, 1)
 assert_eq(int(5) ?? 1, 5)

{koatl-0.3.16 → koatl-0.3.18}/koatl/tests/e2e/prelude/try.tl

@@ -24,5 +24,5 @@ except _ =>
 
 assert_eq(check 1 matches Ok(1), True)
 
-assert_eq((check 5)?.($+1), Ok(6))
-assert_eq((check x)?.($+1) matches Err(), True)
+assert_eq((check 5)?.($ + 1), Ok(6))
+assert_eq((check x)?.($ + 1) matches Err(), True)

{koatl-0.3.16 → koatl-0.3.18}/koatl-core/src/ast.rs

@@ -205,8 +205,6 @@ pub enum Expr<'a, TTree: Tree> {
     Fn(Vec<ArgDefItem<'a, TTree>>, TTree::Expr),
     Fstr(Spanned<String>, Vec<(FmtExpr<TTree>, Spanned<String>)>),
 
-    // these are removed during desugaring
-    Decorated(TTree::Expr, TTree::Expr),
     Placeholder,
 }
 

{koatl-0.3.16 → koatl-0.3.18}/koatl-core/src/ast_builder.rs

@@ -162,10 +162,6 @@ impl AstBuilder {
         Expr::RawAttribute(value.indirect(), attr.into().spanned(self.span)).spanned(self.span)
     }
 
-    pub fn then<'src>(&self, left: SExpr<'src>, right: SExpr<'src>) -> SExpr<'src> {
-        Expr::ScopedAttribute(left.indirect(), right.indirect()).spanned(self.span)
-    }
-
     pub fn function<'src>(&self, args: Vec<SArgDefItem<'src>>, body: SExpr<'src>) -> SExpr<'src> {
         Expr::Fn(args, body.indirect()).spanned(self.span)
     }

{koatl-0.3.16 → koatl-0.3.18}/koatl-core/src/inference.rs

@@ -235,9 +235,9 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for Indirect<SExpr<'src>> {
                 expr.traverse(ctx);
                 Type::Any
             }
-            Expr::ScopedAttribute(expr, other) | Expr::MappedScopedAttribute(expr, other) => {
+            Expr::ScopedAttribute(expr, func) | Expr::MappedScopedAttribute(expr, func) => {
                 expr.traverse(ctx);
-                other.traverse(ctx);
+                func.traverse(ctx);
                 Type::Any
             }
             Expr::Checked(expr, _pattern) => {
@@ -265,7 +265,6 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for Indirect<SExpr<'src>> {
                 Type::Any
             }
             Expr::Literal(..) | Expr::Ident(..) => Type::Any,
-            Expr::Decorated(_, _) => panic!("Decorated expressions should not be traversed"),
             Expr::Placeholder => panic!("Placeholder expression should not be traversed"),
         };
 

{koatl-0.3.16 → koatl-0.3.18}/koatl-core/src/lift_cst.rs

@@ -274,9 +274,6 @@ impl<'src, 'tok> Lift<Indirect<ast::SExpr<'src>>> for cst::SExpr<'src, 'tok> {
                 ast::Expr::Fn(args_list, body.lift())
             }
             cst::Expr::Fstr { head, parts, .. } => lift_fstr(head, parts),
-            cst::Expr::Decorated {
-                expr, decorator, ..
-            } => ast::Expr::Decorated(expr.lift(), decorator.lift()),
             cst::Expr::Memo { async_kw, body, .. } => {
                 ast::Expr::Memo(body.lift(), async_kw.is_some())
             }
@@ -387,6 +384,13 @@ impl<'src, 'tok> Lift<Indirect<ast::SExpr<'src>>> for cst::SExpr<'src, 'tok> {
                     ast::Expr::ScopedAttribute(expr.lift(), rhs.lift())
                 }
             }
+            cst::Expr::Decorated {
+                expr, decorator, ..
+            } => {
+                let func = decorator.lift();
+                let arg = ast::CallItem::Arg(expr.lift());
+                ast::Expr::Call(func, vec![arg])
+            }
             cst::Expr::Checked { expr, pattern, .. } => {
                 ast::Expr::Checked(expr.lift(), pattern.as_ref().map(|p| p.lift()))
             }

{koatl-0.3.16 → koatl-0.3.18}/koatl-core/src/resolve_scopes.rs

@@ -1055,10 +1055,6 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
 
                 Expr::Checked(expr.traverse_guarded(state), pattern)
             }
-            Expr::Decorated(deco, expr) => Expr::Call(
-                deco.traverse(state),
-                vec![CallItem::Arg(expr.traverse(state))],
-            ),
             Expr::Matches(x, pattern) => {
                 let (pattern, meta) = pattern.traverse(state, false);
                 if !meta.captures.is_empty() {

{koatl-0.3.16 → koatl-0.3.18}/koatl-core/src/transform.rs

@@ -319,10 +319,6 @@ fn transform_assignment<'src, 'ast>(
                     cur_node = left;
                     decorators.push(right);
                 }
-                Expr::Decorated(deco, right) => {
-                    cur_node = right;
-                    decorators.push(deco);
-                }
                 Expr::Call(left, right) => {
                     if right.len() != 1 {
                         break;
@@ -2024,10 +2020,6 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
 
                 a.load_ident(name)
             }
-            Expr::Decorated(deco, expr) => a.call(
-                pre.bind(deco.transform(ctx)?),
-                vec![PyCallItem::Arg(pre.bind(expr.transform(ctx)?))],
-            ),
             Expr::Literal(lit) => a.literal(lit.value.transform(ctx)?),
             Expr::Ident(_) => {
                 let ident = ctx.py_ident(self);

{koatl-0.3.16 → koatl-0.3.18}/koatl-parser/src/cst.rs

@@ -509,11 +509,10 @@ pub enum Expr<TTree: Tree> {
         end: TTree::Token,
     },
 
-    // these are removed during desugaring
     Decorated {
-        expr: TTree::Expr,
-        op: TTree::Token,
         decorator: TTree::Expr,
+        op: TTree::Token,
+        expr: TTree::Expr,
     },
     Placeholder {
         token: TTree::Token,

{koatl-0.3.16 → koatl-0.3.18}/koatl-parser/src/parser.rs

@@ -1289,7 +1289,7 @@ impl<'src: 'tok, 'tok> ParseCtx<'src, 'tok> {
             },
             Decorator {
                 op: &'tok SToken<'src>,
-                decorator: SExpr<'src, 'tok>,
+                decorated: SExpr<'src, 'tok>,
             },
         }
 
@@ -1332,8 +1332,8 @@ impl<'src: 'tok, 'tok> ParseCtx<'src, 'tok> {
 
             let decorator = |ctx: &mut Self| {
                 let op = ctx.symbol("!")?;
-                let decorator = ctx.expr()?;
-                Ok(Postfix::Decorator { op, decorator })
+                let decorated = ctx.expr()?;
+                Ok(Postfix::Decorator { op, decorated })
             };
 
             let dot_attribute = |ctx: &mut Self| {
@@ -1438,7 +1438,7 @@ impl<'src: 'tok, 'tok> ParseCtx<'src, 'tok> {
                         question2,
                         attr,
                     },
-                    Postfix::Decorator { op, decorator } => {
+                    Postfix::Decorator { op, decorated } => {
                         if question.is_some() {
                             return Err(self.set_error(
                                 start,
@@ -1446,9 +1446,9 @@ impl<'src: 'tok, 'tok> ParseCtx<'src, 'tok> {
                             ));
                         }
                         Expr::Decorated {
-                            expr: expr.boxed(),
+                            expr: decorated.boxed(),
                             op,
-                            decorator: decorator.boxed(),
+                            decorator: expr.boxed(),
                         }
                     }
                 }

{koatl-0.3.16 → koatl-0.3.18}/koatl-parser/src/simple_fmt.rs

@@ -350,7 +350,7 @@ impl<'src, 'tok> SimpleFmt for SExprInner<'src, 'tok> {
             Expr::Decorated {
                 expr, decorator, ..
             } => {
-                format!("{} & {}", expr.simple_fmt(), decorator.simple_fmt())
+                format!("{}! {}", expr.simple_fmt(), decorator.simple_fmt())
             }
         }
     }

{koatl-0.3.16 → koatl-0.3.18}/python/koatl/std/iter.tl

@@ -260,6 +260,12 @@ export Iterable = class(Traversable, Trait):
     list = self =>
         list(self.iter)
 
+    set = self =>
+        set(self.iter)
+
+    tuple = self =>
+        tuple(self.iter)
+
     dict = self =>
         dict(self.iter)