snail-lang 0.7.4__tar.gz → 0.7.6__tar.gz

{snail_lang-0.7.4 → snail_lang-0.7.6}/Cargo.lock

@@ -312,25 +312,25 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "snail-ast"
-version = "0.7.4"
+version = "0.7.6"
 
 [[package]]
 name = "snail-error"
-version = "0.7.4"
+version = "0.7.6"
 dependencies = [
  "snail-ast",
 ]
 
 [[package]]
 name = "snail-lower"
-version = "0.7.4"
+version = "0.7.6"
 dependencies = [
  "snail-python",
 ]
 
 [[package]]
 name = "snail-parser"
-version = "0.7.4"
+version = "0.7.6"
 dependencies = [
  "pest",
  "pest_derive",
@@ -340,7 +340,7 @@ dependencies = [
 
 [[package]]
 name = "snail-python"
-version = "0.7.4"
+version = "0.7.6"
 dependencies = [
  "pyo3",
  "snail-ast",

{snail_lang-0.7.4 → snail_lang-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snail-lang
-Version: 0.7.4
+Version: 0.7.6
 Requires-Dist: astunparse>=1.6.3 ; python_full_version < '3.9'
 Requires-Dist: jmespath>=1.0.1
 Requires-Dist: maturin>=1.5 ; extra == 'dev'
@@ -323,7 +323,7 @@ Documentation is WIP
 
 ## 🔌 Editor Support
 
-Vim/Neovim plugin with syntax highlighting, formatting, and run commands:
+Vim/Neovim plugin with Tree-sitter-based highlighting (Neovim), formatting, and run commands:
 
 ```vim
 Plug 'sudonym1/snail', { 'rtp': 'extras/vim' }

{snail_lang-0.7.4 → snail_lang-0.7.6}/README.md

@@ -310,7 +310,7 @@ Documentation is WIP
 
 ## 🔌 Editor Support
 
-Vim/Neovim plugin with syntax highlighting, formatting, and run commands:
+Vim/Neovim plugin with Tree-sitter-based highlighting (Neovim), formatting, and run commands:
 
 ```vim
 Plug 'sudonym1/snail', { 'rtp': 'extras/vim' }

{snail_lang-0.7.4 → snail_lang-0.7.6}/crates/snail-ast/Cargo.toml

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

{snail_lang-0.7.4 → snail_lang-0.7.6}/crates/snail-error/Cargo.toml

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

{snail_lang-0.7.4 → snail_lang-0.7.6}/crates/snail-parser/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-parser"
-version = "0.7.4"
+version = "0.7.6"
 edition = "2024"
 readme = "README.md"
 

{snail_lang-0.7.4 → snail_lang-0.7.6}/crates/snail-python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-python"
-version = "0.7.4"
+version = "0.7.6"
 edition.workspace = true
 build = "build.rs"
 

{snail_lang-0.7.4 → snail_lang-0.7.6}/crates/snail-python/src/lib.rs

@@ -112,6 +112,8 @@ fn prepare_globals<'py>(
     filename: &str,
     argv: &[String],
     auto_import: bool,
+    awk_field_separators: Option<String>,
+    awk_include_whitespace: Option<bool>,
 ) -> PyResult<Bound<'py, PyAny>> {
     let runtime = py.import_bound("snail.runtime")?;
 
@@ -131,6 +133,16 @@ fn prepare_globals<'py>(
     sys.setattr("argv", PyList::new_bound(py, argv))?;
 
     runtime.call_method1("install_helpers", (&globals,))?;
+    let separators = awk_field_separators
+        .as_deref()
+        .filter(|value| !value.is_empty());
+    let separators_value = match separators {
+        Some(separators) => separators.into_py(py),
+        None => py.None().into_py(py),
+    };
+    globals.set_item("__snail_awk_field_separators", separators_value)?;
+    let include_whitespace = awk_include_whitespace.unwrap_or(separators.is_none());
+    globals.set_item("__snail_awk_include_whitespace", include_whitespace)?;
 
     Ok(globals)
 }
@@ -201,7 +213,7 @@ fn compile_ast_py(
 }
 
 #[pyfunction(name = "exec")]
-#[pyo3(signature = (source, *, argv = Vec::new(), mode = "snail", auto_print = true, auto_import = true, filename = "<snail>", begin_code = Vec::new(), end_code = Vec::new()))]
+#[pyo3(signature = (source, *, argv = Vec::new(), mode = "snail", auto_print = true, auto_import = true, filename = "<snail>", begin_code = Vec::new(), end_code = Vec::new(), field_separators = None, include_whitespace = None))]
 #[allow(clippy::too_many_arguments)]
 fn exec_py(
     py: Python<'_>,
@@ -213,6 +225,8 @@ fn exec_py(
     filename: &str,
     begin_code: Vec<String>,
     end_code: Vec<String>,
+    field_separators: Option<String>,
+    include_whitespace: Option<bool>,
 ) -> PyResult<i32> {
     let profile = profile_enabled();
     let total_start = Instant::now();
@@ -241,7 +255,14 @@ fn exec_py(
         log_profile("py_compile", compile_start.elapsed());
     }
     let globals_start = Instant::now();
-    let globals = prepare_globals(py, strip_display_prefix(filename), &argv, auto_import)?;
+    let globals = prepare_globals(
+        py,
+        strip_display_prefix(filename),
+        &argv,
+        auto_import,
+        field_separators,
+        include_whitespace,
+    )?;
     if profile {
         log_profile("prepare_globals", globals_start.elapsed());
     }

{snail_lang-0.7.4 → snail_lang-0.7.6}/crates/snail-python/src/lower/awk.rs

@@ -270,23 +270,36 @@ pub(crate) fn lower_awk_line_loop_with_auto_print(
         .call_node(
             "Call",
             vec![
-                builder
-                    .call_node(
-                        "Attribute",
-                        vec![
-                            name_expr(
-                                builder,
-                                SNAIL_AWK_LINE_PYVAR,
-                                span,
-                                builder.load_ctx().map_err(py_err_to_lower)?,
-                            )?,
-                            "split".to_string().into_py(builder.py()),
+                name_expr(
+                    builder,
+                    SNAIL_AWK_SPLIT_HELPER,
+                    span,
+                    builder.load_ctx().map_err(py_err_to_lower)?,
+                )?,
+                PyList::new_bound(
+                    builder.py(),
+                    vec![
+                        name_expr(
+                            builder,
+                            SNAIL_AWK_LINE_PYVAR,
+                            span,
                             builder.load_ctx().map_err(py_err_to_lower)?,
-                        ],
-                        span,
-                    )
-                    .map_err(py_err_to_lower)?,
-                PyList::empty_bound(builder.py()).into_py(builder.py()),
+                        )?,
+                        name_expr(
+                            builder,
+                            SNAIL_AWK_FIELD_SEPARATORS_PYVAR,
+                            span,
+                            builder.load_ctx().map_err(py_err_to_lower)?,
+                        )?,
+                        name_expr(
+                            builder,
+                            SNAIL_AWK_INCLUDE_WHITESPACE_PYVAR,
+                            span,
+                            builder.load_ctx().map_err(py_err_to_lower)?,
+                        )?,
+                    ],
+                )
+                .into_py(builder.py()),
                 PyList::empty_bound(builder.py()).into_py(builder.py()),
             ],
             span,

{snail_lang-0.7.4 → snail_lang-0.7.6}/crates/snail-python/src/lower/constants.rs

@@ -13,6 +13,7 @@ pub const SNAIL_INCR_ATTR: &str = "__snail_incr_attr";
 pub const SNAIL_INCR_INDEX: &str = "__snail_incr_index";
 pub const SNAIL_AUG_ATTR: &str = "__snail_aug_attr";
 pub const SNAIL_AUG_INDEX: &str = "__snail_aug_index";
+pub(crate) const SNAIL_AWK_SPLIT_HELPER: &str = "__snail_awk_split";
 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";
@@ -28,6 +29,8 @@ pub(crate) const SNAIL_AWK_MATCH: &str = "$m";
 pub(crate) const SNAIL_AWK_FIELDS: &str = "$f";
 pub(crate) const SNAIL_AWK_LINE_PYVAR: &str = "__snail_line";
 pub(crate) const SNAIL_AWK_FIELDS_PYVAR: &str = "__snail_fields";
+pub(crate) const SNAIL_AWK_FIELD_SEPARATORS_PYVAR: &str = "__snail_awk_field_separators";
+pub(crate) const SNAIL_AWK_INCLUDE_WHITESPACE_PYVAR: &str = "__snail_awk_include_whitespace";
 pub(crate) const SNAIL_AWK_NR_PYVAR: &str = "__snail_nr_user";
 pub(crate) const SNAIL_AWK_FNR_PYVAR: &str = "__snail_fnr_user";
 pub(crate) const SNAIL_AWK_PATH_PYVAR: &str = "__snail_path_user";

{snail_lang-0.7.4 → snail_lang-0.7.6}/crates/snail-python/src/lower/desugar.rs

@@ -553,26 +553,18 @@ impl LambdaHoister {
                 span: span.clone(),
             },
             Expr::Lambda { params, body, span } => {
-                if lambda_requires_def(params, body) {
-                    let params = self.desugar_params(params, prelude);
-                    let body = ensure_lambda_return(self.desugar_block(body));
-                    let name = self.next_lambda_name();
-                    prelude.push(Stmt::Def {
-                        name: name.clone(),
-                        params,
-                        body,
-                        span: span.clone(),
-                    });
-                    Expr::Name {
-                        name,
-                        span: span.clone(),
-                    }
-                } else {
-                    Expr::Lambda {
-                        params: params.clone(),
-                        body: body.clone(),
-                        span: span.clone(),
-                    }
+                let params = self.desugar_params(params, prelude);
+                let body = self.desugar_block(body);
+                let name = self.next_lambda_name();
+                prelude.push(Stmt::Def {
+                    name: name.clone(),
+                    params,
+                    body,
+                    span: span.clone(),
+                });
+                Expr::Name {
+                    name,
+                    span: span.clone(),
                 }
             }
             Expr::Compound { expressions, span } => Expr::Compound {
@@ -717,190 +709,3 @@ impl LambdaHoister {
         }
     }
 }
-
-fn lambda_requires_def(params: &[Parameter], body: &[Stmt]) -> bool {
-    if body.iter().any(|stmt| !matches!(stmt, Stmt::Expr { .. })) {
-        return true;
-    }
-
-    for param in params {
-        if let Parameter::Regular { default, .. } = param
-            && let Some(default) = default
-            && expr_contains_complex_lambda(default)
-        {
-            return true;
-        }
-    }
-
-    for stmt in body {
-        if let Stmt::Expr { value, .. } = stmt
-            && expr_contains_complex_lambda(value)
-        {
-            return true;
-        }
-    }
-
-    false
-}
-
-fn expr_contains_complex_lambda(expr: &Expr) -> bool {
-    match expr {
-        Expr::Yield { value, .. } => value
-            .as_ref()
-            .is_some_and(|expr| expr_contains_complex_lambda(expr)),
-        Expr::YieldFrom { expr, .. } => expr_contains_complex_lambda(expr),
-        Expr::Lambda { params, body, .. } => lambda_requires_def(params, body),
-        Expr::Unary { expr, .. } => expr_contains_complex_lambda(expr),
-        Expr::Binary { left, right, .. } => {
-            expr_contains_complex_lambda(left) || expr_contains_complex_lambda(right)
-        }
-        Expr::AugAssign { target, value, .. } => {
-            assign_target_contains_complex_lambda(target) || expr_contains_complex_lambda(value)
-        }
-        Expr::PrefixIncr { target, .. } | Expr::PostfixIncr { target, .. } => {
-            assign_target_contains_complex_lambda(target)
-        }
-        Expr::Compare {
-            left, comparators, ..
-        } => {
-            if expr_contains_complex_lambda(left) {
-                return true;
-            }
-            comparators.iter().any(expr_contains_complex_lambda)
-        }
-        Expr::IfExpr {
-            test, body, orelse, ..
-        } => {
-            expr_contains_complex_lambda(test)
-                || expr_contains_complex_lambda(body)
-                || expr_contains_complex_lambda(orelse)
-        }
-        Expr::TryExpr { expr, fallback, .. } => {
-            expr_contains_complex_lambda(expr)
-                || fallback
-                    .as_ref()
-                    .is_some_and(|expr| expr_contains_complex_lambda(expr))
-        }
-        Expr::Compound { expressions, .. } => expressions.iter().any(expr_contains_complex_lambda),
-        Expr::Regex { pattern, .. } => regex_pattern_contains_complex_lambda(pattern),
-        Expr::RegexMatch { value, pattern, .. } => {
-            expr_contains_complex_lambda(value) || regex_pattern_contains_complex_lambda(pattern)
-        }
-        Expr::Subprocess { parts, .. } => parts.iter().any(|part| match part {
-            SubprocessPart::Expr(expr) => expr_contains_complex_lambda(expr),
-            SubprocessPart::Text(_) => false,
-        }),
-        Expr::Call { func, args, .. } => {
-            if expr_contains_complex_lambda(func) {
-                return true;
-            }
-            args.iter().any(|arg| match arg {
-                Argument::Positional { value, .. }
-                | Argument::Keyword { value, .. }
-                | Argument::Star { value, .. }
-                | Argument::KwStar { value, .. } => expr_contains_complex_lambda(value),
-            })
-        }
-        Expr::Attribute { value, .. } => expr_contains_complex_lambda(value),
-        Expr::Index { value, index, .. } => {
-            expr_contains_complex_lambda(value) || expr_contains_complex_lambda(index)
-        }
-        Expr::Paren { expr, .. } => expr_contains_complex_lambda(expr),
-        Expr::List { elements, .. } | Expr::Tuple { elements, .. } => {
-            elements.iter().any(expr_contains_complex_lambda)
-        }
-        Expr::Set { elements, .. } => elements.iter().any(expr_contains_complex_lambda),
-        Expr::Dict { entries, .. } => entries.iter().any(|(key, value)| {
-            expr_contains_complex_lambda(key) || expr_contains_complex_lambda(value)
-        }),
-        Expr::Slice { start, end, .. } => {
-            start
-                .as_ref()
-                .is_some_and(|expr| expr_contains_complex_lambda(expr))
-                || end
-                    .as_ref()
-                    .is_some_and(|expr| expr_contains_complex_lambda(expr))
-        }
-        Expr::ListComp {
-            element, iter, ifs, ..
-        } => {
-            expr_contains_complex_lambda(element)
-                || expr_contains_complex_lambda(iter)
-                || ifs.iter().any(expr_contains_complex_lambda)
-        }
-        Expr::DictComp {
-            key,
-            value,
-            iter,
-            ifs,
-            ..
-        } => {
-            expr_contains_complex_lambda(key)
-                || expr_contains_complex_lambda(value)
-                || expr_contains_complex_lambda(iter)
-                || ifs.iter().any(expr_contains_complex_lambda)
-        }
-        Expr::FString { parts, .. } => parts.iter().any(fstring_part_contains_complex_lambda),
-        Expr::Name { .. }
-        | Expr::Placeholder { .. }
-        | Expr::Number { .. }
-        | Expr::String { .. }
-        | Expr::Bool { .. }
-        | Expr::None { .. }
-        | Expr::StructuredAccessor { .. }
-        | Expr::FieldIndex { .. } => false,
-    }
-}
-
-fn assign_target_contains_complex_lambda(target: &AssignTarget) -> bool {
-    match target {
-        AssignTarget::Name { .. } => false,
-        AssignTarget::Attribute { value, .. } => expr_contains_complex_lambda(value),
-        AssignTarget::Index { value, index, .. } => {
-            expr_contains_complex_lambda(value) || expr_contains_complex_lambda(index)
-        }
-        AssignTarget::Starred { target, .. } => assign_target_contains_complex_lambda(target),
-        AssignTarget::Tuple { elements, .. } | AssignTarget::List { elements, .. } => {
-            elements.iter().any(assign_target_contains_complex_lambda)
-        }
-    }
-}
-
-fn regex_pattern_contains_complex_lambda(pattern: &RegexPattern) -> bool {
-    match pattern {
-        RegexPattern::Literal(_) => false,
-        RegexPattern::Interpolated(parts) => parts.iter().any(fstring_part_contains_complex_lambda),
-    }
-}
-
-fn fstring_part_contains_complex_lambda(part: &FStringPart) -> bool {
-    match part {
-        FStringPart::Text(_) => false,
-        FStringPart::Expr(expr) => fstring_expr_contains_complex_lambda(expr),
-    }
-}
-
-fn fstring_expr_contains_complex_lambda(expr: &FStringExpr) -> bool {
-    if expr_contains_complex_lambda(expr.expr.as_ref()) {
-        return true;
-    }
-    expr.format_spec
-        .as_ref()
-        .is_some_and(|parts| parts.iter().any(fstring_part_contains_complex_lambda))
-}
-
-fn ensure_lambda_return(mut body: Vec<Stmt>) -> Vec<Stmt> {
-    let Some(last) = body.pop() else {
-        return body;
-    };
-    match last {
-        Stmt::Expr { value, span, .. } => {
-            body.push(Stmt::Return {
-                value: Some(value),
-                span,
-            });
-        }
-        other => body.push(other),
-    }
-    body
-}

{snail_lang-0.7.4 → snail_lang-0.7.6}/crates/snail-python/src/lower/expr.rs

@@ -10,7 +10,6 @@ use super::operators::{
     lower_unary_op,
 };
 use super::py_ast::{AstBuilder, py_err_to_lower};
-use super::stmt::lower_parameters;
 
 pub(crate) fn lower_expr(builder: &AstBuilder<'_>, expr: &Expr) -> Result<PyObject, LowerError> {
     lower_expr_with_exception(builder, expr, None)
@@ -782,9 +781,9 @@ pub(crate) fn lower_expr_with_exception(
                 .call_node("YieldFrom", vec![value], span)
                 .map_err(py_err_to_lower)
         }
-        Expr::Lambda { params, body, span } => {
-            lower_lambda_expr(builder, params, body, span, exception_name)
-        }
+        Expr::Lambda { .. } => Err(LowerError::new(
+            "def expressions should be desugared before lowering",
+        )),
         Expr::Compound { expressions, span } => {
             let mut lowered = Vec::new();
             for expr in expressions {
@@ -1431,83 +1430,6 @@ fn lower_subprocess_parts(
     Ok(lowered_parts)
 }
 
-fn lower_lambda_expr(
-    builder: &AstBuilder<'_>,
-    params: &[Parameter],
-    body: &[Stmt],
-    span: &SourceSpan,
-    exception_name: Option<&str>,
-) -> Result<PyObject, LowerError> {
-    let args = lower_parameters(builder, params, exception_name)?;
-    let body_expr = lower_lambda_body_expr(builder, body, span, exception_name)?;
-    builder
-        .call_node("Lambda", vec![args, body_expr], span)
-        .map_err(py_err_to_lower)
-}
-
-fn lower_lambda_body_expr(
-    builder: &AstBuilder<'_>,
-    body: &[Stmt],
-    span: &SourceSpan,
-    exception_name: Option<&str>,
-) -> Result<PyObject, LowerError> {
-    let mut lowered = Vec::new();
-    for stmt in body {
-        match stmt {
-            Stmt::Expr { value, .. } => {
-                lowered.push(lower_expr_with_exception(builder, value, exception_name)?);
-            }
-            _ => {
-                return Err(LowerError::new(
-                    "def expression bodies must contain only expression statements",
-                ));
-            }
-        }
-    }
-
-    if lowered.is_empty() {
-        return builder
-            .call_node(
-                "Constant",
-                vec![builder.py().None().into_py(builder.py())],
-                span,
-            )
-            .map_err(py_err_to_lower);
-    }
-
-    if lowered.len() == 1 {
-        return Ok(lowered.pop().unwrap());
-    }
-
-    let tuple_expr = builder
-        .call_node(
-            "Tuple",
-            vec![
-                PyList::new_bound(builder.py(), lowered).into_py(builder.py()),
-                builder.load_ctx().map_err(py_err_to_lower)?,
-            ],
-            span,
-        )
-        .map_err(py_err_to_lower)?;
-    let index_expr = builder
-        .call_node(
-            "UnaryOp",
-            vec![
-                lower_unary_op(builder, UnaryOp::Minus)?,
-                number_expr(builder, "1", span)?,
-            ],
-            span,
-        )
-        .map_err(py_err_to_lower)?;
-    subscript_expr(
-        builder,
-        tuple_expr,
-        index_expr,
-        builder.load_ctx().map_err(py_err_to_lower)?,
-        span,
-    )
-}
-
 fn lower_call_arguments(
     builder: &AstBuilder<'_>,
     args: &[Argument],

{snail_lang-0.7.4 → snail_lang-0.7.6}/crates/snail-python/src/lower/validate.rs

@@ -269,8 +269,8 @@ fn check_expr(expr: &Expr, in_function: bool) -> Result<(), LowerError> {
             for param in params {
                 check_param(param)?;
             }
-            // Lambdas lower to Python lambdas; disallow yield in their bodies.
-            check_stmts(body, false)?;
+            // Anonymous defs are hoisted to defs; allow yield in their bodies.
+            check_stmts(body, true)?;
         }
         Expr::Compound { expressions, .. } => {
             for expr in expressions {

{snail_lang-0.7.4 → snail_lang-0.7.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "snail-lang"
-version = "0.7.4"
+version = "0.7.6"
 description = "Snail programming language interpreter"
 readme = "README.md"
 requires-python = ">=3.8"

{snail_lang-0.7.4 → snail_lang-0.7.6}/python/snail/cli.py

@@ -8,8 +8,8 @@ from . import __build_info__, compile_ast, exec
 
 _USAGE = "snail [options] -f <file> [args]...\n       snail [options] <code> [args]..."
 _DESCRIPTION = "Snail programming language interpreter"
-_BOOLEAN_FLAGS = frozenset("amPIvh")
-_VALUE_FLAGS = frozenset("fbe")
+_BOOLEAN_FLAGS = frozenset("amPIvhW")
+_VALUE_FLAGS = frozenset("fbeF")
 
 
 def _display_filename(filename: str) -> str:
@@ -101,6 +101,8 @@ class _Args:
         self.help = False
         self.begin_code: list[str] = []
         self.end_code: list[str] = []
+        self.field_separators: list[str] = []
+        self.include_whitespace = False
         self.args: list[str] = []
 
 
@@ -123,6 +125,11 @@ def _print_help(file=None) -> None:
         "  -e, --end <code>         end block code (repeatable)",
         file=file,
     )
+    print(
+        "  -F, --field-separator <chars>  field separator characters (repeatable)",
+        file=file,
+    )
+    print("  -W, --whitespace        include whitespace as a separator", file=file)
     print(
         "  -P, --no-print          disable auto-print of implicit return value",
         file=file,
@@ -244,6 +251,11 @@ def _parse_args(argv: list[str]) -> _Args:
             code_found = True
             idx += 2
             continue
+        if token in ("-W", "--whitespace"):
+            args.include_whitespace = True
+            args.awk = True
+            idx += 1
+            continue
         if token in ("-b", "--begin"):
             if idx + 1 >= len(argv):
                 raise ValueError(f"option {token} requires an argument")
@@ -256,6 +268,13 @@ def _parse_args(argv: list[str]) -> _Args:
             args.end_code.append(argv[idx + 1])
             idx += 2
             continue
+        if token in ("-F", "--field-separator"):
+            if idx + 1 >= len(argv):
+                raise ValueError(f"option {token} requires an argument")
+            args.field_separators.append(argv[idx + 1])
+            args.awk = True
+            idx += 2
+            continue
         raise ValueError(f"unknown option: {token}")
     return args
 
@@ -394,6 +413,10 @@ def main(argv: Optional[list[str]] = None) -> int:
         print(output)
         return 0
 
+    separators = "".join(namespace.field_separators)
+    field_separators = separators if separators else None
+    include_whitespace = namespace.include_whitespace or field_separators is None
+
     return exec(
         source,
         argv=args,
@@ -403,6 +426,8 @@ def main(argv: Optional[list[str]] = None) -> int:
         filename=filename,
         begin_code=namespace.begin_code,
         end_code=namespace.end_code,
+        field_separators=field_separators,
+        include_whitespace=include_whitespace,
     )
 
 

{snail_lang-0.7.4 → snail_lang-0.7.6}/python/snail/runtime/__init__.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import importlib
+import re
 from typing import Optional
 
 __all__ = ["install_helpers", "AutoImportDict", "AUTO_IMPORT_NAMES"]
@@ -49,6 +50,7 @@ _incr_index = None
 _aug_attr = None
 _aug_index = None
 _env_map = None
+_awk_split_cache: dict[tuple[str, bool], re.Pattern[str]] = {}
 
 
 def _get_compact_try():
@@ -221,6 +223,28 @@ def _lazy_aug_index(obj, index, value, op: str):
     return _get_aug_index()(obj, index, value, op)
 
 
+def __snail_awk_split(line: str, separators: Optional[str], include_whitespace: bool):
+    if not separators:
+        return line.split()
+    if not include_whitespace:
+        if len(separators) == 1:
+            return line.split(separators)
+        regex = _awk_split_cache.get((separators, False))
+        if regex is None:
+            regex = re.compile(f"[{re.escape(separators)}]")
+            _awk_split_cache[(separators, False)] = regex
+        return regex.split(line)
+
+    stripped = line.strip()
+    if not stripped:
+        return []
+    regex = _awk_split_cache.get((separators, True))
+    if regex is None:
+        regex = re.compile(f"(?:\\s+|[{re.escape(separators)}])")
+        _awk_split_cache[(separators, True)] = regex
+    return regex.split(stripped)
+
+
 def __snail_partial(func, /, *args, **kwargs):
     import functools
 
@@ -255,6 +279,9 @@ def install_helpers(globals_dict: dict) -> None:
     globals_dict["__snail_incr_index"] = _lazy_incr_index
     globals_dict["__snail_aug_attr"] = _lazy_aug_attr
     globals_dict["__snail_aug_index"] = _lazy_aug_index
+    globals_dict["__snail_awk_split"] = __snail_awk_split
+    globals_dict["__snail_awk_field_separators"] = None
+    globals_dict["__snail_awk_include_whitespace"] = False
     globals_dict["__snail_env"] = _get_env_map()
     globals_dict["js"] = _lazy_js
     globals_dict["__SnailLazyText"] = _get_lazy_text_class()