lawspec 0.7.0 → 0.8.0

package/bin/lawspec.mjs

@@ -104,6 +104,7 @@ async function init() {
     throw new Error("Target is already configured");
   await mkdir(root, { recursive: true });
   const buildFiles = [
+    "Cargo.toml",
     "pom.xml",
     "pyproject.toml",
     "package.json",
@@ -153,46 +154,17 @@ async function init() {
     `Configured ${language}. ${hasBuild ? "Existing build files preserved." : "Created missing project build files."}\n${setup[language]}\nNext: lawspec doctor, then lawspec generate.`,
   );
 }
-function showType(type) {
-  if (type.tag === 'Named' || type.tag === 'Variable') return type.contents;
-  if (type.tag === 'Applied') return `${type.contents[0]} (${showType(type.contents[1])})`;
-  return `${showType(type.contents[0])} -> ${showType(type.contents[1])}`;
-}
-function showExpression(expr) {
-  const value = expr.contents;
-  if (expr.tag === "Var" || expr.tag === "Number") return value;
-  if (expr.tag === "DecimalNumber") return `${value[0]}e${value[1]}`;
-  if (expr.tag === "ScalarLit") return showScalar(value);
-  if (expr.tag === "Binary") return `(${showExpression(value[1])} ${value[0]} ${showExpression(value[2])})`;
-  if (expr.tag === "Unary") return `${value[0]}(${showExpression(value[1])})`;
-  if (expr.tag === "Annotate") return `(${showExpression(value[0])} :: ${showType(value[1])})`;
-  if (
-    expr.tag === "Number" ||
-    expr.tag === "StringLit" ||
-    expr.tag === "BoolLit"
-  )
-    return JSON.stringify(value);
-  if (expr.tag === "Apply")
-    return `${showExpression(value[0])} (${showExpression(value[1])})`;
-  return `(${showExpression(value[0])} . ${showExpression(value[1])})`;
+function showAssertion(assertion) {
+  if (assertion.kind === "equal") return `${assertion.left.text} = ${assertion.right.text}`;
+  if (assertion.kind === "implies") return `${assertion.guard.text} implies ${showAssertion(assertion.body)}`;
+  return assertion.items.map(showAssertion).join(" and ");
 }
 function explainExamples(law) {
-  return law.original.examples
-    .map(
-      (ex) =>
-        `\nexample ${JSON.stringify(ex.exampleName)}\n` +
-        ex.bindings
-          .map(([n, v]) => `  ${n} = ${showScalar(v)}`)
-          .join("\n") +
-        "\n" +
-        ex.expectations
-          .map(
-            (e) =>
-              `  expect ${showExpression(e.actual)} = ${showScalar(e.expected)}`,
-          )
-          .join("\n"),
-    )
-    .join("\n");
+  return law.examples.map(ex =>
+    `\nexample ${JSON.stringify(ex.name)}\n` +
+    ex.bindings.map(b => `  ${b.name} = ${showScalar(b.value)}`).join("\n") + "\n" +
+    ex.expectations.map(e => `  expect ${showAssertion(e)}`).join("\n")
+  ).join("\n");
 }
 async function main() {
   if (options['machine-bits'] !== undefined) {
@@ -201,13 +173,13 @@ async function main() {
   }
   if (!verb || ["help", "--help", "-h"].includes(verb)) {
     output(
-      "LawSpec 0.7.0\nUsage: lawspec init --target <language> [--project <directory>]\n       lawspec check | doctor | explain <unit>::<law> | generate\n       lawspec examples [--target <language>] [--output example_artifacts]\nOptions: --config <path>, --target <language>, --machine-bits <32|64>, --json\nGeneration: --dry-run, --check\nTargets: " +
+      "LawSpec 0.8.0\nUsage: lawspec init --target <language> [--project <directory>]\n       lawspec check | doctor | explain <unit>::<law> | generate\n       lawspec examples [--target <language>] [--output example_artifacts]\nOptions: --config <path>, --target <language>, --machine-bits <32|64>, --json\nGeneration: --dry-run, --check\nTargets: " +
         targets.join(", "),
     );
     return;
   }
   if (verb === "--version") {
-    output("0.7.0");
+    output("0.8.0");
     return;
   }
   if (positional.length > (verb === "explain" ? 1 : 0))
@@ -280,7 +252,7 @@ async function main() {
     output(
       options.json
         ? result
-        : `Checked ${result.laws.length} executable law(s).`,
+        : `Checked ${result.laws.length} law(s).`,
     );
     return;
   }
@@ -291,7 +263,7 @@ async function main() {
       .filter(
         ({ e }) => !positional[0] || `${e.owner}::${e.name}` === positional[0],
       );
-    if (!indices.length) throw new Error("No matching executable law");
+    if (!indices.length) throw new Error("No matching law");
     output(
       options.json
         ? indices.map(({ e, i }) => ({ ...e, expansion: result.expansions[i] }))
@@ -319,7 +291,7 @@ async function main() {
       ).files,
     );
   const reports = await Promise.all(
-    selected.map((t, i) => doctor(t, roots[i])),
+    selected.map((t, i) => doctor(t, roots[i], artifacts[i])),
   );
   const failed = reports.filter((r) => !r.ok);
   if (failed.length)

package/build.json

@@ -7,20 +7,35 @@
     "runtime/lawspec_runtime.go",
     "runtime/lawspec_runtime.mjs",
     "runtime/lawspec_runtime.py",
+    "runtime/lawspec_runtime.rs",
+    "runtime/lawspec_strategies.rs",
+    "runtime/rust/Cargo.lock",
+    "runtime/rust/Cargo.toml",
     "src/LawSpec/Api.hs",
+    "src/LawSpec/Backend.hs",
+    "src/LawSpec/Common.hs",
     "src/LawSpec/Compile.hs",
+    "src/LawSpec/Core.hs",
+    "src/LawSpec/Core/Eval.hs",
+    "src/LawSpec/Core/Semantics.hs",
+    "src/LawSpec/Core/Validate.hs",
+    "src/LawSpec/CoreEmit.hs",
+    "src/LawSpec/CoreNativeScalarEmit.hs",
+    "src/LawSpec/CoreScalarEmit.hs",
     "src/LawSpec/Domain.hs",
     "src/LawSpec/Emit.hs",
     "src/LawSpec/Eval.hs",
+    "src/LawSpec/Frontend.hs",
     "src/LawSpec/Gen.hs",
     "src/LawSpec/Model.hs",
-    "src/LawSpec/NativeScalarEmit.hs",
     "src/LawSpec/Parser.hs",
     "src/LawSpec/Prelude.hs",
+    "src/LawSpec/Public.hs",
     "src/LawSpec/Refinement.hs",
     "src/LawSpec/RuntimeSources.hs",
+    "src/LawSpec/RustEmit.hs",
     "src/LawSpec/Scalar.hs",
-    "src/LawSpec/ScalarEmit.hs",
+    "src/LawSpec/Testing.hs",
     "stack.yaml",
     "stack.yaml.lock",
     "tools/embed-runtimes.py",
@@ -30,36 +45,51 @@
     "wasm/lawspec-wasm.cabal"
   ],
   "digests": {
-    "package.yaml": "ca15186d8aa807c58258a4b0fef8fa7d64afaa828f2e71803b4e8741066422fe",
+    "package.yaml": "90923d07cf41977f62a201faf26667ae4fd76de84c6f25ce47917ac92a6a1f4b",
     "runtime/LawSpecRuntime.hs": "1c3ca22232c64227717d836a57d375d906f748ecde6b79705944a2319ce5064d",
     "runtime/LawSpecRuntime.java": "5637914bd491f75ad0c75fb19d1bec798164295b7bcf9d23e1549e8ebf780d01",
     "runtime/lawspec_runtime.go": "62d2041c33760b67db619e0a803501768a505c4dfd9837bca85e158fff81fda9",
     "runtime/lawspec_runtime.mjs": "7d0abd53fa45dd9828c10ff2ffa7876162e965e7bb4913f4c460af13e06142fa",
     "runtime/lawspec_runtime.py": "7541353effebd133e50cd00a3f4d8999651c93ba751a6d951164b1f390ce0c15",
-    "src/LawSpec/Api.hs": "f1a283fd3696e8e0dd1bd6240ba636a4c1abe19c6e0ea25d6d80a1af89f762cb",
-    "src/LawSpec/Compile.hs": "a67ee7cb19ebeea644bbf8dbdc0647323a77197b15f8e87fe2227deb6c995b8e",
+    "runtime/lawspec_runtime.rs": "bf9cf5fa546346a59c85248936395fe11946974ce0bad053aeeaf4e26b6a829d",
+    "runtime/lawspec_strategies.rs": "a5dcee400574a69a5d2aa066bb8959e366728b3f21a578de84f50feadadf6641",
+    "runtime/rust/Cargo.lock": "91533e20939436e117c0f09ded695a8a05a86e79efc29fe4b4b93ad8ef1771c8",
+    "runtime/rust/Cargo.toml": "7ec66cf82dcc73a4a0b4a44d6048b6c3a340897c488aaaace9e8d4bac90b5e0a",
+    "src/LawSpec/Api.hs": "4810c05d53e370daf7520b9116c34997b7b4ba9c8d3f1a349e2afdb7b1424552",
+    "src/LawSpec/Backend.hs": "15ba04b69739e3891f73757d9cdc0a29acca6b7f7e067fd11d83d718474d0f20",
+    "src/LawSpec/Common.hs": "baa849dad0cc6227af334fdc7488389df50c0fe3a74a2ba1d84eb60c6b6edd6e",
+    "src/LawSpec/Compile.hs": "6c8bcea938f2ec3f83afb348c5ca932d96ce070f4e916fc9233a3a02ffcc89f2",
+    "src/LawSpec/Core.hs": "27ce2bb1274485cc190e10f8520118d5b381c90ac4ab6343223c46fb3cd10869",
+    "src/LawSpec/Core/Eval.hs": "87bf2acfdfff1431f1358947044c0474df40b5bc601076f5e5051e089f1d2fa4",
+    "src/LawSpec/Core/Semantics.hs": "a9d019433e3b9731f8cd0f65ec0ccc53179824bea58247b72df26760b878c2b6",
+    "src/LawSpec/Core/Validate.hs": "bd67926c872e190279f3758ad57b45c0f80d5be8381cedc8ac56a5b88b115201",
+    "src/LawSpec/CoreEmit.hs": "7ba225a262372f61edd6fe2ba0f2dbade44dfa2f767cdbcdd3f4c323eb5e9e7b",
+    "src/LawSpec/CoreNativeScalarEmit.hs": "f20382952f5854605ae617609c1ff9f5627e5acb134417cf3a67b97054844acb",
+    "src/LawSpec/CoreScalarEmit.hs": "db564e0cb07c69dee63b7dcb9cd524c30d4e7d658264d72f834adcc9fa05899d",
     "src/LawSpec/Domain.hs": "8ad50ad3a37aacb3a429c2d7924279e2a3b973204ce3c5c04c634c1b9ada0151",
-    "src/LawSpec/Emit.hs": "0b29d449f762af635bb65e5fcbf1f4cfffb1b91b28db115b08b2309557498693",
-    "src/LawSpec/Eval.hs": "9bdb694352ec4bd7140cdf8ab18045978b7407e93db5b661270160d08e4e9b7d",
-    "src/LawSpec/Gen.hs": "d4b4e5a21f5a2886dcdc98f56f649980d961c0570d9463154bed459844ab66aa",
-    "src/LawSpec/Model.hs": "67cad75f1d344bc2dfc997731c37f68994c6a6b568e03209e5b446484ae54674",
-    "src/LawSpec/NativeScalarEmit.hs": "67f50a7ea381ddada8ecbfc7534917c53f4074f8ce1d4fb6948adb8b7dfb2007",
-    "src/LawSpec/Parser.hs": "b6e5ee4a8c58b0ab2709420460f1fcabe287714f6defc0fab6cf52ccd0c416a5",
+    "src/LawSpec/Emit.hs": "9f34f5765915a2a12a66a6dca647ddaef9289372956802c6d99cf0cfec447c7a",
+    "src/LawSpec/Eval.hs": "bbaa50d3febee690c3b09ceb3f2592964cdb458dd1b4c38b6ec68a80f3e077ea",
+    "src/LawSpec/Frontend.hs": "b483732416f23960f0f03c30079a6db3ba630cf013b38fd6beede08b186585b8",
+    "src/LawSpec/Gen.hs": "f0a153e05fb0599a7cb2303dd62a269b2561738466c7211efc1927af2d5604b0",
+    "src/LawSpec/Model.hs": "75cedd730b8e8f7bff2dd39cfe3c1ed8f64e74471f6231248474957df446328f",
+    "src/LawSpec/Parser.hs": "e64356888d78f02572ff8c0a39b782248dd6a4bb9f0b1e30900f9dc12c3cd946",
     "src/LawSpec/Prelude.hs": "b1e155c12f58e7c346551a0c65c5d5af76d045b3f1625977ca2a5d1c97cb8c46",
-    "src/LawSpec/Refinement.hs": "060f7bdaaa9cebc17969fa28474e9402cc918ceea0f18cac54050d25010b473c",
-    "src/LawSpec/RuntimeSources.hs": "4a49d98919971bdbe2b9eabda4eb2e7cda643aaa65ef1a4e6892b6da40ee8acd",
-    "src/LawSpec/Scalar.hs": "d89d8233abd893f65bb20d4dabe11066340eb51b982ad6fa7bce04d3e22c3547",
-    "src/LawSpec/ScalarEmit.hs": "e1f05d255db08c8634b6af98fd5d0b938f9a3735f8adf13a952f092a90ee884c",
+    "src/LawSpec/Public.hs": "eec6c9684b3c5cb42fa882f89460104856cb02f963822b66d9b9583dc011dfeb",
+    "src/LawSpec/Refinement.hs": "9902897edc0a803c2d440cf6d5a1d44e524f94b7384ea55a6f9dcd16dbfa8957",
+    "src/LawSpec/RuntimeSources.hs": "69dadd138bb784eaebd74869d03e30079e6d73e1724179794d8ec32be178e171",
+    "src/LawSpec/RustEmit.hs": "702652cc590c5db148f35d2e591d90e45270eee47e78c31772749943509aafe7",
+    "src/LawSpec/Scalar.hs": "2907d94b72e66584b762b5ab33da64adb26f9bf84b885151ef408dc3de1a440d",
+    "src/LawSpec/Testing.hs": "a5dc1c15a45539bb72d1c7cb24cbd04888bbb8ef2f066c829654c3bdbf32c609",
     "stack.yaml": "20ccf4d599e355e60b7aa4f814a7cd4299fe2048616cc2e6dbdc22a7bd8cec73",
     "stack.yaml.lock": "ae222b9c81af920c56e50fa4596fa57786e7fa5a7b461390362b2b2ff63818c7",
-    "tools/embed-runtimes.py": "7520956a91f4b4ec8a6ab12078195cf1243c989b388a3f9d0b10a0fa60193bc3",
+    "tools/embed-runtimes.py": "26dda6ecf944ac065d10165d84ecdf44f134945fabbd48492a67d2495b5faba4",
     "wasm/app/Exports.hs": "4ecbdac8faa2449e6fc61b93c82e6278fa14374154f29b4dacf0eef433f06a47",
     "wasm/cabal.project": "021e560afdc5eb4cb7169e7119ecb8f92c9ee170245af909c94b612941bff5cc",
     "wasm/cabal.project.freeze": "733dbed3d2ecccb26e874fd58f136296dad772184deb1658c196b5d54a0814dc",
-    "wasm/lawspec-wasm.cabal": "afdb97eb4a08de190f7533b7be79c6ba11fab9ef30792aca71ef5fb448001106",
-    "npm/core.wasm": "32e3f553dc8346a0d7aac63ad556eacc0e791803b8957f0804a609b883ed0ea8",
+    "wasm/lawspec-wasm.cabal": "22590b2a6fcd384ef8957bd179e04a055e90535f7eaaa2b5ac3d314fd0b686ed",
+    "npm/core.wasm": "09efa9e767c3d33e718a8a0909cdf23b24d158813570cc610f56e72d37a59fa3",
     "npm/core_jsffi.js": "88d136efe92f7cff5758c8fec8d9b6bbc9707fe37741cebeeb415fe34ce3d72b",
-    "npm/api.mjs": "d6df654600172131ac66a55b86876fc29cde2a76a0a63bbefff3183488a4837b",
-    "npm/index.d.ts": "ec19e731ed33e0d0481345888c73778ae0d3f2db58e4c3310ba684b801e698bc"
+    "npm/api.mjs": "7415fc057ea5f4da68f9d255ce862152d6bc45d6b0053d44f61f9110911ac64b",
+    "npm/index.d.ts": "d19ecaea0be4ca01c8667a76e1bcfe758fd200d728ef67a44ad14e1b1dd15b72"
   }
 }

package/compatibility.json

@@ -2,37 +2,120 @@
   "version": 1,
   "targets": {
     "java": {
-      "java": ["25", "26"],
-      "jetCheck": ["0.3.0", "0.3.1"],
-      "junit-jupiter": ["5.14.0", "5.15.0"]
+      "java": [
+        "25",
+        "26"
+      ],
+      "jetCheck": [
+        "0.3.0",
+        "0.3.1"
+      ],
+      "junit-jupiter": [
+        "5.14.0",
+        "5.15.0"
+      ]
     },
     "python": {
-      "python": ["3.13", "3.15"],
-      "pytest": ["8.4.0", "8.5.0"],
-      "hypothesis": ["6.135.26", "7"]
+      "python": [
+        "3.13",
+        "3.15"
+      ],
+      "pytest": [
+        "8.4.0",
+        "8.5.0"
+      ],
+      "hypothesis": [
+        "6.135.26",
+        "7"
+      ]
     },
     "javascript": {
-      "fast-check": ["4", "5"]
+      "fast-check": [
+        "4",
+        "5"
+      ]
     },
     "typescript": {
-      "fast-check": ["4", "5"],
-      "typescript": ["5.9", "5.10"],
-      "@types/node": ["22", "23"]
+      "fast-check": [
+        "4",
+        "5"
+      ],
+      "typescript": [
+        "5.9",
+        "5.10"
+      ],
+      "@types/node": [
+        "22",
+        "23"
+      ]
     },
     "go": {
-      "go": ["1.22", "1.27"],
-      "rapid": ["1.2.0", "1.2.1"]
+      "go": [
+        "1.22",
+        "1.27"
+      ],
+      "rapid": [
+        "1.2.0",
+        "1.2.1"
+      ]
     },
     "haskell": {
-      "hspec": ["2.11", "2.12"],
-      "hedgehog": ["1.5", "1.6"],
-      "hspec-hedgehog": ["0.3.0.0", "0.3.0.1"],
-      "ghc": ["9.10", "9.11"]
+      "hspec": [
+        "2.11",
+        "2.12"
+      ],
+      "hedgehog": [
+        "1.5",
+        "1.6"
+      ],
+      "hspec-hedgehog": [
+        "0.3.0.0",
+        "0.3.0.1"
+      ],
+      "ghc": [
+        "9.10",
+        "9.11"
+      ]
     },
     "kotlin": {
-      "java": ["25", "26"],
-      "gradle": ["9.1", "9.4"],
-      "kotlin": ["2.3.21", "2.3.22"]
+      "java": [
+        "25",
+        "26"
+      ],
+      "gradle": [
+        "9.1",
+        "9.4"
+      ],
+      "kotlin": [
+        "2.3.21",
+        "2.3.22"
+      ]
+    },
+    "rust": {
+      "rust": [
+        "1.85",
+        "2"
+      ],
+      "proptest": [
+        "1.11.0",
+        "1.11.1"
+      ],
+      "num-bigint": [
+        "0.4.8",
+        "0.4.9"
+      ],
+      "num-rational": [
+        "0.4.2",
+        "0.4.3"
+      ],
+      "num-complex": [
+        "0.4.6",
+        "0.4.7"
+      ],
+      "num-traits": [
+        "0.2.19",
+        "0.2.20"
+      ]
     }
   }
 }

package/doctor.mjs

@@ -67,14 +67,14 @@ async function installed(req, name) {
     dir = parent;
   }
 }
-export async function doctor(target, root) {
+export async function doctor(target, root, plannedArtifacts = []) {
   const name = target.language;
   const defaults =
     name === "java"
       ? ["src/main/java", "src/test/java"]
       : name === "kotlin"
         ? ["src/main/kotlin", "src/test/kotlin"]
-        : ["src", name === "python" ? "tests" : "test"];
+        : ["src", ["python", "rust"].includes(name) ? "tests" : "test"];
   const sourceDir = target.sourceDir ?? defaults[0];
   const testDir = target.testDir ?? defaults[1];
   try {
@@ -257,6 +257,8 @@ export async function doctor(target, root) {
         "The Stack profile requires one package per target root",
       );
       const cabal = await readFile(path.join(root, cabals[0]), "utf8");
+      const components = cabal.split(/^(?:library(?:[ \t]+\S+)?|test-suite[ \t]+\S+)[ \t]*\n/m).slice(1).map(s => s.split(/\n(?=\S)/)[0]);
+      requireThat(components.some(s => s.includes(sourceDir) && ['text','bytestring'].every(dep => new RegExp(`(?:^|[\\s,])${dep}(?=[\\s,<>=]|$)`).test(s))), "The component compiling generated source must directly depend on text and bytestring");
       const suites = cabal
         .split(/^test-suite\s+/m)
         .slice(1)
@@ -355,6 +357,33 @@ export async function doctor(target, root) {
         ),
         "The JUnit Jupiter test engine must be on the test classpath",
       );
+    } else if (name === "rust") {
+      const compiler = target.rustc || "rustc";
+      const cargo = target.cargo || "cargo";
+      versions.rust = (await run(compiler, ["--version"], root)).match(/^rustc (\d+\.\d+\.\d+)/)?.[1];
+      requireThat(versions.rust && compare(versions.rust, "1.85.0") >= 0, "Rust 1.85+ is required");
+      const data = JSON.parse(await run(cargo, ["metadata", "--format-version", "1"], root));
+      const pkg = data.packages.find(p => path.resolve(p.manifest_path) === path.join(root, "Cargo.toml"));
+      requireThat(pkg, "Select a Cargo package directory containing Cargo.toml");
+      requireThat(pkg.edition === "2024", "Cargo package must use edition 2024");
+      const node = data.resolve.nodes.find(n => n.id === pkg.id);
+      for (const dep of ["proptest", "num-bigint", "num-rational", "num-complex", "num-traits"]) {
+        const reference = node.deps.find(d => d.name === dep.replaceAll("-", "_"));
+        versions[dep] = data.packages.find(p => p.id === reference?.pkg)?.version;
+        requireThat(versions[dep], `Missing direct Cargo dependency: ${dep}`);
+      }
+      const manifest = await readFile(path.join(root, "Cargo.toml"), "utf8");
+      requireThat(!/harness\s*=\s*false/.test(manifest), "Rust generated tests require the standard Cargo test harness");
+      const testRoot = path.resolve(root, testDir);
+      const expectedTests = plannedArtifacts.length
+        ? plannedArtifacts.filter(f => f.placement === "test" && f.path.endsWith("_lawspec.rs")).map(f => path.resolve(root, f.path))
+        : (await readdir(testRoot).catch(error => {if(error.code === "ENOENT") return []; throw error;})).filter(n => n.endsWith("_lawspec.rs")).map(n => path.join(testRoot,n));
+      if (testDir !== "tests" || /autotests\s*=\s*false/.test(manifest)) {
+        const registered = new Set(pkg.targets.filter(t => t.kind.includes("test") && t.test).map(t => path.resolve(t.src_path)));
+        requireThat(expectedTests.length ? expectedTests.every(file => registered.has(file)) : [...registered].some(file => file.startsWith(testRoot + path.sep)), "Register every generated Rust test file with Cargo [[test]] entries for this custom layout");
+      }
+      const library = pkg.targets.find(t => t.kind.includes("lib"));
+      requireThat(!library || path.dirname(path.resolve(library.src_path)) === path.resolve(root, sourceDir), "Cargo library path must match the configured sourceDir");
     } else if (name === "kotlin") {
       const command =
         target.gradle ||

package/examples/specs/algebra.lawspec

@@ -1,13 +1,13 @@
 unit example.algebra
 
--- Int32 arithmetic in this example wraps modulo 2^32 on every target.
-add           :: Int32 -> Int32 -> Int32
-multiply      :: Int32 -> Int32 -> Int32
-negateValue   :: Int32 -> Int32
-maximumValue  :: Int32 -> Int32 -> Int32
-subtractValue :: Int32 -> Int32 -> Int32
-divideLeft    :: Int32 -> Int32 -> Int32
-divideRight   :: Int32 -> Int32 -> Int32
+-- Integer denotes mathematical integers. Adapter results must remain exact.
+add           :: Integer -> Integer -> Integer
+multiply      :: Integer -> Integer -> Integer
+negateValue   :: Integer -> Integer
+maximumValue  :: Integer -> Integer -> Integer
+subtractValue :: Integer -> Integer -> Integer
+divideLeft    :: Integer -> Integer -> Integer
+divideRight   :: Integer -> Integer -> Integer
 
 law `addition is commutative` is
   definition is
@@ -20,6 +20,20 @@ law `addition is commutative` is
     expect add x y = 8
     expect add y x = 8
   end
+
+  example `addition exceeds the Int32 maximum without wrapping` is
+    x = 2147483647
+    y = 1
+    expect add x y = 2147483648
+    expect add y x = 2147483648
+  end
+
+  example `addition remains exact beyond machine and safe-number bounds` is
+    x = 18446744073709551615
+    y = 2
+    expect add x y = 18446744073709551617
+    expect add y x = 18446744073709551617
+  end
 end
 
 law `addition is associative` is
@@ -116,6 +130,14 @@ law `multiplication distributes over addition left` is
     expect multiply x (add y z) = 36
     expect add (multiply x y) (multiply x z) = 36
   end
+
+  example `multiplication preserves products outside Int32` is
+    x = 2147483647
+    y = 2147483647
+    z = 1
+    expect multiply x y = 4611686014132420609
+    expect multiply x (add y z) = 4611686016279904256
+  end
 end
 
 law `multiplication distributes over addition right` is
@@ -251,4 +273,10 @@ law `negation is an involution` is
     expect negateValue x = 3
     expect negateValue (negateValue x) = -3
   end
+
+  example `negating the Int32 minimum produces a positive integer` is
+    x = -2147483648
+    expect negateValue x = 2147483648
+    expect negateValue (negateValue x) = -2147483648
+  end
 end

package/examples/specs/currying.lawspec

@@ -1,6 +1,6 @@
 unit example.currying
 
-sumFour :: Int32 -> Int32 -> Int32 -> Int32 -> Int32
+sumFour :: Integer -> Integer -> Integer -> Integer -> Integer
 format  :: Text -> Bool -> Int32 -> Text -> Text
 referenceFormat :: Text -> Bool -> Int32 -> Text -> Text
 trim    :: Text -> Text

package/examples/specs/refinements.lawspec

@@ -73,3 +73,14 @@ end
 law `machine bound` is
   definition is `for all` (x :: IntSize where x == IntSize.max) . x = IntSize.max end
 end
+
+law `symbol fixture refinement` is
+  definition is
+    `for all` (x :: Symbol where x == symbol("selected", "fixture")) .
+      x = symbol("selected", "fixture")
+  end
+  example `selected identity` is
+    x = symbol("selected", "fixture")
+    expect x = symbol("selected", "fixture")
+  end
+end

package/examples-command.mjs

@@ -43,7 +43,7 @@ export async function generateExamples(options) {
   return plans.map((plan, i) => ({
     target: selected[i],
     directory: plan.root,
-    files: artifacts[i].map((f) => ({ path: f.path, ownership: f.ownership })),
+    files: artifacts[i].map((f) => ({ path: f.path, ownership: f.ownership, placement: f.placement })),
     changes: plan.changes.length,
     preservedAdapters: plan.preserved,
     adapterUpdates: plan.adapterUpdates,

package/index.d.ts

@@ -1,29 +1,29 @@
 // Generated from LawSpec.Gen. Do not edit.
-export type Target = 'java' | 'python' | 'javascript' | 'typescript' | 'go' | 'haskell' | 'kotlin';
+export type Target = 'java' | 'python' | 'javascript' | 'typescript' | 'go' | 'haskell' | 'kotlin' | 'rust';
 export interface Source { path: string; content: string }
 export interface Location { file: string; line: number; column: number }
+export interface Span { start: Location; end: Location }
 export interface Diagnostic { code: string; message: string; at: Location | null }
 export interface Artifact { path: string; content: string; ownership: 'user' | 'generated'; placement: 'source' | 'test' }
-export type Type = {tag: 'Named' | 'Variable'; contents: string} | {tag: 'Arrow'; contents: [Type, Type]} | {tag: 'Applied'; contents: ['Nullable' | 'Optional', Type]} | {tag:'Refined'; contents:[string, Type, Expr | null]} | {tag:'Qualified'; contents:[Constraint[],Type]} | {tag:'CheckedType'; contents:[Expr[],Type]} | {tag:'RefinementApp'; contents:[string,RefinementArgument[]]};
-export interface Constraint {tag:'Capability'; contents:['Eq'|'Integer'|'Ordered'|'Bounded',Type]}
-export type RefinementArgument = {tag:'TypeArgument'; contents:Type} | {tag:'ValueArgument'; contents:Expr};
-export interface Refinement {refinementName:string; refinementParameters:[string,Type][]; refinementRequirements:Constraint[]; refinementBody:Type}
-export interface Contract {contractName:string; contractArguments:[string,Type][]; contractResult:[string,Type]; contractPreconditions:Expr[]; contractPostconditions:Expr[]}
+export type Type = {kind:'constructor'; name:string; arguments:TypeArgument[]} | {kind:'variable'; id:string} | {kind:'function'; parameter:Type; result:Type};
+export type TypeArgument = {kind:'type'; type:Type} | {kind:'natural'; value:string} | {kind:'indexVariable'; id:string};
+export type Origin = {kind:'source'; span:Span} | {kind:'generated'; declaration:string};
+export type Evidence = {kind:'numeric'|'structural'; type:Type};
+export interface Expr {type:Type; origin:Origin; text:string; node:ExprNode}
+export type ExprNode = {kind:'constant'; value:ScalarValue} | {kind:'local'; id:string} | {kind:'call'; declaration:string; arguments:Expr[]} | {kind:'binary'; operator:string; evidence:Evidence; left:Expr; right:Expr} | {kind:'unary'; operator:'-'|'!'; argument:Expr} | {kind:'shortCircuit'; operator:'&&'|'||'; left:Expr; right:Expr} | {kind:'convert'; conversion:'explicit'|'checked'; argument:Expr} | {kind:'helper'; name:string; arguments:Expr[]};
+export type Assertion = {kind:'equal'; evidence:Evidence; left:Expr; right:Expr} | {kind:'implies'; guard:Expr; body:Assertion} | {kind:'all'; items:Assertion[]};
 export interface Generation {cases:number; maxAttempts:number; maxShrinks:number; exhaustiveLimit:number}
-export interface Input {inputName:string; inputId:string; inputType:Type; inputRefinements:Expr[]}
-export interface DomainPlan {domainInput:Input; domainBounds:[string,Expr][]}
+export interface Binder {id:string; name:string; type:Type}
+export interface Input extends Binder {predicates:Expr[]; bounds:{operator:string; value:Expr}[]}
+export interface Example {name:string; bindings:(Binder & {value:ScalarValue})[]; expectations:Assertion[]}
+export interface Law {id:string; owner:string; name:string; inputs:Input[]; assertion:Assertion; examples:Example[]; description:string; rationale:string; references:string[]; location:Location; trace:string[]; generation:Generation}
+export interface Unit {id:string; declarations:(Binder & {origin:Origin})[]}
+export interface Contract {id:string; name:string; arguments:Binder[]; result:Binder; preconditions:Expr[]; postconditions:Expr[]}
+export interface Refinement {owner:string; name:string; parameters:{name:string; kind:'type'|'value'; type:string}[]; requirements:{capability:string; type:string}[]; definition:string}
+export interface CheckRequest {sources:Source[]; schemaVersion?:3; machineBits?:32|64; generation?:Partial<Generation>}
+export interface GenerationRequest extends CheckRequest {target:Target; sourceDir?:string; testDir?:string}
+export interface Result {schemaVersion:3; machineBits?:32|64; generation?:Generation; units?:Unit[]; laws?:Law[]; contracts?:{owner:string; contract:Contract}[]; refinements?:Refinement[]; diagnostics:Diagnostic[]; expansions?:string[]; files?:Artifact[]}
 export type IntegerType = 'Int8' | 'Int16' | 'Int32' | 'Int64' | 'UInt8' | 'UInt16' | 'UInt32' | 'UInt64' | 'IntSize' | 'UIntSize' | 'UIntPtr' | 'Integer' | 'BigInt' | 'BigUInt';
 export type ScalarValue = {type: IntegerType; value: string} | {type: 'Bool'; value: boolean} | {type: 'Decimal'; coefficient: string; exponent: string} | {type: 'Rational'; numerator: string; denominator: string} | {type: 'Float32' | 'Float64'; bits: string} | {type: 'Complex64' | 'Complex128'; real: ScalarValue; imaginary: ScalarValue} | {type: 'Char' | 'CodePoint' | 'CodeUnit16'; value: number} | {type: 'Text' | 'CodePointText' | 'Utf16Text' | 'Bytes'; units: number[]} | {type: 'Symbol'; id: string; description: string} | {type: 'Unit' | 'Null' | 'Undefined'} | {type: 'Nullable' | 'Optional'; value: ScalarValue | null};
-export type Expr = {tag: 'Var' | 'StringLit'; contents: string} | {tag: 'Number'; contents: string} | {tag: 'DecimalNumber'; contents: [string, string]} | {tag: 'BoolLit'; contents: boolean} | {tag: 'Apply' | 'Compose'; contents: [Expr, Expr]} | {tag: 'ScalarLit'; contents: ScalarValue} | {tag: 'Annotate'; contents: [Expr, Type]} | {tag: 'Unary'; contents: [string, Expr]} | {tag: 'Binary'; contents: [string, Expr, Expr]} | {tag:'TypeBound'; contents:['min'|'max',Type]};
-export type Definition = {tag: 'Forall'; contents: [[string, Type][], Definition]} | {tag: 'Equal'; contents: [Expr, Expr]} | {tag: 'Holds'; contents: Expr} | {tag: 'Implies'; contents: [Expr, Definition]} | {tag: 'And'; contents: [Definition, Definition]} | {tag: 'Invoke'; contents: [string, Expr[]]};
-export interface Expectation { actual: Expr; expected: ScalarValue }
-export interface Example { exampleName: string; bindings: [string, ScalarValue][]; expectations: Expectation[] }
-export interface Law { lawName: string; parameters: [string, Type][]; requirements: Constraint[]; definition: Definition; description: string; rationale: string; examples: Example[]; references: string[]; location: Location }
-export type Assertion = {tag: 'AssertEqual'; contents: [Expr, Expr]} | {tag: 'AssertImplies'; contents: [Expr, Assertion]} | {tag: 'AssertAll'; contents: Assertion[]};
-export interface Expanded { owner: string; name: string; inputs: Input[]; left: Expr; right: Expr; guards: Expr[]; assertion: Assertion; trace: string[]; original: Law; typedExpressions: TypedExpr[]; propertyKind: 'law'|'contract'; generation:Generation; generationPlan:DomainPlan[] }
-export interface TypedExpr { expressionType: Type; expression: Expr; operands: TypedExpr[]; requiredConversion: Type | null }
-export interface CheckRequest { sources: Source[]; schemaVersion?: 2; machineBits?: 32 | 64; generation?:Partial<Generation> }
-export interface GenerationRequest extends CheckRequest { target: Target; sourceDir?: string; testDir?: string }
-export interface Result { schemaVersion: 2; machineBits?: 32 | 64; generation?:Generation; refinements?:{owner:string; declaration:Refinement}[]; contracts?:{owner:string; contract:Contract}[]; diagnostics: Diagnostic[]; laws?: Expanded[]; expansions?: string[]; files?: Artifact[] }
 export interface Compiler { check(input: CheckRequest): Promise<Result>; expand(input: CheckRequest): Promise<Result>; planGeneration(input: GenerationRequest): Promise<Result> }
 export function createCompiler(): Promise<Compiler>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lawspec",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "State the law once. Check it everywhere.",
   "license": "MIT",
   "type": "module",
@@ -8,6 +8,6 @@
   "bin": { "lawspec": "bin/lawspec.mjs" },
   "exports": { ".": { "types": "./index.d.ts", "import": "./api.mjs" } },
   "types": "index.d.ts",
-  "files": ["*.mjs", "*.json", "index.d.ts", "bin", "core.wasm", "core_jsffi.js", "README.md", "PRIMITIVES.md", "REFINEMENTS.md", "API-MIGRATION.md", "LICENSE", "starter.lawspec", "examples"],
+  "files": ["*.mjs", "*.json", "index.d.ts", "bin", "core.wasm", "core_jsffi.js", "README.md", "PRIMITIVES.md", "REFINEMENTS.md", "RUST.md", "LANGUAGE.md", "API-MIGRATION.md", "LICENSE", "starter.lawspec", "examples"],
   "scripts": { "test": "node --test test/*.test.mjs" }
 }

package/templates.mjs

@@ -6,8 +6,10 @@ export const targets = [
   "go",
   "haskell",
   "kotlin",
+  "rust",
 ];
 export const commands = {
+  rust: "cargo test",
   java: "mvn test",
   python: "python -m pytest",
   javascript: "node --test test/*.test.mjs",
@@ -18,6 +20,7 @@ export const commands = {
   kotlin: "gradle test",
 };
 export const setup = {
+  rust: "Use Rust 1.85+ with edition 2024, Proptest 1.11.0, num-bigint 0.4.8, num-rational 0.4.2, num-complex 0.4.6, and num-traits 0.2.19. Run cargo test.",
   java: "Use JDK 25+, Maven, JetCheck 0.3.0, JUnit Jupiter 5.14.x, compiler plugin 3.14.1+, Surefire 3.5.x, and maven.compiler.release=25. Run mvn test-compile.",
   python:
     'Use Python 3.13+. Install pytest 8.4.x and Hypothesis 6.x into the selected environment: python -m pip install -e ".[test]". Configure pytest pythonpath=["src"] and testpaths=["tests"]. Set the target python field to the interpreter path if needed.',
@@ -41,6 +44,27 @@ export function templates(target) {
     type: "module",
   };
   switch (target) {
+    case "rust":
+      return {
+        "src/lib.rs": '// Application library. LawSpec maintains the included module declarations.\ninclude!("lawspec_modules.rs");\n',
+        "Cargo.toml": `[package]
+name = "lawspec-example"
+version = "0.1.0"
+edition = "2024"
+rust-version = "1.85"
+publish = false
+
+[dependencies]
+num-bigint = "=0.4.8"
+num-rational = "=0.4.2"
+num-complex = "=0.4.6"
+num-traits = "=0.2.19"
+
+[dev-dependencies]
+proptest = "=1.11.0"
+`,
+      };
+
     case "javascript":
       return {
         "package.json": json({