snail-lang 0.5.2__cp310-abi3-macosx_11_0_arm64.whl

snail/__init__.py

@@ -0,0 +1,25 @@
+from ._native import __build_info__, compile, compile_ast, exec, parse
+
+
+def _resolve_version() -> str:
+    try:
+        from importlib.metadata import version
+
+        return version("snail-lang")
+    except Exception:  # pragma: no cover - during development
+        return "0.0.0"
+
+
+def __getattr__(name: str):
+    if name == "__version__":
+        value = _resolve_version()
+        globals()["__version__"] = value
+        return value
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted(list(globals().keys()) + ["__version__"])
+
+
+__all__ = ["compile", "compile_ast", "exec", "parse", "__version__", "__build_info__"]

snail/cli.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+
+import os
+import sys
+
+from . import __build_info__, compile_ast, exec
+
+_USAGE = (
+    "snail [options] -f <file> [args]...\n"
+    "       snail [options] <code> [args]..."
+)
+_DESCRIPTION = "Snail programming language interpreter"
+
+
+def _display_filename(filename: str) -> str:
+    if filename.startswith("snail:"):
+        return filename
+    return f"snail:{filename}"
+
+
+def _trim_internal_prefix(stack, internal_files: set[str]) -> None:
+    if not stack:
+        return
+    trim_count = 0
+    for frame in stack:
+        filename = frame.filename
+        if filename.startswith("snail:"):
+            break
+        if filename in internal_files:
+            trim_count += 1
+            continue
+        if os.path.isabs(filename) and os.path.abspath(filename) in internal_files:
+            trim_count += 1
+            continue
+        break
+    if 0 < trim_count < len(stack):
+        del stack[:trim_count]
+
+
+def _trim_traceback_exception(tb_exc, internal_files: set[str]) -> None:
+    _trim_internal_prefix(tb_exc.stack, internal_files)
+    cause = getattr(tb_exc, "__cause__", None)
+    if cause is not None:
+        _trim_traceback_exception(cause, internal_files)
+    context = getattr(tb_exc, "__context__", None)
+    if context is not None:
+        _trim_traceback_exception(context, internal_files)
+    for group_exc in getattr(tb_exc, "exceptions", ()) or ():
+        _trim_traceback_exception(group_exc, internal_files)
+
+
+def _install_trimmed_excepthook() -> None:
+    entrypoint = os.path.abspath(sys.argv[0])
+    cli_path = os.path.abspath(__file__)
+    internal_files = {entrypoint, cli_path}
+    original_excepthook = sys.excepthook
+
+    def _snail_excepthook(
+        exc_type: type[BaseException],
+        exc: BaseException,
+        tb: object,
+    ) -> None:
+        if exc_type is KeyboardInterrupt:
+            return original_excepthook(exc_type, exc, tb)
+        import traceback
+
+        tb_exc = traceback.TracebackException(
+            exc_type,
+            exc,
+            tb,
+            capture_locals=False,
+        )
+        _trim_traceback_exception(tb_exc, internal_files)
+        try:
+            import _colorize
+
+            colorize = _colorize.can_colorize(file=sys.stderr)
+        except Exception:
+            colorize = hasattr(sys.stderr, "isatty") and sys.stderr.isatty()
+        for line in tb_exc.format(colorize=colorize):
+            sys.stderr.write(line)
+
+    sys.excepthook = _snail_excepthook
+
+
+class _Args:
+    def __init__(self) -> None:
+        self.file: str | None = None
+        self.awk = False
+        self.no_print = False
+        self.no_auto_import = False
+        self.debug = False
+        self.version = False
+        self.help = False
+        self.args: list[str] = []
+
+
+def _print_help(file=sys.stdout) -> None:
+    print(f"usage: {_USAGE}", file=file)
+    print("", file=file)
+    print(_DESCRIPTION, file=file)
+    print("", file=file)
+    print("options:", file=file)
+    print("  -f <file>               read Snail source from file", file=file)
+    print("  -a, --awk               awk mode", file=file)
+    print("  -P, --no-print          disable auto-print of last expression", file=file)
+    print("  -I, --no-auto-import    disable auto-imports", file=file)
+    print("  --debug                 parse and compile, then print, do not run", file=file)
+    print("  -v, --version           show version and exit", file=file)
+    print("  -h, --help              show this help message and exit", file=file)
+
+
+def _parse_args(argv: list[str]) -> _Args:
+    args = _Args()
+    idx = 0
+    while idx < len(argv):
+        token = argv[idx]
+        if token == "--":
+            args.args = argv[idx + 1 :]
+            return args
+        if token == "-" or not token.startswith("-"):
+            args.args = argv[idx:]
+            return args
+        if token in ("-h", "--help"):
+            args.help = True
+            return args
+        if token in ("-v", "--version"):
+            args.version = True
+            idx += 1
+            continue
+        if token in ("-a", "--awk"):
+            args.awk = True
+            idx += 1
+            continue
+        if token in ("-P", "--no-print"):
+            args.no_print = True
+            idx += 1
+            continue
+        if token in ("-I", "--no-auto-import"):
+            args.no_auto_import = True
+            idx += 1
+            continue
+        if token == "--debug":
+            args.debug = True
+            idx += 1
+            continue
+        if token == "-f":
+            if idx + 1 >= len(argv):
+                raise ValueError("option -f requires an argument")
+            args.file = argv[idx + 1]
+            idx += 2
+            continue
+        raise ValueError(f"unknown option: {token}")
+    return args
+
+
+def _format_version(version: str, build_info: dict[str, object] | None) -> str:
+    display_version = version if version.startswith("v") else f"v{version}"
+    if not build_info:
+        return display_version
+    git_rev = build_info.get("git_rev")
+    if not git_rev:
+        return display_version
+
+    suffixes: list[str] = []
+    if build_info.get("dirty"):
+        suffixes.append("!dirty")
+    if build_info.get("untagged"):
+        suffixes.append("!untagged")
+
+    if suffixes:
+        return f"{display_version} ({git_rev}) {' '.join(suffixes)}"
+    return f"{display_version} ({git_rev})"
+
+
+def _get_version() -> str:
+    from . import __version__ as version
+
+    return version
+
+
+def main(argv: list[str] | None = None) -> int:
+    if argv is None:
+        _install_trimmed_excepthook()
+        argv = sys.argv[1:]
+
+    try:
+        namespace = _parse_args(argv)
+    except ValueError as exc:
+        _print_help(file=sys.stderr)
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+
+    if namespace.help:
+        _print_help()
+        return 0
+    if namespace.version:
+        print(_format_version(_get_version(), __build_info__))
+        return 0
+
+    mode = "awk" if namespace.awk else "snail"
+
+    if namespace.file:
+        from pathlib import Path
+
+        path = Path(namespace.file)
+        try:
+            source = path.read_text()
+        except OSError as exc:
+            print(f"failed to read {path}: {exc}", file=sys.stderr)
+            return 1
+        filename = str(path)
+        args = [filename, *namespace.args]
+    else:
+        if not namespace.args:
+            print("no input provided", file=sys.stderr)
+            return 1
+        source = namespace.args[0]
+        filename = "<cmd>"
+        args = ["--", *namespace.args[1:]]
+
+    if namespace.debug:
+        import ast
+        import builtins
+
+        python_ast = compile_ast(
+            source,
+            mode=mode,
+            auto_print=not namespace.no_print,
+            filename=filename,
+        )
+        builtins.compile(python_ast, _display_filename(filename), "exec")
+        print(ast.unparse(python_ast))
+        return 0
+
+    return exec(
+        source,
+        argv=args,
+        mode=mode,
+        auto_print=not namespace.no_print,
+        auto_import=not namespace.no_auto_import,
+        filename=filename,
+    )
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

snail/runtime/__init__.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import importlib
+
+__all__ = ["install_helpers", "AutoImportDict", "AUTO_IMPORT_NAMES"]
+
+# Names that can be auto-imported when first referenced.
+# Maps name -> (module, attribute) where attribute is None for whole-module imports.
+AUTO_IMPORT_NAMES: dict[str, tuple[str, str | None]] = {
+    # Whole module imports: import X
+    "sys": ("sys", None),
+    "os": ("os", None),
+    # Attribute imports: from X import Y
+    "Path": ("pathlib", "Path"),
+}
+
+
+class AutoImportDict(dict):
+    """A dict subclass that lazily imports allowed names on first access.
+
+    When a key lookup fails, if the key is in AUTO_IMPORT_NAMES,
+    the corresponding module/attribute is imported and stored in the dict.
+    Supports both whole-module imports (import sys) and attribute imports
+    (from pathlib import Path).
+    """
+
+    def __missing__(self, key: str) -> object:
+        if key in AUTO_IMPORT_NAMES:
+            module_name, attr_name = AUTO_IMPORT_NAMES[key]
+            module = importlib.import_module(module_name)
+            value = getattr(module, attr_name) if attr_name else module
+            self[key] = value
+            return value
+        raise KeyError(key)
+
+
+_compact_try = None
+_regex_search = None
+_regex_compile = None
+_subprocess_capture = None
+_subprocess_status = None
+_jmespath_query = None
+_js = None
+
+
+def _get_compact_try():
+    global _compact_try
+    if _compact_try is None:
+        from .compact_try import compact_try
+
+        _compact_try = compact_try
+    return _compact_try
+
+
+def _get_regex_search():
+    global _regex_search
+    if _regex_search is None:
+        from .regex import regex_search
+
+        _regex_search = regex_search
+    return _regex_search
+
+
+def _get_regex_compile():
+    global _regex_compile
+    if _regex_compile is None:
+        from .regex import regex_compile
+
+        _regex_compile = regex_compile
+    return _regex_compile
+
+
+def _get_subprocess_capture():
+    global _subprocess_capture
+    if _subprocess_capture is None:
+        from .subprocess import SubprocessCapture
+
+        _subprocess_capture = SubprocessCapture
+    return _subprocess_capture
+
+
+def _get_subprocess_status():
+    global _subprocess_status
+    if _subprocess_status is None:
+        from .subprocess import SubprocessStatus
+
+        _subprocess_status = SubprocessStatus
+    return _subprocess_status
+
+
+def _get_jmespath_query():
+    global _jmespath_query
+    if _jmespath_query is None:
+        from .structured_accessor import __snail_jmespath_query
+
+        _jmespath_query = __snail_jmespath_query
+    return _jmespath_query
+
+
+def _get_js():
+    global _js
+    if _js is None:
+        from .structured_accessor import js
+
+        _js = js
+    return _js
+
+
+def _lazy_compact_try(expr_fn, fallback_fn=None):
+    return _get_compact_try()(expr_fn, fallback_fn)
+
+
+def _lazy_regex_search(value, pattern):
+    return _get_regex_search()(value, pattern)
+
+
+def _lazy_regex_compile(pattern):
+    return _get_regex_compile()(pattern)
+
+
+def _lazy_subprocess_capture(cmd: str):
+    return _get_subprocess_capture()(cmd)
+
+
+def _lazy_subprocess_status(cmd: str):
+    return _get_subprocess_status()(cmd)
+
+
+def _lazy_jmespath_query(query: str):
+    return _get_jmespath_query()(query)
+
+
+def _lazy_js(input_data=None):
+    return _get_js()(input_data)
+
+
+def __snail_partial(func, /, *args, **kwargs):
+    import functools
+
+    return functools.partial(func, *args, **kwargs)
+
+
+def __snail_contains__(left, right):
+    method = getattr(right, "__snail_contains__", None)
+    if method is not None:
+        return method(left)
+    return left in right
+
+
+def __snail_contains_not__(left, right):
+    method = getattr(right, "__snail_contains__", None)
+    if method is not None:
+        return not bool(method(left))
+    return left not in right
+
+
+def install_helpers(globals_dict: dict) -> None:
+    globals_dict["__snail_compact_try"] = _lazy_compact_try
+    globals_dict["__snail_regex_search"] = _lazy_regex_search
+    globals_dict["__snail_regex_compile"] = _lazy_regex_compile
+    globals_dict["__SnailSubprocessCapture"] = _lazy_subprocess_capture
+    globals_dict["__SnailSubprocessStatus"] = _lazy_subprocess_status
+    globals_dict["__snail_jmespath_query"] = _lazy_jmespath_query
+    globals_dict["__snail_partial"] = __snail_partial
+    globals_dict["__snail_contains__"] = __snail_contains__
+    globals_dict["__snail_contains_not__"] = __snail_contains_not__
+    globals_dict["js"] = _lazy_js

snail/runtime/compact_try.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+
+def compact_try(expr_fn, fallback_fn=None):
+    try:
+        return expr_fn()
+    except Exception as exc:
+        if fallback_fn is None:
+            fallback_member = getattr(exc, "__fallback__", None)
+            if callable(fallback_member):
+                return fallback_member()
+            return None
+        return fallback_fn(exc)

snail/runtime/regex.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import re
+
+
+class SnailRegex:
+    def __init__(self, pattern: str) -> None:
+        self.pattern = pattern
+        self._regex = re.compile(pattern)
+
+    def search(self, value):
+        return regex_search(value, self._regex)
+
+    def __contains__(self, value):
+        return bool(self.__snail_contains__(value))
+
+    def __snail_contains__(self, value):
+        return self.search(value)
+
+    def __repr__(self) -> str:
+        return f"/{self.pattern}/"
+
+
+def regex_search(value, pattern):
+    if isinstance(pattern, SnailRegex):
+        return pattern.search(value)
+    if hasattr(pattern, "search"):
+        match = pattern.search(value)
+    else:
+        match = re.search(pattern, value)
+    if match is None:
+        return ()
+    return (match.group(0),) + match.groups()
+
+
+def regex_compile(pattern):
+    return SnailRegex(pattern)

snail/runtime/structured_accessor.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import json as _json
+import os as _os
+import sys as _sys
+
+def __snail_jmespath_query(query: str):
+    """Create a callable that applies JMESPath query.
+
+    Used by the $[query] syntax which lowers to __snail_jmespath_query(query).
+    """
+
+    import jmespath as _jmespath
+
+    def apply(data):
+        return _jmespath.search(query, data)
+
+    return apply
+
+
+def _parse_jsonl(content: str):
+    lines = [line for line in content.splitlines() if line.strip()]
+    if not lines:
+        return []
+
+    items = []
+    for line in lines:
+        try:
+            items.append(_json.loads(line))
+        except _json.JSONDecodeError as exc:
+            raise _json.JSONDecodeError(
+                f"Invalid JSONL line: {exc.msg}",
+                line,
+                exc.pos,
+            ) from exc
+    return items
+
+
+def js(input_data=None):
+    """Parse JSON from various input sources.
+
+    Returns the parsed Python object (dict, list, etc.) directly.
+    If called with no arguments, reads from stdin.
+    """
+    if input_data is None:
+        input_data = _sys.stdin
+
+    if isinstance(input_data, str):
+        try:
+            return _json.loads(input_data)
+        except _json.JSONDecodeError:
+            if _os.path.exists(input_data):
+                with open(input_data, "r", encoding="utf-8") as handle:
+                    content = handle.read()
+                try:
+                    return _json.loads(content)
+                except _json.JSONDecodeError:
+                    return _parse_jsonl(content)
+            else:
+                return _parse_jsonl(input_data)
+    elif hasattr(input_data, "read"):
+        content = input_data.read()
+        if isinstance(content, bytes):
+            content = content.decode("utf-8")
+        try:
+            return _json.loads(content)
+        except _json.JSONDecodeError:
+            return _parse_jsonl(content)
+    elif isinstance(input_data, (dict, list, int, float, bool)) or input_data is None:
+        return input_data
+    else:
+        raise TypeError(
+            f"js() input must be JSON-compatible, got {type(input_data).__name__}"
+        )

snail/runtime/subprocess.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import subprocess
+
+
+class SubprocessCapture:
+    def __init__(self, cmd: str) -> None:
+        self.cmd = cmd
+
+    def __call__(self, input_data=None):
+        try:
+            if input_data is None:
+                completed = subprocess.run(
+                    self.cmd,
+                    shell=True,
+                    check=True,
+                    text=True,
+                    stdout=subprocess.PIPE,
+                )
+            else:
+                if not isinstance(input_data, (str, bytes)):
+                    input_data = str(input_data)
+                completed = subprocess.run(
+                    self.cmd,
+                    shell=True,
+                    check=True,
+                    text=True,
+                    input=input_data,
+                    stdout=subprocess.PIPE,
+                )
+            return completed.stdout.rstrip("\n")
+        except subprocess.CalledProcessError as exc:
+
+            def __fallback(exc=exc):
+                raise exc
+
+            exc.__fallback__ = __fallback
+            raise
+
+
+class SubprocessStatus:
+    def __init__(self, cmd: str) -> None:
+        self.cmd = cmd
+
+    def __call__(self, input_data=None):
+        try:
+            if input_data is None:
+                subprocess.run(self.cmd, shell=True, check=True)
+            else:
+                if not isinstance(input_data, (str, bytes)):
+                    input_data = str(input_data)
+                subprocess.run(
+                    self.cmd,
+                    shell=True,
+                    check=True,
+                    text=True,
+                    input=input_data,
+                )
+            return 0
+        except subprocess.CalledProcessError as exc:
+
+            def __fallback(exc=exc):
+                return exc.returncode
+
+            exc.__fallback__ = __fallback
+            raise

snail_lang-0.5.2.dist-info/METADATA

@@ -0,0 +1,259 @@
+Metadata-Version: 2.4
+Name: snail-lang
+Version: 0.5.2
+Requires-Dist: jmespath>=1.0.1
+Requires-Dist: maturin>=1.5 ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'dev'
+Provides-Extra: dev
+License-File: LICENSE
+Summary: Snail programming language interpreter
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+<p align="center">
+  <img src="logo.png" alt="Snail logo" width="200">
+</p>
+<p align="center"><em>What do you get when you shove a snake in a shell?</em></p>
+
+<h1 align="center">Snail</h1>
+
+**Snail** is a programming language that compiles to Python, combining Python's familiarity and extensive libraries with Perl/awk-inspired syntax for quick scripts and one-liners.
+
+## Installing Snail
+
+Install [uv](https://docs.astral.sh/uv/getting-started/installation/) and then run:
+
+```bash
+uv tool install -p 3.12 snail-lang
+```
+
+That installs the `snail` CLI for your user; try it with `snail "print('hello')"` once the install completes.
+
+## ✨ What Makes Snail Unique
+
+### Curly Braces, Not Indentation
+
+Write Python logic without worrying about whitespace:
+
+```snail
+def process(items) {
+    for item in items {
+        if item > 0 { print(item) }
+        else { continue }
+    }
+}
+```
+
+Note, since it is jarring to write python with semicolons everywhere,
+semicolons are optional. You can separate statements with newlines.
+
+### Awk Mode
+
+Process files line-by-line with familiar awk semantics:
+
+```snail-awk("5\n4\n3\n2\n1\nbanana\n")
+BEGIN { total = 0 }
+/^[0-9]+/ { total = total + int($1) }
+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:
+
+```snail
+# Swallow exception, return None
+err = risky()?
+
+# Swallow exception, return exception object
+err = risky():$e?
+
+# Provide a fallback value (exception available as $e)
+value = js("malformed json"):{"error": "invalid json"}?
+details = fetch_url("foo.com"):"default html"?
+exception_info = fetch_url("example.com"):$e.http_response_code?
+
+# Access attributes directly
+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
+function calls. `x | y | z` becomes `z(y(x))`. This lets you stay in a
+shell mindset.
+
+```snail
+# Pipe data to subprocess stdin
+result = "hello\nworld" | $(grep hello)
+
+# Chain multiple transformations
+output = "foo\nbar" | $(grep foo) | $(wc -l)
+
+# Custom pipeline handlers
+class Doubler {
+    def __call__(self, x) { return x * 2 }
+}
+doubled = 21 | Doubler()  # yields 42
+```
+
+Arbitrary callables make up pipelines, even if they have multiple parameters.
+Snail supports this via placeholders.
+```snail
+greeting = "World" | greet("Hello ", _)  # greet("Hello ", "World")
+excited = "World" | greet(_, "!")        # greet("World", "!")
+formal = "World" | greet("Hello ", suffix=_)  # greet("Hello ", "World")
+```
+
+When a pipeline targets a call expression, the left-hand value is passed to the
+resulting callable. If the call includes a single `_` placeholder, Snail substitutes
+the piped value at that position (including keyword arguments). Only one
+placeholder is allowed in a piped call. Outside of pipeline calls, `_` remains a
+normal identifier.
+
+### Built-in Subprocess
+
+Shell commands are first-class citizens with capturing and non-capturing
+forms.
+
+```snail
+# Capture command output with interpolation
+greeting = $(echo hello {name})
+
+# Pipe data through commands
+result = "foo\nbar\nbaz" | $(grep bar) | $(cat -n)
+
+# Check command status
+@(make build)?  # returns exit code on failure instead of raising
+```
+
+
+### Regex Literals
+
+Snail supports first class patterns. Think of them as an infinte set.
+
+```snail
+if bad_email in /^[\w.]+@[\w.]+$/ {
+    print("Valid email")
+}
+
+# Compiled regex for reuse
+pattern = /\d{3}-\d{4}/
+match = pattern.search(phone)
+match2 = "555-1212" in pattern
+```
+
+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
+
+Parse and query JSON data with the `js()` function and structured pipeline accessor:
+
+```snail
+# Parse JSON and query with $[jmespath]
+
+# JSON query with JMESPath
+data = js($(curl -s https://api.github.com/repos/sudonym1/snail))
+counts = data | $[stargazers_count]
+
+# Inline parsing and querying
+result = js('{{"foo": 12}}') | $[foo]
+
+# JSONL parsing returns a list
+names = js('{{"name": "Ada"}}\n{{"name": "Lin"}}') | $[[*].name]
+```
+
+### Full Python Interoperability
+
+Snail compiles to Python AST—import any Python module, use any library, in any
+environment. Assuming that you are using Python 3.10 or later.
+
+## 🚀 Quick Start
+
+```bash
+# One-liner: arithmetic + interpolation
+snail 'name="Snail"; print("{name} says: {6 * 7}")'
+
+# JSON query with JMESPath
+snail 'js($(curl -s https://api.github.com/repos/sudonym1/snail)) | $[stargazers_count]'
+
+# Compact error handling with fallback
+snail 'result = int("oops"):"bad int {$e}"?; print(result)'
+
+# Regex match and capture
+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}") }'
+```
+
+## 📚 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
+
+## 🔌 Editor Support
+
+Vim/Neovim plugin with syntax highlighting, formatting, and run commands:
+
+```vim
+Plug 'sudonym1/snail', { 'rtp': 'extras/vim' }
+```
+
+See [extras/vim/README.md](extras/vim/README.md) for details. Tree-sitter grammar available in `extras/tree-sitter-snail/`.
+
+## 🛠️ Building from Source
+
+### Prerequisites
+
+**Python 3.10+** (required at runtime)
+
+Snail runs in-process via a Pyo3 extension module, so it uses the active Python environment.
+
+Installation per platform:
+- **Ubuntu/Debian**: `sudo apt install python3 python3-dev`
+- **Fedora/RHEL**: `sudo dnf install python3 python3-devel`
+- **macOS**: `brew install python@3.12` (or use the system Python 3)
+- **Windows**: Download from [python.org](https://www.python.org/downloads/)
+
+### Build, Test, and Install
+
+```bash
+# Clone the repository
+git clone https://github.com/sudonym1/snail.git
+cd snail
+
+make test
+make install
+```
+
+
+**Note on Proptests**: The `snail-proptest` crate contains property-based tests that are skipped by default to keep development iteration fast.
+

snail_lang-0.5.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+snail/__init__.py,sha256=wuFoVD7mdEm8z-zzbU5bBb2svxKRcuPfWx_hWcdxXFU,695
+snail/_native.abi3.so,sha256=p41cfjm7gqRUT9Polr6xDvrIhu2sjNxD3QUrOK_Y18I,1461008
+snail/cli.py,sha256=aB1PopuCP0ReJ-Odks-MVotf_GOpT-o5--gbmitsFIM,7200
+snail/runtime/__init__.py,sha256=P9bRT8oaXEwJPFbYbpPLSjHzU0eix1G1A808RGdLeo8,4461
+snail/runtime/compact_try.py,sha256=LFT41W1XPNamZfCqG6PpiHz4oKd3s24XvzjYo0G7Iok,380
+snail/runtime/regex.py,sha256=ciy6_HDkOHAJL2lip9T-OMqkzISYc37Jx4lm444RAJg,879
+snail/runtime/structured_accessor.py,sha256=nj5jWZ3K5tEjqxMxgTz5WUNIykLLvFEsmEZkJn7izbQ,2163
+snail/runtime/subprocess.py,sha256=-SrFrj5mXCjfSaqcm_93kG1WxWNc6jPKGpW7RKjpxJ8,1889
+snail_lang-0.5.2.dist-info/METADATA,sha256=zSVaOL9EvqFuUs86suni8G6OuOAW9FdVBsQRl00wDZY,7363
+snail_lang-0.5.2.dist-info/WHEEL,sha256=vZ12AMAE5CVtd8oYbYGrz3omfHuIZCNO_3P50V00s00,104
+snail_lang-0.5.2.dist-info/entry_points.txt,sha256=8u6pjHZtKGdaZQlr6yKbftplObC07caDZ44j5PIPU6M,39
+snail_lang-0.5.2.dist-info/licenses/LICENSE,sha256=erKVJCZPZ4jVaEjq4ZDw2OCXmmby5r1Z6xCpn2Akktc,1062
+snail_lang-0.5.2.dist-info/RECORD,,

snail_lang-0.5.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp310-abi3-macosx_11_0_arm64

snail_lang-0.5.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+snail=snail.cli:main

snail_lang-0.5.2.dist-info/licenses/LICENSE

@@ -0,0 +1,20 @@
+Copyright 2026 Seamus Connor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+