koatl 0.3.17__tar.gz → 0.3.19__tar.gz

{koatl-0.3.17 → koatl-0.3.19}/Cargo.lock

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

{koatl-0.3.17 → koatl-0.3.19}/PKG-INFO

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

{koatl-0.3.17 → koatl-0.3.19}/koatl/Cargo.toml

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

{koatl-0.3.17 → koatl-0.3.19}/koatl/python/koatl/std/iter.tl

@@ -84,16 +84,20 @@ export Iterable = class(Traversable, Trait):
 
         impl()
 
-    flat_map = (self, f) => itertools.chain.from_iterable(self.map(f))
+    flat_map = (self, f=None) =>
+        if f === None:
+            itertools.chain.from_iterable(self.iter)
+        else:
+            itertools.chain.from_iterable(self.iter.map(f))
 
-    reverse = self => reversed(list(self.iter))
+    reversed = self => reversed(list(self.iter))
 
-    sort = (self, key=None, reverse=False) =>
+    sorted = (self, key=None, reverse=False) =>
         sorted(self.iter, key=key, reverse=reverse)
 
     copy = self => itertools.tee(self.iter)
 
-    count = (self, f=None) =>
+    tally = (self, f=None) =>
         let acc = 0
         if f === None:
             for _ in self:
@@ -187,7 +191,7 @@ export Iterable = class(Traversable, Trait):
         impl()
 
     join = (self, sep="") =>
-        sep.join(self.map(str))
+        sep.join(self.iter.map(str))
 
     sum = self =>
         let acc = 0
@@ -260,6 +264,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.17 → koatl-0.3.19}/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.17 → koatl-0.3.19}/koatl/tests/test_iterable.tl

@@ -57,11 +57,14 @@ test_all = () =>
     assert_eq([].all(x => x > 0), True)
     assert_eq([True, True, True].all(x => x), True)
 
-test_count = () =>
-    # count() works on Iterable trait via .iter
-    assert_eq([1, 2, 3, 4, 5].iter.count(x => x > 2), 3)
-    assert_eq([1, 2, 3, 4, 5].iter.count(x => x %% 2 == 0), 2)
-    assert_eq([1, 2, 3].iter.count(x => x > 10), 0)
+test_tally = () =>
+    # tally() works on Iterable trait via .iter
+    assert_eq([1, 2, 3, 4, 5].iter.tally(), 5)
+    assert_eq([].iter.tally(), 0)
+    assert_eq((..10).tally(), 10)
+    assert_eq([1, 2, 3, 4, 5].iter.tally(x => x > 2), 3)
+    assert_eq([1, 2, 3, 4, 5].iter.tally(x => x %% 2 == 0), 2)
+    assert_eq([1, 2, 3].iter.tally(x => x > 10), 0)
 
 test_take = () =>
     assert_eq([1, 2, 3, 4, 5].take(3).list(), [1, 2, 3])
@@ -104,16 +107,15 @@ test_cycle = () =>
     assert_eq([1, 2, 3].cycle().take(7).list(), [1, 2, 3, 1, 2, 3, 1])
     assert_eq([5].cycle().take(3).list(), [5, 5, 5])
 
-test_reverse = () =>
-    # reverse() is a method on Iterable trait, accessed via .iter
-    assert_eq(list([1, 2, 3, 4, 5].iter.reverse()), [5, 4, 3, 2, 1])
-    assert_eq(list([1].iter.reverse()), [1])
-    assert_eq(list([].iter.reverse()), [])
+test_reversed = () =>
+    assert_eq(list([1, 2, 3, 4, 5].reversed()), [5, 4, 3, 2, 1])
+    assert_eq(list([1].reversed()), [1])
+    assert_eq(list([].reversed()), [])
 
-test_sort = () =>
-    assert_eq([3, 1, 4, 1, 5].iter.sort().list(), [1, 1, 3, 4, 5])
-    assert_eq(["c", "a", "b"].iter.sort().list(), ["a", "b", "c"])
-    assert_eq([].iter.sort().list(), [])
+test_sorted = () =>
+    assert_eq([3, 1, 4, 1, 5].iter.sorted().list(), [1, 1, 3, 4, 5])
+    assert_eq(["c", "a", "b"].iter.sorted().list(), ["a", "b", "c"])
+    assert_eq([].iter.sorted().list(), [])
 
 test_join = () =>
     assert_eq(["a", "b", "c"].join(", "), "a, b, c")

{koatl-0.3.17 → koatl-0.3.19}/koatl-core/src/ast.rs

@@ -186,15 +186,16 @@ pub enum Expr<'a, TTree: Tree> {
     Call(TTree::Expr, Vec<CallItem<'a, TTree>>),
     Subscript(TTree::Expr, Vec<ListItem<TTree>>),
     RawAttribute(TTree::Expr, SIdent<'a>),
+    ScopedAttribute(TTree::Expr, TTree::Expr),
     Attribute(TTree::Expr, SIdent<'a>),
     MaybeAttribute(TTree::Expr, SIdent<'a>),
 
     MappedCall(TTree::Expr, Vec<CallItem<'a, TTree>>),
     MappedSubscript(TTree::Expr, Vec<ListItem<TTree>>),
     MappedRawAttribute(TTree::Expr, SIdent<'a>),
+    MappedScopedAttribute(TTree::Expr, TTree::Expr),
     MappedAttribute(TTree::Expr, SIdent<'a>),
     MappedMaybeAttribute(TTree::Expr, SIdent<'a>),
-    CallNullable(TTree::Expr, TTree::Expr),
 
     Try(TTree::Expr, Vec<MatchCase<TTree>>, Option<TTree::Expr>),
     Checked(TTree::Expr, Option<TTree::Pattern>),

{koatl-0.3.17 → koatl-0.3.19}/koatl-core/src/inference.rs

@@ -235,7 +235,7 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for Indirect<SExpr<'src>> {
                 expr.traverse(ctx);
                 Type::Any
             }
-            Expr::CallNullable(expr, func) => {
+            Expr::ScopedAttribute(expr, func) | Expr::MappedScopedAttribute(expr, func) => {
                 expr.traverse(ctx);
                 func.traverse(ctx);
                 Type::Any

{koatl-0.3.17 → koatl-0.3.19}/koatl-core/src/lift_cst.rs

@@ -379,11 +379,9 @@ impl<'src, 'tok> Lift<Indirect<ast::SExpr<'src>>> for cst::SExpr<'src, 'tok> {
                 ..
             } => {
                 if question.is_some() {
-                    ast::Expr::CallNullable(expr.lift(), rhs.lift())
+                    ast::Expr::MappedScopedAttribute(expr.lift(), rhs.lift())
                 } else {
-                    let func = rhs.lift();
-                    let arg = ast::CallItem::Arg(expr.lift());
-                    ast::Expr::Call(func, vec![arg])
+                    ast::Expr::ScopedAttribute(expr.lift(), rhs.lift())
                 }
             }
             cst::Expr::Decorated {

{koatl-0.3.17 → koatl-0.3.19}/koatl-core/src/resolve_scopes.rs

@@ -1442,14 +1442,14 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
 
                 return traversed;
             }
-            Expr::Call(a, items) => {
-                Expr::Call(a.traverse_guarded(state), traverse_call_items(state, items))
+            Expr::ScopedAttribute(expr, value) => {
+                Expr::ScopedAttribute(expr.traverse(state), value.traverse_guarded(state))
             }
-            Expr::CallNullable(expr, value) => {
+            Expr::MappedScopedAttribute(expr, value) => {
                 let (rhs, fn_ctx) =
                     with_phantom_fninfo(state, span, |state| value.traverse_guarded(state));
 
-                let traversed = Expr::CallNullable(expr.traverse(state), rhs)
+                let traversed = Expr::MappedScopedAttribute(expr.traverse(state), rhs)
                     .spanned(span)
                     .indirect();
 
@@ -1459,6 +1459,9 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
 
                 return traversed;
             }
+            Expr::Call(a, items) => {
+                Expr::Call(a.traverse(state), traverse_call_items(state, items))
+            }
             Expr::MappedCall(a, call_items) => {
                 let (rhs, fn_ctx) = with_phantom_fninfo(state, span, |state| {
                     traverse_call_items(state, call_items)

{koatl-0.3.17 → koatl-0.3.19}/koatl-core/src/transform.rs

@@ -1425,11 +1425,13 @@ fn transform_postfix_expr<'src, 'ast>(
         Expr::RawAttribute(obj, _) => (false, obj),
         Expr::Subscript(obj, _) => (false, obj),
         Expr::Call(obj, _) => (false, obj),
+        Expr::ScopedAttribute(obj, _) => (false, obj),
         Expr::Attribute(obj, _) => (false, obj),
         Expr::MaybeAttribute(obj, _) => (false, obj),
         Expr::MappedRawAttribute(obj, _) => (true, obj),
         Expr::MappedSubscript(obj, _) => (true, obj),
         Expr::MappedCall(obj, _) => (true, obj),
+        Expr::MappedScopedAttribute(obj, _) => (true, obj),
         Expr::MappedAttribute(obj, _) => (true, obj),
         Expr::MappedMaybeAttribute(obj, _) => (true, obj),
         _ => {
@@ -1460,6 +1462,10 @@ fn transform_postfix_expr<'src, 'ast>(
                 let t = inner_pre.bind(transform_subscript_items(ctx, &list, &expr.span)?);
                 a.subscript(lhs, t, access_ctx)
             }
+            Expr::ScopedAttribute(_, rhs) | Expr::MappedScopedAttribute(_, rhs) => {
+                let t = inner_pre.bind(rhs.transform(ctx)?);
+                a.call(t, vec![PyCallItem::Arg(lhs)])
+            }
             Expr::RawAttribute(_, attr) | Expr::MappedRawAttribute(_, attr) => {
                 a.attribute(lhs, attr.value.escape(), access_ctx)
             }
@@ -2025,30 +2031,14 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
             | Expr::MappedCall(..)
             | Expr::Subscript(..)
             | Expr::MappedSubscript(..)
+            | Expr::ScopedAttribute(..)
+            | Expr::MappedScopedAttribute(..)
             | Expr::Attribute(..)
             | Expr::MappedAttribute(..)
             | Expr::MaybeAttribute(..)
             | Expr::MappedMaybeAttribute(..) => {
                 pre.bind(transform_postfix_expr(ctx, self, access_ctx)?)
             }
-            Expr::CallNullable(obj, func) => {
-                let a = PyAstBuilder::new(span);
-                let obj_transformed = pre.bind(obj.transform(ctx)?);
-                let func_transformed = pre.bind(func.transform(ctx)?);
-
-                let maparg = ctx.create_aux_var("maparg", span.start);
-
-                a.call(
-                    a.tl_builtin("op_map"),
-                    vec![
-                        a.call_arg(obj_transformed),
-                        a.call_arg(a.lambda(
-                            PyArgList::simple_args(vec![(maparg.clone().into(), None)]),
-                            a.call(func_transformed, vec![a.call_arg(a.load_ident(maparg))]),
-                        )),
-                    ],
-                )
-            }
             Expr::With(pattern, value, body) => {
                 let temp_var = ctx.create_aux_var("with", span.start);
                 let value = pre.bind(value.transform(ctx)?);

{koatl-0.3.17 → koatl-0.3.19}/python/koatl/std/iter.tl

@@ -84,16 +84,20 @@ export Iterable = class(Traversable, Trait):
 
         impl()
 
-    flat_map = (self, f) => itertools.chain.from_iterable(self.map(f))
+    flat_map = (self, f=None) =>
+        if f === None:
+            itertools.chain.from_iterable(self.iter)
+        else:
+            itertools.chain.from_iterable(self.iter.map(f))
 
-    reverse = self => reversed(list(self.iter))
+    reversed = self => reversed(list(self.iter))
 
-    sort = (self, key=None, reverse=False) =>
+    sorted = (self, key=None, reverse=False) =>
         sorted(self.iter, key=key, reverse=reverse)
 
     copy = self => itertools.tee(self.iter)
 
-    count = (self, f=None) =>
+    tally = (self, f=None) =>
         let acc = 0
         if f === None:
             for _ in self:
@@ -187,7 +191,7 @@ export Iterable = class(Traversable, Trait):
         impl()
 
     join = (self, sep="") =>
-        sep.join(self.map(str))
+        sep.join(self.iter.map(str))
 
     sum = self =>
         let acc = 0
@@ -260,6 +264,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)