koatl 0.3.15__tar.gz → 0.3.17__tar.gz

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

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

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

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

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

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

{koatl-0.3.15 → koatl-0.3.17}/koatl/python/koatl/prelude/__init__.tl

@@ -14,15 +14,14 @@ import koatl.std.(
 export std = LazyModule("koatl.std")
 export mod = RootModulesProxy()
 
-Extension.trait(Iterable)
-
-Extension.property(list, "len")! List.len.fget
+# Extensions
 
-Extension.property(object, "result")! self => Result(self)
+Extension.trait(Iterable)
 
 Extension.method(str, "match")! (regex, str) => Pattern(regex).match(str)
 Extension.method(str, "matches")! (str, regex) => Pattern(regex).match(str)
 
+Extension.property(list, "len")! List.len.fget
 Extension.method(list, "map")! (self, f) => self.iter.map(f).list()
 Extension.method(list, "filter")! (self, f) => self.iter.filter(f).list()
 
@@ -33,6 +32,8 @@ Extension.method(dict, "filter")! (self, f) => self.iter.filter(f).dict()
 Extension.method(dict, "filter_keys")! (self, f) => self.iter.filter([k, v] => f(k)).dict()
 Extension.method(dict, "filter_values")! (self, f) => self.iter.filter([k, v] => f(v)).dict()
 
+# Implementations for language features
+
 __tl__.do = koatl.std.control.do.do
 
 __tl__.op_map = koatl.std.control.result.op_map

{koatl-0.3.15 → koatl-0.3.17}/koatl/python/koatl/std/re.tl

@@ -20,7 +20,7 @@ export Pattern = class:
         if not isinstance(string, str):
             raise TypeError(f"Expected a string, but got {type(string).__name__}")
 
-        self.pattern.match(string, flags).result.map(Match)
+        self.pattern.match(string, flags).(Result).map(Match)
 
 export Match = collections.abc.Sequence.register! class:
     __slots__ = ("_match",)

{koatl-0.3.15 → koatl-0.3.17}/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.15 → koatl-0.3.17}/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.17/koatl/tests/test_re.tl

@@ -0,0 +1,204 @@
+import util.(assert_eq, fail)
+import koatl.std.re.(Pattern, Match)
+import koatl.std.control.(Ok, Err)
+
+# Basic pattern compilation and matching
+test_pattern_from_string = () =>
+    let pat = Pattern("hello")
+    assert_eq(pat.pattern.pattern, "hello")
+
+test_pattern_from_pattern = () =>
+    import re
+    let py_pat = re.compile("test")
+    let pat = Pattern(py_pat)
+    assert_eq(pat.pattern.pattern, "test")
+
+test_pattern_from_pattern_copy = () =>
+    let pat1 = Pattern("copy")
+    let pat2 = Pattern(pat1)
+    assert_eq(pat2.pattern.pattern, "copy")
+
+# Pattern.match() tests
+test_pattern_match_success = () =>
+    let pat = Pattern("\\d+")
+    let result = pat.match("123abc")
+    assert_eq(result.ok, True)
+
+test_pattern_match_failure = () =>
+    let pat = Pattern("\\d+")
+    let result = pat.match("abc")
+    assert_eq(result.ok, False)
+
+test_pattern_match_groups = () =>
+    let pat = Pattern("(\\d+)\\.(\\d+)")
+    if pat.match("123.456") matches Ok(m):
+        assert_eq(list(m), ["123", "456"])
+        assert_eq(m.match, "123.456")
+
+test_pattern_match_no_groups = () =>
+    let pat = Pattern("hello")
+    if pat.match("hello world") matches Ok(m):
+        assert_eq(list(m), [])
+        assert_eq(m.match, "hello")
+
+# String extension method tests
+test_str_match_success = () =>
+    let result = "\\w+".match("hello")
+    assert_eq(result.ok, True)
+    if result matches Ok(m):
+        assert_eq(m.match, "hello")
+
+test_str_match_failure = () =>
+    let result = "[a-z]+".match("123")
+    assert_eq(result.ok, False)
+
+test_str_match_with_groups = () =>
+    let result = "(\\d{3})-(\\d{4})".match("123-4567")
+    if result matches Ok(m):
+        assert_eq(m.match, "123-4567")
+        assert_eq(m[1], "123")
+        assert_eq(m[2], "4567")
+        assert_eq(list(m), ["123", "4567"])
+
+test_str_matches_alias = () =>
+    # matches is an alias for match
+    let result1 = "\\w+".match("test")
+    let result2 = "test".matches("\\w+")
+    assert_eq(result1.ok, True)
+    assert_eq(result2.ok, True)
+
+# Match object tests
+test_match_sequence_behavior = () =>
+    let pat = Pattern("(\\w+)@(\\w+)\\.(\\w+)")
+    if pat.match("user@example.com") matches Ok(m):
+        assert_eq(len(m), 3)
+        assert_eq(m[1], "user")
+        assert_eq(m[2], "example")
+        assert_eq(m[3], "com")
+
+test_match_iteration = () =>
+    let pat = Pattern("(\\d+),(\\d+),(\\d+)")
+    if pat.match("10,20,30") matches Ok(m):
+        let groups = []
+        for group in m:
+            groups.append(group)
+        assert_eq(groups, ["10", "20", "30"])
+
+test_match_full_match_property = () =>
+    let pat = Pattern("hello (\\w+)")
+    if pat.match("hello world!") matches Ok(m):
+        assert_eq(m.match, "hello world")
+        assert_eq(m[1], "world")
+
+# Complex regex patterns
+test_email_pattern = () =>
+    let email_pat = Pattern("([\\w.-]+)@([\\w.-]+)\\.([a-z]{2,})")
+    if email_pat.match("user.name@example.co.uk") matches Ok(m):
+        assert_eq(m[1], "user.name")
+        assert_eq(m[2], "example.co")
+        assert_eq(m[3], "uk")
+
+test_url_pattern = () =>
+    let url_pat = Pattern("https?://([\\w.-]+)(?:/([\\w/.-]*))?")
+    if url_pat.match("https://example.com/path/to/page") matches Ok(m):
+        assert_eq(m[1], "example.com")
+        assert_eq(m[2], "path/to/page")
+
+test_phone_pattern = () =>
+    let phone_pat = Pattern("\\(?(\\d{3})\\)?[-.]?(\\d{3})[-.]?(\\d{4})")
+    if phone_pat.match("(555) 123-4567") matches Ok(m):
+        assert_eq(list(m), ["555", "123", "4567"])
+
+# Edge cases
+test_empty_pattern = () =>
+    let pat = Pattern("")
+    let result = pat.match("anything")
+    assert_eq(result.ok, True)
+    if result matches Ok(m):
+        assert_eq(m.match, "")
+        assert_eq(list(m), [])
+
+test_match_at_start_only = () =>
+    let pat = Pattern("\\d+")
+    # match() only matches at the beginning of the string
+    assert_eq(pat.match("123abc").ok, True)
+    assert_eq(pat.match("abc123").ok, False)
+
+test_special_characters = () =>
+    let pat = Pattern("\\$\\d+\\.\\d{2}")
+    if pat.match("$19.99 total") matches Ok(m):
+        assert_eq(m.match, "$19.99")
+
+test_unicode_pattern = () =>
+    let pat = Pattern("[α-ω]+")
+    if pat.match("αβγδε") matches Ok(m):
+        assert_eq(m.match, "αβγδε")
+
+# Named groups aren't directly exposed in Match, but the full match object is accessible
+test_multiple_groups = () =>
+    let pat = Pattern("(\\d{4})-(\\d{2})-(\\d{2})")
+    if pat.match("2025-12-13") matches Ok(m):
+        assert_eq(m[1], "2025")
+        assert_eq(m[2], "12")
+        assert_eq(m[3], "13")
+        assert_eq(len(m), 3)
+
+# Result monad integration
+test_result_map = () =>
+    let result = "(\\d+)".match("123").map(m => m[1])
+    if result matches Ok(value):
+        assert_eq(value, "123")
+
+test_result_chaining = () =>
+    let result = "(\\d+)\\.(\\d+)".match("3.14")
+        .map(m => [m[1], m[2]])
+        .map([a, b] => [int(a), int(b)])
+
+    if result matches Ok([major, minor]):
+        assert_eq(major, 3)
+        assert_eq(minor, 14)
+
+test_result_or_else = () =>
+    let result = "\\d+".match("abc")
+    if result matches Err(_):
+        assert_eq(True, True)
+    else:
+        fail()
+
+# Pattern matching with matches expression
+test_matches_expression_success = () =>
+    if "(\\d+)".match("123") matches Ok(m):
+        assert_eq(m[1], "123")
+    else:
+        fail()
+
+test_matches_expression_failure = () =>
+    if "(\\d+)".match("abc") matches Ok(_):
+        fail()
+    else:
+        assert_eq(True, True)
+
+# Practical examples
+test_extract_version_numbers = () =>
+    let version_pat = Pattern("v?(\\d+)\\.(\\d+)\\.(\\d+)")
+    if version_pat.match("v1.2.3") matches Ok(m):
+        let [major, minor, patch] = list(m)
+        assert_eq(major, "1")
+        assert_eq(minor, "2")
+        assert_eq(patch, "3")
+
+test_parse_csv_line = () =>
+    let csv_pat = Pattern("([^,]+),([^,]+),([^,]+)")
+    if csv_pat.match("John,Doe,30") matches Ok(m):
+        assert_eq(list(m), ["John", "Doe", "30"])
+
+test_validate_hex_color = () =>
+    let hex_pat = Pattern("#([0-9a-fA-F]{6})")
+    assert_eq(hex_pat.match("#FF5733").ok, True)
+    assert_eq(hex_pat.match("#GG5733").ok, False)
+    assert_eq(hex_pat.match("FF5733").ok, False)
+
+test_extract_quoted_string = () =>
+    let quote_pat = Pattern('"([^"]*)"')
+    if quote_pat.match('"hello world"') matches Ok(m):
+        assert_eq(m[1], "hello world")

{koatl-0.3.15 → koatl-0.3.17}/koatl/tests/util/__init__.py

@@ -3,3 +3,9 @@ def assert_eq(received, expected):
 
 def assert_contains(haystack, needle):
     assert needle in haystack, f"Expected to find {needle} in {haystack}"
+
+def assert_true(value, message=None):
+    assert value is True, message or f"Expected True, but got {value}"
+
+def fail(message):
+    raise AssertionError(message)

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

@@ -186,16 +186,15 @@ 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>),
@@ -205,8 +204,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.15 → koatl-0.3.17}/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.15 → koatl-0.3.17}/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::CallNullable(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.15 → koatl-0.3.17}/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())
             }
@@ -382,11 +379,20 @@ impl<'src, 'tok> Lift<Indirect<ast::SExpr<'src>>> for cst::SExpr<'src, 'tok> {
                 ..
             } => {
                 if question.is_some() {
-                    ast::Expr::MappedScopedAttribute(expr.lift(), rhs.lift())
+                    ast::Expr::CallNullable(expr.lift(), rhs.lift())
                 } else {
-                    ast::Expr::ScopedAttribute(expr.lift(), rhs.lift())
+                    let func = rhs.lift();
+                    let arg = ast::CallItem::Arg(expr.lift());
+                    ast::Expr::Call(func, vec![arg])
                 }
             }
+            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.15 → koatl-0.3.17}/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() {
@@ -1446,14 +1442,14 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
 
                 return traversed;
             }
-            Expr::ScopedAttribute(expr, value) => {
-                Expr::ScopedAttribute(expr.traverse(state), value.traverse_guarded(state))
+            Expr::Call(a, items) => {
+                Expr::Call(a.traverse_guarded(state), traverse_call_items(state, items))
             }
-            Expr::MappedScopedAttribute(expr, value) => {
+            Expr::CallNullable(expr, value) => {
                 let (rhs, fn_ctx) =
                     with_phantom_fninfo(state, span, |state| value.traverse_guarded(state));
 
-                let traversed = Expr::MappedScopedAttribute(expr.traverse(state), rhs)
+                let traversed = Expr::CallNullable(expr.traverse(state), rhs)
                     .spanned(span)
                     .indirect();
 
@@ -1463,9 +1459,6 @@ 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.15 → koatl-0.3.17}/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;
@@ -1429,13 +1425,11 @@ 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),
         _ => {
@@ -1466,10 +1460,6 @@ 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)
             }
@@ -2024,10 +2014,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);
@@ -2039,14 +2025,30 @@ 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.15 → koatl-0.3.17}/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.15 → koatl-0.3.17}/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.15 → koatl-0.3.17}/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.15 → koatl-0.3.17}/python/koatl/prelude/__init__.tl

@@ -14,15 +14,14 @@ import koatl.std.(
 export std = LazyModule("koatl.std")
 export mod = RootModulesProxy()
 
-Extension.trait(Iterable)
-
-Extension.property(list, "len")! List.len.fget
+# Extensions
 
-Extension.property(object, "result")! self => Result(self)
+Extension.trait(Iterable)
 
 Extension.method(str, "match")! (regex, str) => Pattern(regex).match(str)
 Extension.method(str, "matches")! (str, regex) => Pattern(regex).match(str)
 
+Extension.property(list, "len")! List.len.fget
 Extension.method(list, "map")! (self, f) => self.iter.map(f).list()
 Extension.method(list, "filter")! (self, f) => self.iter.filter(f).list()
 
@@ -33,6 +32,8 @@ Extension.method(dict, "filter")! (self, f) => self.iter.filter(f).dict()
 Extension.method(dict, "filter_keys")! (self, f) => self.iter.filter([k, v] => f(k)).dict()
 Extension.method(dict, "filter_values")! (self, f) => self.iter.filter([k, v] => f(v)).dict()
 
+# Implementations for language features
+
 __tl__.do = koatl.std.control.do.do
 
 __tl__.op_map = koatl.std.control.result.op_map

{koatl-0.3.15 → koatl-0.3.17}/python/koatl/std/re.tl

@@ -20,7 +20,7 @@ export Pattern = class:
         if not isinstance(string, str):
             raise TypeError(f"Expected a string, but got {type(string).__name__}")
 
-        self.pattern.match(string, flags).result.map(Match)
+        self.pattern.match(string, flags).(Result).map(Match)
 
 export Match = collections.abc.Sequence.register! class:
     __slots__ = ("_match",)