snail-lang 0.4.1__tar.gz → 0.5.1__tar.gz

{snail_lang-0.4.1 → snail_lang-0.5.1}/Cargo.lock

@@ -485,11 +485,11 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "snail-ast"
-version = "0.4.1"
+version = "0.5.1"
 
 [[package]]
 name = "snail-core"
-version = "0.4.1"
+version = "0.5.1"
 dependencies = [
  "pyo3",
  "snail-ast",
@@ -500,14 +500,14 @@ dependencies = [
 
 [[package]]
 name = "snail-error"
-version = "0.4.1"
+version = "0.5.1"
 dependencies = [
  "snail-ast",
 ]
 
 [[package]]
 name = "snail-lower"
-version = "0.4.1"
+version = "0.5.1"
 dependencies = [
  "pyo3",
  "snail-ast",
@@ -516,7 +516,7 @@ dependencies = [
 
 [[package]]
 name = "snail-parser"
-version = "0.4.1"
+version = "0.5.1"
 dependencies = [
  "pest",
  "pest_derive",
@@ -526,7 +526,7 @@ dependencies = [
 
 [[package]]
 name = "snail-proptest"
-version = "0.4.1"
+version = "0.5.1"
 dependencies = [
  "proptest",
  "pyo3",
@@ -540,7 +540,7 @@ dependencies = [
 
 [[package]]
 name = "snail-python"
-version = "0.4.1"
+version = "0.5.1"
 dependencies = [
  "pyo3",
  "snail-core",

{snail_lang-0.4.1 → snail_lang-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snail-lang
-Version: 0.4.1
+Version: 0.5.1
 Requires-Dist: jmespath>=1.0.1
 Requires-Dist: maturin>=1.5 ; extra == 'dev'
 Requires-Dist: pytest ; extra == 'dev'
@@ -59,7 +59,6 @@ END { print("Sum:", total); assert total == 15}
 
 Built-in variables: `$0` (line), `$1`, `$2` etc (access fields), `$n` (line number), `$fn` (per-file line number), `$p` (file path), `$m` (last match).
 
-
 ### Compact Error Handling
 
 The `?` operator makes error handling terse yet expressive:
@@ -81,6 +80,25 @@ name = risky("")?.__class__.__name__
 args = risky("becomes a list"):[1,2,3]?[0]
 ```
 
+### Destructuring + `if let` / `while let`
+
+Unpack tuples and lists directly, including Python-style rest bindings:
+
+```snail
+x, *xs = [1, 2, 3]
+
+if let [head, *tail] = [1, 2, 3]; head > 0 {
+    print(head, tail)
+}
+```
+
+`if let`/`while let` only enter the block when the destructuring succeeds. A guard
+after `;` lets you add a boolean check that runs after the bindings are created.
+
+Note that this syntax is more powerful than the walrus operator as that does
+not allow for destructuring.
+
+
 ### Pipeline Operator
 
 The `|` operator enables data pipelining as syntactic sugar for nested
@@ -144,9 +162,12 @@ if bad_email in /^[\w.]+@[\w.]+$/ {
 # Compiled regex for reuse
 pattern = /\d{3}-\d{4}/
 match = pattern.search(phone)
+match2 = "555-1212" in pattern
 ```
 
-NOTE: this feature is WIP.
+Snail regexes don't return a match object, rather they return a tuple
+containing all of the match groups, including group 0. Both `search` and `in`
+return the same tuple (or `()` when there is no match).
 
 ### JSON Queries with JMESPath
 
@@ -184,28 +205,16 @@ snail 'js($(curl -s https://api.github.com/repos/sudonym1/snail)) | $[stargazers
 snail 'result = int("oops"):"bad int {$e}"?; print(result)'
 
 # Regex match and capture
-snail 'm = "user@example.com" in /^[\\w.]+@([\\w.]+)$/; if m { print(m[1]) }'
+snail 'if let [_, user, domain] = "user@example.com" in /^[\w.]+@([\w.]+)$/ { print(domain) }'
 
 # Awk mode: print line numbers for matches
 rg -n "TODO" README.md | snail --awk '/TODO/ { print("{$n}: {$0}") }'
 ```
 
-## 🏗️ Architecture
-
-**Key Components:**
-
-- **Parser**: Uses [Pest](https://pest.rs/) parser generator with PEG grammar defined in `src/snail.pest`
-- **AST**: Separate representations for regular Snail (`Program`) and awk mode (`AwkProgram`) with source spans for error reporting
-- **Lowering**: Transforms Snail AST into Python AST, emitting helper calls backed by `snail.runtime`
-  - `?` operator → `__snail_compact_try`
-  - `$(cmd)` subprocess capture → `__SnailSubprocessCapture`
-  - `@(cmd)` subprocess status → `__SnailSubprocessStatus`
-  - Regex literals → `__snail_regex_search` and `__snail_regex_compile`
-- **Execution**: Compiles Python AST directly for in-process execution
-- **CLI**: Python wrapper (`python/snail/cli.py`) that executes via the extension module
-
 ## 📚 Documentation
 
+Documentation is WIP
+
 - **[Language Reference](docs/REFERENCE.md)** — Complete syntax and semantics
 - **[examples/all_syntax.snail](examples/all_syntax.snail)** — Every feature in one file
 - **[examples/awk.snail](examples/awk.snail)** — Awk mode examples

{snail_lang-0.4.1 → snail_lang-0.5.1}/README.md

@@ -47,7 +47,6 @@ END { print("Sum:", total); assert total == 15}
 
 Built-in variables: `$0` (line), `$1`, `$2` etc (access fields), `$n` (line number), `$fn` (per-file line number), `$p` (file path), `$m` (last match).
 
-
 ### Compact Error Handling
 
 The `?` operator makes error handling terse yet expressive:
@@ -69,6 +68,25 @@ name = risky("")?.__class__.__name__
 args = risky("becomes a list"):[1,2,3]?[0]
 ```
 
+### Destructuring + `if let` / `while let`
+
+Unpack tuples and lists directly, including Python-style rest bindings:
+
+```snail
+x, *xs = [1, 2, 3]
+
+if let [head, *tail] = [1, 2, 3]; head > 0 {
+    print(head, tail)
+}
+```
+
+`if let`/`while let` only enter the block when the destructuring succeeds. A guard
+after `;` lets you add a boolean check that runs after the bindings are created.
+
+Note that this syntax is more powerful than the walrus operator as that does
+not allow for destructuring.
+
+
 ### Pipeline Operator
 
 The `|` operator enables data pipelining as syntactic sugar for nested
@@ -132,9 +150,12 @@ if bad_email in /^[\w.]+@[\w.]+$/ {
 # Compiled regex for reuse
 pattern = /\d{3}-\d{4}/
 match = pattern.search(phone)
+match2 = "555-1212" in pattern
 ```
 
-NOTE: this feature is WIP.
+Snail regexes don't return a match object, rather they return a tuple
+containing all of the match groups, including group 0. Both `search` and `in`
+return the same tuple (or `()` when there is no match).
 
 ### JSON Queries with JMESPath
 
@@ -172,28 +193,16 @@ snail 'js($(curl -s https://api.github.com/repos/sudonym1/snail)) | $[stargazers
 snail 'result = int("oops"):"bad int {$e}"?; print(result)'
 
 # Regex match and capture
-snail 'm = "user@example.com" in /^[\\w.]+@([\\w.]+)$/; if m { print(m[1]) }'
+snail 'if let [_, user, domain] = "user@example.com" in /^[\w.]+@([\w.]+)$/ { print(domain) }'
 
 # Awk mode: print line numbers for matches
 rg -n "TODO" README.md | snail --awk '/TODO/ { print("{$n}: {$0}") }'
 ```
 
-## 🏗️ Architecture
-
-**Key Components:**
-
-- **Parser**: Uses [Pest](https://pest.rs/) parser generator with PEG grammar defined in `src/snail.pest`
-- **AST**: Separate representations for regular Snail (`Program`) and awk mode (`AwkProgram`) with source spans for error reporting
-- **Lowering**: Transforms Snail AST into Python AST, emitting helper calls backed by `snail.runtime`
-  - `?` operator → `__snail_compact_try`
-  - `$(cmd)` subprocess capture → `__SnailSubprocessCapture`
-  - `@(cmd)` subprocess status → `__SnailSubprocessStatus`
-  - Regex literals → `__snail_regex_search` and `__snail_regex_compile`
-- **Execution**: Compiles Python AST directly for in-process execution
-- **CLI**: Python wrapper (`python/snail/cli.py`) that executes via the extension module
-
 ## 📚 Documentation
 
+Documentation is WIP
+
 - **[Language Reference](docs/REFERENCE.md)** — Complete syntax and semantics
 - **[examples/all_syntax.snail](examples/all_syntax.snail)** — Every feature in one file
 - **[examples/awk.snail](examples/awk.snail)** — Awk mode examples

{snail_lang-0.4.1 → snail_lang-0.5.1}/crates/snail-ast/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-ast"
-version = "0.4.1"
+version = "0.5.1"
 edition = "2024"
 readme = "README.md"
 

{snail_lang-0.4.1 → snail_lang-0.5.1}/crates/snail-ast/src/ast.rs

@@ -20,14 +20,14 @@ pub struct Program {
 #[derive(Debug, Clone, PartialEq)]
 pub enum Stmt {
     If {
-        cond: Expr,
+        cond: Condition,
         body: Vec<Stmt>,
-        elifs: Vec<(Expr, Vec<Stmt>)>,
+        elifs: Vec<(Condition, Vec<Stmt>)>,
         else_body: Option<Vec<Stmt>>,
         span: SourceSpan,
     },
     While {
-        cond: Expr,
+        cond: Condition,
         body: Vec<Stmt>,
         else_body: Option<Vec<Stmt>>,
         span: SourceSpan,
@@ -148,6 +148,29 @@ pub enum AssignTarget {
         index: Box<Expr>,
         span: SourceSpan,
     },
+    Starred {
+        target: Box<AssignTarget>,
+        span: SourceSpan,
+    },
+    Tuple {
+        elements: Vec<AssignTarget>,
+        span: SourceSpan,
+    },
+    List {
+        elements: Vec<AssignTarget>,
+        span: SourceSpan,
+    },
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Condition {
+    Expr(Box<Expr>),
+    Let {
+        target: Box<AssignTarget>,
+        value: Box<Expr>,
+        guard: Option<Box<Expr>>,
+        span: SourceSpan,
+    },
 }
 
 #[derive(Debug, Clone, PartialEq)]

{snail_lang-0.4.1 → snail_lang-0.5.1}/crates/snail-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-core"
-version = "0.4.1"
+version = "0.5.1"
 edition.workspace = true
 readme = "README.md"
 

{snail_lang-0.4.1 → snail_lang-0.5.1}/crates/snail-error/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-error"
-version = "0.4.1"
+version = "0.5.1"
 edition = "2024"
 readme = "README.md"
 

{snail_lang-0.4.1 → snail_lang-0.5.1}/crates/snail-lower/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-lower"
-version = "0.4.1"
+version = "0.5.1"
 edition = "2024"
 readme = "README.md"
 

{snail_lang-0.4.1 → snail_lang-0.5.1}/crates/snail-lower/src/constants.rs

@@ -7,6 +7,13 @@ pub const SNAIL_REGEX_SEARCH: &str = "__snail_regex_search";
 pub const SNAIL_REGEX_COMPILE: &str = "__snail_regex_compile";
 pub const SNAIL_JMESPATH_QUERY: &str = "__snail_jmespath_query";
 pub const SNAIL_PARTIAL_HELPER: &str = "__snail_partial";
+pub const SNAIL_CONTAINS_HELPER: &str = "__snail_contains__";
+pub const SNAIL_CONTAINS_NOT_HELPER: &str = "__snail_contains_not__";
+pub(crate) const SNAIL_LET_VALUE: &str = "__snail_let_value";
+pub(crate) const SNAIL_LET_OK: &str = "__snail_let_ok";
+pub(crate) const SNAIL_LET_KEEP: &str = "__snail_let_keep";
+pub(crate) const SNAIL_COMPARE_LEFT: &str = "__snail_compare_left";
+pub(crate) const SNAIL_COMPARE_RIGHT: &str = "__snail_compare_right";
 
 // Awk-related constants (public within crate)
 pub(crate) const SNAIL_AWK_NR: &str = "$n";

{snail_lang-0.4.1 → snail_lang-0.5.1}/crates/snail-lower/src/expr.rs

@@ -36,6 +36,44 @@ pub(crate) fn lower_assign_target(
                 .call_node("Subscript", vec![value_expr, index_expr, store_ctx], span)
                 .map_err(py_err_to_lower)
         }
+        AssignTarget::Starred { target, span } => {
+            let value = lower_assign_target(builder, target)?;
+            builder
+                .call_node("Starred", vec![value, store_ctx.clone()], span)
+                .map_err(py_err_to_lower)
+        }
+        AssignTarget::Tuple { elements, span } => {
+            let mut lowered = Vec::with_capacity(elements.len());
+            for element in elements {
+                lowered.push(lower_assign_target(builder, element)?);
+            }
+            builder
+                .call_node(
+                    "Tuple",
+                    vec![
+                        PyList::new_bound(builder.py(), lowered).into_py(builder.py()),
+                        store_ctx,
+                    ],
+                    span,
+                )
+                .map_err(py_err_to_lower)
+        }
+        AssignTarget::List { elements, span } => {
+            let mut lowered = Vec::with_capacity(elements.len());
+            for element in elements {
+                lowered.push(lower_assign_target(builder, element)?);
+            }
+            builder
+                .call_node(
+                    "List",
+                    vec![
+                        PyList::new_bound(builder.py(), lowered).into_py(builder.py()),
+                        store_ctx,
+                    ],
+                    span,
+                )
+                .map_err(py_err_to_lower)
+        }
     }
 }
 
@@ -63,6 +101,41 @@ pub(crate) fn lower_delete_target(
                 .call_node("Subscript", vec![value_expr, index_expr, del_ctx], span)
                 .map_err(py_err_to_lower)
         }
+        AssignTarget::Starred { .. } => Err(LowerError::new(
+            "starred targets are not valid in del statements",
+        )),
+        AssignTarget::Tuple { elements, span } => {
+            let mut lowered = Vec::with_capacity(elements.len());
+            for element in elements {
+                lowered.push(lower_delete_target(builder, element)?);
+            }
+            builder
+                .call_node(
+                    "Tuple",
+                    vec![
+                        PyList::new_bound(builder.py(), lowered).into_py(builder.py()),
+                        del_ctx,
+                    ],
+                    span,
+                )
+                .map_err(py_err_to_lower)
+        }
+        AssignTarget::List { elements, span } => {
+            let mut lowered = Vec::with_capacity(elements.len());
+            for element in elements {
+                lowered.push(lower_delete_target(builder, element)?);
+            }
+            builder
+                .call_node(
+                    "List",
+                    vec![
+                        PyList::new_bound(builder.py(), lowered).into_py(builder.py()),
+                        del_ctx,
+                    ],
+                    span,
+                )
+                .map_err(py_err_to_lower)
+        }
     }
 }
 
@@ -116,6 +189,145 @@ fn lower_regex_pattern_expr(
     }
 }
 
+fn lower_contains_call(
+    builder: &AstBuilder<'_>,
+    helper_name: &str,
+    left: PyObject,
+    right: PyObject,
+    span: &SourceSpan,
+) -> Result<PyObject, LowerError> {
+    let func = name_expr(
+        builder,
+        helper_name,
+        span,
+        builder.load_ctx().map_err(py_err_to_lower)?,
+    )?;
+    let args = vec![left, right];
+    builder
+        .call_node(
+            "Call",
+            vec![
+                func,
+                PyList::new_bound(builder.py(), args).into_py(builder.py()),
+                PyList::empty_bound(builder.py()).into_py(builder.py()),
+            ],
+            span,
+        )
+        .map_err(py_err_to_lower)
+}
+
+fn lower_compare_pair(
+    builder: &AstBuilder<'_>,
+    left: PyObject,
+    op: CompareOp,
+    right: PyObject,
+    span: &SourceSpan,
+) -> Result<PyObject, LowerError> {
+    match op {
+        CompareOp::In => lower_contains_call(builder, SNAIL_CONTAINS_HELPER, left, right, span),
+        CompareOp::NotIn => {
+            lower_contains_call(builder, SNAIL_CONTAINS_NOT_HELPER, left, right, span)
+        }
+        _ => {
+            let op = lower_compare_op(builder, op)?;
+            builder
+                .call_node(
+                    "Compare",
+                    vec![
+                        left,
+                        PyList::new_bound(builder.py(), vec![op]).into_py(builder.py()),
+                        PyList::new_bound(builder.py(), vec![right]).into_py(builder.py()),
+                    ],
+                    span,
+                )
+                .map_err(py_err_to_lower)
+        }
+    }
+}
+
+fn named_expr(
+    builder: &AstBuilder<'_>,
+    name: &str,
+    value: PyObject,
+    span: &SourceSpan,
+) -> Result<PyObject, LowerError> {
+    let target = name_expr(
+        builder,
+        name,
+        span,
+        builder.store_ctx().map_err(py_err_to_lower)?,
+    )?;
+    builder
+        .call_node("NamedExpr", vec![target, value], span)
+        .map_err(py_err_to_lower)
+}
+
+fn lower_compare_chain(
+    builder: &AstBuilder<'_>,
+    left: &Expr,
+    ops: &[CompareOp],
+    comparators: &[Expr],
+    span: &SourceSpan,
+    exception_name: Option<&str>,
+) -> Result<PyObject, LowerError> {
+    if ops.len() != comparators.len() {
+        return Err(LowerError::new(
+            "comparison ops must match comparator count",
+        ));
+    }
+    if ops.is_empty() {
+        return Err(LowerError::new("comparison missing operator"));
+    }
+
+    let left_expr = lower_expr_with_exception(builder, left, exception_name)?;
+    let right_expr = lower_expr_with_exception(builder, &comparators[0], exception_name)?;
+    let left_named = named_expr(builder, SNAIL_COMPARE_LEFT, left_expr, span)?;
+    let right_named = named_expr(builder, SNAIL_COMPARE_RIGHT, right_expr, span)?;
+    let mut comparisons = Vec::with_capacity(ops.len());
+    comparisons.push(lower_compare_pair(
+        builder,
+        left_named,
+        ops[0],
+        right_named,
+        span,
+    )?);
+
+    for (index, op) in ops.iter().enumerate().skip(1) {
+        let prev_right = name_expr(
+            builder,
+            SNAIL_COMPARE_RIGHT,
+            span,
+            builder.load_ctx().map_err(py_err_to_lower)?,
+        )?;
+        let left_named = named_expr(builder, SNAIL_COMPARE_LEFT, prev_right, span)?;
+        let right_expr = lower_expr_with_exception(builder, &comparators[index], exception_name)?;
+        let right_named = named_expr(builder, SNAIL_COMPARE_RIGHT, right_expr, span)?;
+        comparisons.push(lower_compare_pair(
+            builder,
+            left_named,
+            *op,
+            right_named,
+            span,
+        )?);
+    }
+
+    if comparisons.len() == 1 {
+        return Ok(comparisons.remove(0));
+    }
+
+    let op = lower_bool_op(builder, BinaryOp::And)?;
+    builder
+        .call_node(
+            "BoolOp",
+            vec![
+                op,
+                PyList::new_bound(builder.py(), comparisons).into_py(builder.py()),
+            ],
+            span,
+        )
+        .map_err(py_err_to_lower)
+}
+
 fn lower_fstring_parts(
     builder: &AstBuilder<'_>,
     parts: &[FStringPart],
@@ -404,26 +616,14 @@ pub(crate) fn lower_expr_with_exception(
             comparators,
             span,
         } => {
-            let left_expr = lower_expr_with_exception(builder, left, exception_name)?;
-            let ops = ops
-                .iter()
-                .map(|op| lower_compare_op(builder, *op))
-                .collect::<Result<Vec<_>, _>>()?;
-            let comparators = comparators
-                .iter()
-                .map(|expr| lower_expr_with_exception(builder, expr, exception_name))
-                .collect::<Result<Vec<_>, _>>()?;
-            builder
-                .call_node(
-                    "Compare",
-                    vec![
-                        left_expr,
-                        PyList::new_bound(builder.py(), ops).into_py(builder.py()),
-                        PyList::new_bound(builder.py(), comparators).into_py(builder.py()),
-                    ],
-                    span,
-                )
-                .map_err(py_err_to_lower)
+            if ops.len() == 1 {
+                let left_expr = lower_expr_with_exception(builder, left, exception_name)?;
+                let right_expr =
+                    lower_expr_with_exception(builder, &comparators[0], exception_name)?;
+                lower_compare_pair(builder, left_expr, ops[0], right_expr, span)
+            } else {
+                lower_compare_chain(builder, left, ops, comparators, span, exception_name)
+            }
         }
         Expr::IfExpr {
             test,
@@ -613,31 +813,20 @@ pub(crate) fn lower_expr_with_exception(
         Expr::Attribute { value, attr, span } => {
             let value = lower_expr_with_exception(builder, value, exception_name)?;
             if attr.chars().all(|ch| ch.is_ascii_digit()) {
-                let group_index = attr
+                let index = attr
                     .parse::<i32>()
                     .map_err(|_| LowerError::new(format!("Invalid match group index: .{attr}")))?;
-                let group_attr = builder
+                let index_expr = number_expr(builder, &index.to_string(), span)?;
+                return builder
                     .call_node(
-                        "Attribute",
+                        "Subscript",
                         vec![
                             value,
-                            "group".into_py(builder.py()),
+                            index_expr,
                             builder.load_ctx().map_err(py_err_to_lower)?,
                         ],
                         span,
                     )
-                    .map_err(py_err_to_lower)?;
-                let index_expr = number_expr(builder, &group_index.to_string(), span)?;
-                return builder
-                    .call_node(
-                        "Call",
-                        vec![
-                            group_attr,
-                            PyList::new_bound(builder.py(), vec![index_expr]).into_py(builder.py()),
-                            PyList::empty_bound(builder.py()).into_py(builder.py()),
-                        ],
-                        span,
-                    )
                     .map_err(py_err_to_lower);
             }
             builder