bend-python 0.1.0__py3-none-any.whl

bend_python/__init__.py

@@ -0,0 +1,24 @@
+"""Build native Python extensions whose application code is written in Bend."""
+
+from .library import get_include, library_path, vendor
+
+BEND_VERSION = "2.0.28"
+
+__all__ = [
+    "BEND_VERSION",
+    "BendBuildExt",
+    "BendExtension",
+    "get_include",
+    "library_path",
+    "vendor",
+]
+
+
+def __getattr__(name):
+    # Installing a binary wheel or vendoring its Bend sources needs no build
+    # dependencies. Only extension authors need setuptools in their build env.
+    if name in {"BendBuildExt", "BendExtension"}:
+        from . import build
+
+        return getattr(build, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

bend_python/__main__.py

@@ -0,0 +1,26 @@
+"""Project setup helpers: ``python -m bend_python vendor bend``."""
+
+import argparse
+
+from .library import get_include, vendor
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    commands = parser.add_subparsers(dest="command", required=True)
+    copy = commands.add_parser("vendor", help="copy the bundled Bend library into a project")
+    copy.add_argument("directory", nargs="?", default="bend")
+    copy.add_argument("--force", action="store_true", help="replace modified library files")
+    commands.add_parser("include", help="print the installed Bend library directory")
+    args = parser.parse_args()
+    try:
+        result = (
+            vendor(args.directory, force=args.force) if args.command == "vendor" else get_include()
+        )
+    except (OSError, RuntimeError) as error:
+        parser.exit(1, f"bend-python: {error}\n")
+    print(result)
+
+
+if __name__ == "__main__":
+    main()

bend_python/build.py

@@ -0,0 +1,368 @@
+"""Setuptools integration for the pinned Bend native compiler."""
+
+from copy import copy
+import hashlib
+import json
+import os
+from pathlib import Path
+import platform
+import re
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+import threading
+import urllib.request
+
+from setuptools import Extension
+from setuptools.command.build_ext import build_ext
+from setuptools.command.build_py import build_py
+from setuptools.errors import CompileError, ExecError, PlatformError
+
+from . import BEND_VERSION
+from .library import library_path, vendor
+
+BEND_RELEASE = (
+    f"https://github.com/bendlang/bend/releases/download/v{BEND_VERSION}/bend-{BEND_VERSION}-linux-x64.tar.gz",
+    "22bb6d5f6bce8ae2c5b340371fedddcbd90edc07a48b6e2b351a944c4558a3eb",
+)
+
+
+class BendExtension(Extension):
+    """A native extension compiled from one Bend entry point and optional proofs.
+
+    The entry point's ``main`` registers functions using the vendored Python
+    library. Normal setuptools Extension keyword arguments remain available.
+    """
+
+    def __init__(self, name, source, *, proofs=(), **kwargs):
+        if not all(re.fullmatch(r"[A-Za-z_][A-Za-z_0-9]*", part) for part in name.split(".")):
+            raise ValueError("Bend extension names must be dotted ASCII Python identifiers")
+        if Path(source).suffix != ".bend":
+            raise ValueError("BendExtension source must be a .bend file")
+        self.bend_source = str(source)
+        self.bend_proofs = [str(path) for path in proofs]
+        defaults = {
+            "extra_compile_args": [
+                "-std=c11",
+                "-O2",
+                "-fvisibility=hidden",
+                "-Wno-unused-function",
+                "-Wno-unused-variable",
+                "-Wno-unreachable-code",
+            ],
+            "extra_link_args": ["-pthread"],
+            "libraries": ["m"],
+        }
+        for key, values in defaults.items():
+            kwargs[key] = values + list(kwargs.get(key, ()))
+        super().__init__(name, sources=[self.bend_source], **kwargs)
+
+
+def _bend_version(bend):
+    try:
+        return subprocess.run([bend, "version"], text=True, capture_output=True).stdout.strip()
+    except OSError:
+        return None
+
+
+def _cached_compiler():
+    """The pinned release, downloaded and checksum-verified into the user cache."""
+    cache = Path(os.environ.get("XDG_CACHE_HOME") or Path.home() / ".cache")
+    target = cache / "bend-python" / f"bend-{BEND_VERSION}"
+    executable = target / "bin" / "bend"
+    if executable.is_file():
+        return executable
+    if os.environ.get("BEND_PYTHON_DOWNLOAD", "1") == "0":
+        return None
+    if (sys.platform, platform.machine()) != ("linux", "x86_64"):
+        return None
+    url, digest = BEND_RELEASE
+    print(f"bend-python: downloading Bend {BEND_VERSION} to {target}", file=sys.stderr)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(dir=target.parent) as temporary:
+        archive = Path(temporary) / "bend.tar.gz"
+        try:
+            with urllib.request.urlopen(url, timeout=120) as response, open(archive, "wb") as out:
+                shutil.copyfileobj(response, out)
+        except OSError as error:
+            raise ExecError(
+                f"Cannot download Bend {BEND_VERSION} from {url}: {error}; install it and set BEND"
+            ) from None
+        actual = hashlib.sha256(archive.read_bytes()).hexdigest()
+        if actual != digest:
+            raise ExecError(f"Bend download checksum mismatch: expected {digest}, got {actual}")
+        with tarfile.open(archive) as bundle:
+            # The data filter rejects absolute paths, links out of the tree, and devices.
+            options = {"filter": "data"} if hasattr(tarfile, "data_filter") else {}
+            bundle.extractall(temporary, **options)
+        try:
+            os.rename(Path(temporary) / "bend", target)
+        except OSError:
+            if not executable.is_file():  # Otherwise a concurrent build installed it first.
+                raise
+    return executable
+
+
+def _compiler():
+    """Find Bend: $BEND, this checkout's bootstrap, PATH, or the downloaded release."""
+    expected = f"bend {BEND_VERSION}"
+    explicit = os.environ.get("BEND")
+    if explicit:
+        version = _bend_version(explicit)
+        if version != expected:
+            raise ExecError(f"Expected {expected} at BEND={explicit!r}, got {version!r}")
+        return explicit
+    # Never search relative to the cwd; only an SDK checkout has this directory.
+    local = Path(__file__).resolve().parents[2] / ".tools/bend/bin/bend"
+    for candidate in (local if local.exists() else None, shutil.which("bend")):
+        if candidate and _bend_version(str(candidate)) == expected:
+            return str(candidate)
+    cached = _cached_compiler()
+    if cached and _bend_version(str(cached)) == expected:
+        return str(cached)
+    raise ExecError(
+        f"Cannot find {expected}: set BEND to its executable, or allow the "
+        "automatic download (unset BEND_PYTHON_DOWNLOAD=0)"
+    )
+
+
+_library_lock = threading.Lock()
+
+
+def _bridge_libraries(source):
+    """Directories of the bend-python libraries a program reaches by relative imports.
+
+    The build must prove the library it compiles: a project's vendored copy,
+    which ``vendor`` preserves when modified, not necessarily the SDK's own.
+    A library imported but absent is vendored first, so projects need not
+    commit or ship a copy.
+    """
+    # A second extension must not observe an incomplete automatic vendor copy.
+    with _library_lock:
+        pending, seen, found = [Path(source).resolve()], set(), []
+        while pending:
+            path = pending.pop()
+            if path in seen:
+                continue
+            seen.add(path)
+            if path.name == "python.bend" and not path.exists():
+                print(
+                    f"bend-python: vendoring the Bend library into {path.parent}", file=sys.stderr
+                )
+                vendor(path.parent)
+            if not path.is_file():
+                continue
+            if path.name == "python.bend" and path.with_name("python.c").is_file():
+                found.append(path.parent)
+            for match in re.finditer(r"^\s*import\s+(\.\.?/\S+\.bend)\b", path.read_text(), re.M):
+                pending.append((path.parent / match[1]).resolve())
+        return found
+
+
+def _bend(bend, *args, failure, quiet=False):
+    # Bend prints its own diagnostic; end the build with a setuptools error
+    # (reported as "error: ...") rather than a CalledProcessError traceback.
+    # Quiet runs (the library's own proofs) print their output only on failure.
+    result = subprocess.run([bend, *args], capture_output=quiet, text=True)
+    if result.returncode != 0:
+        if quiet:
+            sys.stderr.write(result.stdout + result.stderr)
+        raise CompileError(f"{failure} (see Bend output above)")
+
+
+def _patch_runtime(source, name):
+    fatal = """static void err_fail(const char* msg) {
+  fflush(stdout);
+  fprintf(stderr, "bend: %s\\n", msg);
+  _exit(1);
+}"""
+    cpu_globals = """static Corpus CORPUS;
+static u64    ALC[CUBE_T + 1][3 * ALC_WORDS] __attribute__((aligned(128)));
+static u32    KEEP_WORDS;
+// the bag: 2^CUBE_LOG groups of CUBE_T lanes (a -D constant on the device)
+static u32    CUBE_LOG = 7;
+static u32    bank_lock;
+
+static u32            pool_size;"""
+    context_blocks = list(
+        re.finditer(
+            r"// BENDPY_RUNTIME_CONTEXT_BEGIN\n(.*?)// BENDPY_RUNTIME_CONTEXT_END\n",
+            source,
+            re.DOTALL,
+        )
+    )
+    if len(context_blocks) != 1:
+        raise CompileError(
+            "Bend program must import the bend-python library (python.bend) exactly once"
+        )
+    context_block = context_blocks[0]
+    contexts = context_block[1]
+    source = source[: context_block.start()] + source[context_block.end() :]
+    pool_open = """OUTLINE void pool_open(void) {
+  static bool up;
+  if (up) {
+    return;
+  }
+  up = true;
+  for (u32 w = 0; w < pool_size; w += 1) {
+    pthread_t tid;
+    if (pthread_create(&tid, NULL, pool_work, (void*)(uintptr_t)w)) {
+      err_fail("pthread_create");
+    }
+  }
+}"""
+    for old, new in [
+        (fatal, "static void err_fail(const char* msg) { bendpy_panic(msg); }"),
+        (cpu_globals, contexts),
+        ("static bool io_gpu;\nstatic Stk  io_stk;", ""),
+        ("static u64 corpus_size;", ""),
+        ("  Corpus H   = CORPUS;", "  Corpus H   = CORPUS;\n  corpus_size = size;"),
+        (
+            pool_open,
+            """OUTLINE void pool_open(void) {
+  err_fail("Bend worker threads are unsupported by the Python embedding");
+}""",
+        ),
+        (
+            "int main(int argc, char** argv) {",
+            "static int bendpy_unused_main(int argc, char** argv) {",
+        ),
+        ("#define WL_OPEN    { WL_BANK u32 rn;", "#define WL_OPEN    { WL_BANK u32 rn = 0;"),
+        # Python.h is included first and already selects the GNU feature set.
+        ("#define _GNU_SOURCE\n", "#ifndef _GNU_SOURCE\n#define _GNU_SOURCE\n#endif\n"),
+        # Our WL_BANK patch below zero-initializes the forwarded registers.
+        # Under Clang 19+'s preserve_none, those live zeros exhaust the argument
+        # registers once a segment signature grows (e.g. a 5-element match):
+        # "ran out of registers during register allocation". Upstream leaves the
+        # registers uninitialized instead. Keep them defined and use the default
+        # convention, as Clang 14-18 (which lack preserve_none) already do.
+        (
+            "#if __has_attribute(preserve_none) && __has_attribute(preserve_most)\n"
+            "#define PRESERVE(A) __attribute__((A))\n#else\n#define PRESERVE(A)\n#endif\n",
+            "#define PRESERVE(A)\n",
+        ),
+    ]:
+        if source.count(old) != 1:
+            raise CompileError("Bend runtime changed; refusing an unreviewed embedding patch")
+        source = source.replace(old, new)
+    # The tail-call ABI forwards unused registers. Initialize those registers
+    # rather than passing indeterminate C values between generated segments.
+    source, count = re.subn(
+        r"#define WL_BANK Term ([\w, ]+);",
+        lambda match: (
+            "#define WL_BANK Term "
+            + ", ".join(register + " = 0" for register in match[1].split(", "))
+            + ";"
+        ),
+        source,
+    )
+    if count != 1:
+        raise CompileError("Bend register layout changed")
+    prefix = (
+        "#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n"
+        "static void bendpy_panic(const char*) __attribute__((noreturn));\n"
+        f"#define BENDPY_MODULE_NAME {json.dumps(name)}\n"
+        f"#define BENDPY_INIT PyInit_{name.rsplit('.', 1)[-1]}\n"
+    )
+    return prefix + source
+
+
+class BendBuildExt(build_ext):
+    """Proof-check, emit C, and compile BendExtension instances with Clang."""
+
+    def _clang_compiler(self):
+        """Give this extension its own compiler, preserving the configured flags."""
+        compiler = copy(self.compiler)
+        commands = {name: getattr(compiler, name, None) for name in ("compiler_so", "linker_so")}
+        if not all(commands.values()):
+            raise PlatformError("Bend extensions require a Unix Clang compiler")
+        if "CC" not in os.environ:
+            clang = shutil.which("clang")
+            if not clang:
+                raise PlatformError("Bend generated C requires Clang; install it or set CC=clang")
+            compiler.set_executables(
+                **{name: [clang, *command[1:]] for name, command in commands.items()}
+            )
+        try:
+            version = subprocess.run(
+                [*compiler.compiler_so, "--version"], text=True, capture_output=True
+            ).stdout
+        except OSError as error:
+            raise PlatformError(
+                f"Cannot run C compiler {compiler.compiler_so[0]!r}: {error}"
+            ) from error
+        if "clang" not in version.lower():
+            raise PlatformError(
+                f"Bend generated C requires Clang, not {compiler.compiler_so[0]!r}; set CC=clang"
+            )
+        return compiler
+
+    def build_extension(self, extension):
+        if not isinstance(extension, BendExtension):
+            return super().build_extension(extension)
+        if sys.platform != "linux":
+            raise PlatformError("The pinned Bend embedding runtime currently supports Linux only")
+        bend = _compiler()
+        if not Path(extension.bend_source).is_file():
+            raise CompileError(f"Bend source file not found: {extension.bend_source}")
+        libraries = _bridge_libraries(extension.bend_source) or [library_path()]
+        library_proofs = [
+            str(library / proof)
+            for library in libraries
+            for proof in ("PROOF.bend", "THREAD_PROOF.bend")
+        ]
+        for path in [*library_proofs, *extension.bend_proofs]:
+            if not Path(path).is_file():
+                raise CompileError(f"Bend proof file not found: {path}")
+        for proof in dict.fromkeys([*library_proofs, *extension.bend_proofs]):
+            _bend(
+                bend,
+                proof,
+                "--check-only",
+                failure=f"Bend proof check failed: {proof}",
+                quiet=proof in library_proofs,
+            )
+        generated = Path(self.build_temp) / (extension.name + ".c")
+        generated.parent.mkdir(parents=True, exist_ok=True)
+        _bend(
+            bend,
+            extension.bend_source,
+            "-o",
+            str(generated),
+            failure=f"Bend compilation failed: {extension.bend_source}",
+        )
+        generated.write_text(_patch_runtime(generated.read_text(), extension.name))
+        sources = extension.sources
+        extension.sources = [str(generated)]
+        try:
+            # build_ext --parallel shares this command. Isolate both the command
+            # and compiler so ordinary C extensions retain their own toolchain.
+            command = copy(self)
+            command.compiler = self._clang_compiler()
+            build_ext.build_extension(command, extension)
+        finally:
+            extension.sources = sources
+
+
+class BuildPyWithBendLibrary(build_py):
+    """Bundle this repository's canonical bend/ directory when building its SDK."""
+
+    def run(self):
+        super().run()
+        target = Path(self.build_lib) / "bend_python" / "lib"
+        target.mkdir(parents=True, exist_ok=True)
+        for path in library_path().iterdir():
+            if path.suffix in {".bend", ".c"}:
+                self.copy_file(str(path), str(target / path.name))
+
+    def get_outputs(self, include_bytecode=True):
+        files = super().get_outputs(include_bytecode)
+        target = Path(self.build_lib) / "bend_python" / "lib"
+        files.extend(
+            str(target / path.name)
+            for path in library_path().iterdir()
+            if path.suffix in {".bend", ".c"}
+        )
+        return files

bend_python/lib/LAWS.bend

@@ -0,0 +1,85 @@
+import Base
+import ./python.bend as Python
+
+law arity_empty:
+  {Python.arity([]) == 0n : Nat}
+
+law arity_cons:
+  for x: Python.Object
+  for xs: List<Python.Object>
+  {Python.arity(x <> xs) == 1n+Python.arity(xs) : Nat}
+
+law argument_head:
+  for +x: Python.Object
+  for xs: List<Python.Object>
+  {Python.argument(x <> xs, 0n) == Some{x} : Maybe<Python.Object>}
+
+law argument_tail:
+  for x: Python.Object
+  for xs: List<Python.Object>
+  for +index: Nat
+  {Python.argument(x <> xs, 1n+index) == Python.argument(xs, index) : Maybe<Python.Object>}
+
+law argument_empty:
+  for index: Nat
+  {Python.argument([], index) == None{} : Maybe<Python.Object>}
+
+law singleton_roundtrip:
+  for +x: Python.Object
+  {Python.singleton([x]) == Some{x} : Maybe<Python.Object>}
+
+law pair_roundtrip:
+  for +x: Python.Object
+  for +y: Python.Object
+  {Python.pair([x, y]) == Some{(x, y)} : Maybe<Pair(Python.Object, Python.Object)>}
+
+law argument_at_end:
+  for xs: List<Python.Object>
+  {Python.argument(xs, Python.arity(xs)) == None{} : Maybe<Python.Object>}
+
+law singleton_exact_arity:
+  for xs: List<Python.Object>
+  for value: Python.Object
+  for success: {Python.singleton(xs) == Some{value} : Maybe<Python.Object>}
+  {Python.arity(xs) == 1n : Nat}
+
+law pair_exact_arity:
+  for xs: List<Python.Object>
+  for left: Python.Object
+  for right: Python.Object
+  for success: {Python.pair(xs) == Some{(left, right)} : Maybe<Pair(Python.Object, Python.Object)>}
+  {Python.arity(xs) == 2n : Nat}
+
+# Converses of the exact-arity laws: every list of the right length parses.
+# Together these characterize the pure parsers; the IO wrappers are covered below.
+law singleton_complete:
+  for xs: List<Python.Object>
+  for exact: {Python.arity(xs) == 1n : Nat}
+  {Python.singleton(xs) == Python.argument(xs, 0n) : Maybe<Python.Object>}
+
+law pair_complete:
+  for xs: List<Python.Object>
+  for exact: {Python.arity(xs) == 2n : Nat}
+  {Python.pair(xs) == Maybe.bind(&1, Python.Object, Pair(Python.Object, Python.Object), Python.argument(xs, 0n), left => Maybe.bind(&1, Python.Object, Pair(Python.Object, Python.Object), Python.argument(xs, 1n), right => Some{(left, right)})) : Maybe<Pair(Python.Object, Python.Object)>}
+
+# The typed adapters' IO wrappers: a correct argument list yields exactly its
+# elements, and any other length yields the TypeError effect. require_no_kwargs
+# is a foreign effect checked in C and covered by tests, not here.
+law singleton_accepted:
+  for +x: Python.Object
+  {Python.require_singleton(Python.singleton([x])) == IO.pure(Python.Object, x) : IO(Python.Object)}
+
+law singleton_rejected:
+  for xs: List<Python.Object>
+  for wrong: {Nat.is_eq(Python.arity(xs), 1n) == False{} : Bool}
+  {Python.require_singleton(Python.singleton(xs)) == Python.type_error(Python.Object, "expected exactly one positional argument") : IO(Python.Object)}
+
+law pair_accepted:
+  for +x: Python.Object
+  for +y: Python.Object
+  {Python.require_pair(Python.pair([x, y])) == IO.pure(Pair(Python.Object, Python.Object), (x, y)) : IO(Pair(Python.Object, Python.Object))}
+
+law pair_rejected:
+  for xs: List<Python.Object>
+  for wrong: {Nat.is_eq(Python.arity(xs), 2n) == False{} : Bool}
+  {Python.require_pair(Python.pair(xs)) == Python.type_error(Pair(Python.Object, Python.Object), "expected exactly two positional arguments") : IO(Pair(Python.Object, Python.Object))}

bend_python/lib/PROOF.bend

@@ -0,0 +1,141 @@
+import Base
+import ./LAWS.bend as Laws
+import ./python.bend as Python
+
+def Laws.arity_empty():
+  {==}
+
+def Laws.arity_cons(x, xs):
+  {==}
+
+def Laws.argument_head(x, xs):
+  {==}
+
+def Laws.argument_tail(x, xs, index):
+  {==}
+
+def Laws.argument_empty(index):
+  {==}
+
+def Laws.singleton_roundtrip(x):
+  {==}
+
+def Laws.pair_roundtrip(x, y):
+  {==}
+
+def Laws.argument_at_end(xs):
+  match xs:
+    case []:
+      {==}
+    case _ <> tail:
+      Laws.argument_at_end(tail)
+
+def none_discriminator(-A: Type, value: Maybe<A>) -> Type:
+  match value:
+    case None{}:
+      Unit
+    case Some{_}:
+      Empty
+
+def none_not_some(-A: Type, -value: A, success: {None{} == Some{value} : Maybe<A>}) -> Empty:
+  %success : none_discriminator(A, _)
+  Unit{}
+
+def Laws.singleton_exact_arity(xs, value, success):
+  match xs:
+    case []:
+      Empty.absurd({0n == 1n : Nat}, none_not_some(Python.Object, value, success))
+    case [_]:
+      {==}
+    case _ <> _ <> tail:
+      Empty.absurd({1n+1n+Python.arity(tail) == 1n : Nat}, none_not_some(Python.Object, value, success))
+
+def Laws.pair_exact_arity(xs, left, right, success):
+  match xs:
+    case []:
+      Empty.absurd({0n == 2n : Nat}, none_not_some(Pair(Python.Object, Python.Object), (left, right), success))
+    case [_]:
+      Empty.absurd({1n == 2n : Nat}, none_not_some(Pair(Python.Object, Python.Object), (left, right), success))
+    case [_, _]:
+      {==}
+    case _ <> _ <> _ <> tail:
+      Empty.absurd({1n+1n+1n+Python.arity(tail) == 2n : Nat}, none_not_some(Pair(Python.Object, Python.Object), (left, right), success))
+
+def succ_discriminator(value: Nat) -> Type:
+  match value:
+    case 0n:
+      Empty
+    case 1n+_:
+      Unit
+
+def succ_not_zero(-n: Nat, equal: {1n+n == 0n : Nat}) -> Empty:
+  %equal : succ_discriminator(_)
+  Unit{}
+
+def predecessor(value: Nat) -> Nat:
+  match value:
+    case 0n:
+      0n
+    case 1n+pred:
+      pred
+
+def succ_injective(-a: Nat, -b: Nat, equal: {1n+a == 1n+b : Nat}) -> {a == b : Nat}:
+  %equal : {a == predecessor(_) : Nat}
+  {==}
+
+def Laws.singleton_complete(xs, exact):
+  match xs:
+    case []:
+      {==}
+    case [_]:
+      {==}
+    case head <> _ <> tail:
+      Empty.absurd({None{} == Some{head} : Maybe<Python.Object>}, succ_not_zero(Python.arity(tail), succ_injective(1n+Python.arity(tail), 0n, exact)))
+
+def Laws.pair_complete(xs, exact):
+  match xs:
+    case []:
+      {==}
+    case [_]:
+      {==}
+    case [_, _]:
+      {==}
+    case left <> right <> _ <> tail:
+      Empty.absurd({None{} == Some{(left, right)} : Maybe<Pair(Python.Object, Python.Object)>}, succ_not_zero(Python.arity(tail), succ_injective(1n+Python.arity(tail), 0n, succ_injective(1n+1n+Python.arity(tail), 1n, exact))))
+
+def true_discriminator(value: Bool) -> Type:
+  match value:
+    case True{}:
+      Unit
+    case False{}:
+      Empty
+
+def true_not_false(different: {True{} == False{} : Bool}) -> Empty:
+  %different : true_discriminator(_)
+  Unit{}
+
+def Laws.singleton_accepted(x):
+  {==}
+
+def Laws.singleton_rejected(xs, wrong):
+  match xs:
+    case []:
+      {==}
+    case [x]:
+      Empty.absurd({IO.pure(Python.Object, x) == Python.type_error(Python.Object, "expected exactly one positional argument") : IO(Python.Object)}, true_not_false(wrong))
+    case _ <> _ <> _:
+      {==}
+
+def Laws.pair_accepted(x, y):
+  {==}
+
+def Laws.pair_rejected(xs, wrong):
+  match xs:
+    case []:
+      {==}
+    case [_]:
+      {==}
+    case [x, y]:
+      Empty.absurd({IO.pure(Pair(Python.Object, Python.Object), (x, y)) == Python.type_error(Pair(Python.Object, Python.Object), "expected exactly two positional arguments") : IO(Pair(Python.Object, Python.Object))}, true_not_false(wrong))
+    case _ <> _ <> _ <> _:
+      {==}