koatl 0.3.18__tar.gz → 0.3.20__tar.gz

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

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

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

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

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

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

{koatl-0.3.18 → koatl-0.3.20}/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

{koatl-0.3.18 → koatl-0.3.20}/koatl/src/emit_py.rs

@@ -708,11 +708,17 @@ impl<'src> PyExprExt<'src> for SPyExpr<'src> {
                         PyFstrPart::Str(s) => {
                             values.push(ctx.ast_node("Constant", (s.as_ref(),), &self.tl_span)?);
                         }
-                        PyFstrPart::Expr(expr, _format_spec) => {
+                        PyFstrPart::Expr(expr, format_spec) => {
                             let expr_ast = expr.emit_py(ctx)?;
+                            let format_spec_ast = if let Some(spec) = format_spec {
+                                spec.emit_py(ctx)?
+                            } else {
+                                ctx.py.None()
+                            };
+
                             values.push(ctx.ast_node(
                                 "FormattedValue",
-                                (expr_ast, -1, ctx.py.None()),
+                                (expr_ast, -1, format_spec_ast),
                                 &self.tl_span,
                             )?);
                         }

koatl-0.3.20/koatl/tests/e2e/base/fstr.tl

@@ -0,0 +1,51 @@
+import util.assert_eq
+
+assert_eq(f"{1}", "1")
+
+x = 1
+
+fstr = f"x = {x + 1}"
+assert_eq(fstr, "x = 2")
+
+fstr = f"x = {(y => y)(x)}"
+assert_eq(fstr, "x = 1")
+
+fstr = f"={(
+    let a = 1
+    let b = 2
+    let c = 3
+    a * b * c
+)}="
+assert_eq(fstr, "=6=")
+
+assert_eq(f"{{}}", "{}")
+assert_eq(f"{{{1}}}", "{1}")
+
+assert_eq(f"""
+
+{{1}}
+{2 * 5}""", "\n\n{1}\n10")
+
+# Test format specifiers
+num = 42
+assert_eq(f"{num%d}", "42")
+assert_eq(f"{num%05d}", "00042")
+assert_eq(f"{num%>5d}", "   42")
+assert_eq(f"{num%<5d}", "42   ")
+assert_eq(f"{num%^5d}", " 42  ")
+
+pi = 3.14159
+assert_eq(f"{pi%.2f}", "3.14")
+assert_eq(f"{pi%.4f}", "3.1416")
+
+hex_num = 255
+assert_eq(f"{hex_num%x}", "ff")
+assert_eq(f"{hex_num%X}", "FF")
+assert_eq(f"{hex_num%#x}", "0xff")
+
+# Test multiple format specs in one string
+assert_eq(f"{num%05d} and {pi%.2f}", "00042 and 3.14")
+
+# Test format spec with expressions
+assert_eq(f"{1 + 1%d}", "2")
+assert_eq(f"{(10 * 5)%03d}", "050")

{koatl-0.3.18 → koatl-0.3.20}/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.18 → koatl-0.3.20}/koatl-parser/src/lexer.rs

@@ -970,9 +970,11 @@ impl<'src> TokenizeCtx<'src> {
                 seen_quotes += 1;
 
                 if seen_quotes == ending_char_count {
-                    let span = self.span_since(&marker);
+                    // Use ending_marker for the span/slice end position, not current cursor,
+                    // because we may have consumed some ending quotes already
+                    let span = Span::new(marker..ending_marker);
                     tokens.push(SToken::new(
-                        Token::FstrInner(self.slice_since(&marker), current_str),
+                        Token::FstrInner(&self.input[marker..ending_marker], current_str),
                         span,
                         Vec::new(),
                     ));

{koatl-0.3.18 → koatl-0.3.20}/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

koatl-0.3.18/koatl/tests/e2e/base/fstr.tl

@@ -1,27 +0,0 @@
-import util.assert_eq
-
-assert_eq(f"{1}", "1")
-
-x = 1
-
-fstr = f"x = {x+1}"
-assert_eq(fstr, "x = 2")
-
-fstr = f"x = {(y => y)(x)}"
-assert_eq(fstr, "x = 1")
-
-fstr = f"={(
-    let a = 1
-    let b = 2
-    let c = 3
-    a * b * c
-)}="
-assert_eq(fstr, "=6=")
-
-assert_eq(f"{{}}", "{}")
-assert_eq(f"{{{1}}}", "{1}")
-
-assert_eq(f"""
-
-{{1}}
-{2 * 5}""", "\n\n{1}\n10")