lawspec 0.5.0 → 0.7.0

package/REFINEMENTS.md

@@ -0,0 +1,158 @@
+# Refinements and abstract integers (0.7.0)
+
+A refinement restricts a scalar domain with a pure Boolean expression. LawSpec
+checks concrete examples, generates satisfying input tuples, and checks adapter
+contracts during testing. It does not prove that an adapter is correct.
+
+## Exact integers without a storage width
+
+`Integer` is the mathematical integer domain. Integer literals default to it;
+integer addition, subtraction, multiplication, negation, quotient, and remainder
+produce it. Calculations use arbitrary precision internally. `BigInt` remains
+available when a concrete arbitrary-precision adapter representation is wanted.
+
+```lawspec
+unit example.increment
+successor :: (x :: Int8) -> (result :: Integer where result == x + 1)
+```
+
+This signature generates contract tests without a separate law. The maximum
+input, `127`, requires the value `128`. Returning a wrapped `-128` fails.
+`Integer` does not assert which storage width the implementation used.
+
+Abstract integer results accept Python `int` (excluding `bool`), JavaScript or
+TypeScript `bigint` and safe integral `number` values, Java/Kotlin standard signed
+integral wrappers and `BigInteger` through `Number`, and Go signed/unsigned integer
+values or `big.Int` values/pointers through `any`. Floating representations are
+rejected even when their current value is integral. Haskell uses `IntegerValue`:
+
+```haskell
+successor :: Int8 -> IntegerValue
+successor x = integerValue (toInteger x + 1)
+```
+
+`integerValue :: Integral a => a -> IntegerValue` erases the width losslessly.
+Abstract integer arguments use the target's arbitrary-precision integer type.
+Concrete signatures keep their existing checked native mappings.
+
+## Inline and named refinements
+
+Use `where` on a quantified input, function argument, or function result:
+
+```lawspec
+`for all` (x :: Int8) (y :: Int8 where y > Int8.max - x) .
+  add x y = x + y
+```
+
+A predicate can reference its own value and earlier inputs. A function result
+predicate can also reference the function's named arguments. Forward value
+references are errors. `Int8.min` and `Int8.max` denote representation bounds;
+machine-sized bounds use the requested `machineBits` profile.
+
+Named refinements distinguish type parameters from value parameters:
+
+```lawspec
+refinement Between
+  (T :: Type) (minimum :: T) (maximum :: T)
+  requires Ordered T is
+  (value :: T where minimum <= value && value <= maximum)
+end
+
+refinement AdditionOverflows
+  (T :: Type) (left :: T)
+  requires Integer T Bounded T is
+  (right :: T where left + right > T.max)
+end
+
+add :: (x :: Int8)
+    -> (y :: AdditionOverflows Int8 x)
+    -> (result :: Integer where result == x + y)
+```
+
+`(x :: Between Int8 1 10)` applies a refinement. Parenthesize compound arguments,
+for example `Between Int8 (-10) (5 + 5)`. Later value-parameter types can use
+earlier parameters. Value arguments must satisfy their declared domains,
+including refinements. Substitution avoids capturing names from the call site.
+Declarations can appear in any order within a unit; recursive aliases are errors.
+Fixed refinements are the zero-parameter form:
+
+```lawspec
+refinement PositiveInt8 is (value :: Int8 where value > 0) end
+```
+
+Aliases preserve their underlying native representation. They can be nested in
+`Nullable` and `Optional`; inner predicates are checked only for present values.
+Type parameters range over the supported scalar types, including presence types.
+
+`requires Integer T` describes integer capabilities in a generic declaration.
+`Integer` entails `Eq` and `Ordered`. `Ordered` currently covers exact real numbers
+and floats, with the existing IEEE comparisons (including NaN behavior).
+`Bounded` covers fixed and machine-sized integers. Bounds refer to the underlying
+integer representation, rather than a tighter interval inferred from a predicate.
+Capabilities are checked on generic declarations and their specializations.
+
+## Predicate expressions and contracts
+
+Predicates support existing pure arithmetic, comparisons, scalar constructors,
+conversions, and built-in helpers. `&&`, `||`, and `!` short-circuit; comparisons
+bind more tightly than `&&`, which binds more tightly than `||`. Assertion `and`
+continues to combine law conclusions. Exact/inexact mixing still needs an explicit
+conversion, and floating expressions retain their declared precision.
+
+`prelude.length` counts Unicode scalars for Text, code points for CodePointText,
+UTF-16 units for Utf16Text, and octets for Bytes. `prelude.isPresent` and
+`prelude.presentValue` inspect tagged presence values; guard extraction with
+`isPresent` before accessing a possibly absent value.
+
+Adapter calls are forbidden in refinements. Predicate errors such as division by
+zero are reported as failures when evaluated; they are not ordinary rejection of
+an input. Short-circuited branches are not evaluated by generation optimizations.
+
+Every refined function signature creates a standalone property. Calls from other
+laws also check argument preconditions, invoke the adapter once, snapshot its
+result, and check postconditions. Calling a function outside its precondition is
+a test failure, not a discarded example. Ordinary `implies` guards retain their
+existing conditional behavior.
+
+## Dependent generation and shrinking
+
+A quantified law ranges over satisfying tuples. For `AdditionOverflows Int8 x`,
+`x = 0` has no admissible `y`. The generator backtracks to choose another `x`;
+it does not count that dead end as a passing test. Valid pairs satisfy:
+
+```text
+1 <= x <= 127
+128 - x <= y <= 127
+```
+
+The generator derives integer bounds from affine comparisons and conjunctions,
+seeds direct comparison values and boundaries, and checks the complete predicate.
+Predicates outside that analysis use bounded sampling. Small finite base-domain
+products are enumerated exhaustively, retaining only satisfying tuples.
+
+Shrinking checks refinements again and repairs dependent later inputs when an
+earlier value changes. An overflowing counterexample can shrink to `(1, 127)`;
+it cannot shrink to `(0, 127)` because that pair is outside the domain.
+
+Compiler requests and `lawspec.json` accept:
+
+```json
+{
+  "generation": {
+    "cases": 100,
+    "maxAttempts": 10000,
+    "maxShrinks": 1000,
+    "exhaustiveLimit": 4096
+  }
+}
+```
+
+All limits are positive integers. These are the defaults for refinement properties.
+`cases` counts accepted property inputs; explicit examples and boundary fixtures
+are additional checks. Exhausted searches report an error with reproduction
+information. Exhaustion does not prove that the mathematical domain is empty.
+Statically established empty executable domains and invalid examples are rejected.
+
+See [the bundled examples](examples/specs/refinements.lawspec) for overflow,
+abstract integer arguments/results, dependent bounds, optional refinements,
+floating classification, and raw-byte lengths.

package/bin/lawspec.mjs

@@ -4,6 +4,7 @@ import path from "node:path";
 import { createCompiler } from "../api.mjs";
 import { targets, templates, commands, setup } from "../templates.mjs";
 import { generateExamples } from "../examples-command.mjs";
+import { showScalar } from "../scalars.mjs";
 import { doctor } from "../doctor.mjs";
 import {
   readOptional,
@@ -18,7 +19,7 @@ const options = {};
 const positional = [];
 for (let i = 0; i < args.length; i++) {
   const arg = args[i];
-  if (["--target", "--project", "--config", "--output"].includes(arg)) {
+  if (["--target", "--project", "--config", "--output", "--machine-bits"].includes(arg)) {
     if (!args[i + 1] || args[i + 1].startsWith("--"))
       throw new Error(`Missing value for ${arg}`);
     options[arg.slice(2)] = args[++i];
@@ -138,6 +139,7 @@ async function init() {
       await readFile(new URL("../starter.lawspec", import.meta.url), "utf8"),
       true,
     );
+  if (options.machineBits !== undefined) config.machineBits = options.machineBits;
   config.targets.push({
     language,
     root: path.relative(configRoot, root) || ".",
@@ -151,9 +153,19 @@ 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") return value;
+  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" ||
@@ -170,28 +182,32 @@ function explainExamples(law) {
       (ex) =>
         `\nexample ${JSON.stringify(ex.exampleName)}\n` +
         ex.bindings
-          .map(([n, v]) => `  ${n} = ${JSON.stringify(v)}`)
+          .map(([n, v]) => `  ${n} = ${showScalar(v)}`)
           .join("\n") +
         "\n" +
         ex.expectations
           .map(
             (e) =>
-              `  expect ${showExpression(e.actual)} = ${JSON.stringify(e.expected)}`,
+              `  expect ${showExpression(e.actual)} = ${showScalar(e.expected)}`,
           )
           .join("\n"),
     )
     .join("\n");
 }
 async function main() {
+  if (options['machine-bits'] !== undefined) {
+    options.machineBits = Number(options['machine-bits']);
+    if (![32,64].includes(options.machineBits)) throw new Error('machineBits must be 32 or 64');
+  }
   if (!verb || ["help", "--help", "-h"].includes(verb)) {
     output(
-      "LawSpec 0.5.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>, --json\nGeneration: --dry-run, --check\nTargets: " +
+      "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: " +
         targets.join(", "),
     );
     return;
   }
   if (verb === "--version") {
-    output("0.5.0");
+    output("0.7.0");
     return;
   }
   if (positional.length > (verb === "explain" ? 1 : 0))
@@ -256,7 +272,8 @@ async function main() {
     if (reports.some((r) => !r.ok)) process.exitCode = 1;
     return;
   }
-  const input = { sources: await sources(config) };
+  if (config.machineBits !== undefined && ![32, 64].includes(config.machineBits)) throw new Error("machineBits must be 32 or 64");
+  const input = { sources: await sources(config), generation: config.generation, machineBits: options.machineBits ?? config.machineBits ?? 64 };
   const compiler = await createCompiler();
   if (verb === "check") {
     const result = diagnostics(await compiler.check(input));

package/build.json

@@ -2,38 +2,64 @@
   "version": 1,
   "compilerSources": [
     "package.yaml",
+    "runtime/LawSpecRuntime.hs",
+    "runtime/LawSpecRuntime.java",
+    "runtime/lawspec_runtime.go",
+    "runtime/lawspec_runtime.mjs",
+    "runtime/lawspec_runtime.py",
     "src/LawSpec/Api.hs",
     "src/LawSpec/Compile.hs",
+    "src/LawSpec/Domain.hs",
     "src/LawSpec/Emit.hs",
+    "src/LawSpec/Eval.hs",
     "src/LawSpec/Gen.hs",
     "src/LawSpec/Model.hs",
+    "src/LawSpec/NativeScalarEmit.hs",
     "src/LawSpec/Parser.hs",
     "src/LawSpec/Prelude.hs",
+    "src/LawSpec/Refinement.hs",
+    "src/LawSpec/RuntimeSources.hs",
+    "src/LawSpec/Scalar.hs",
+    "src/LawSpec/ScalarEmit.hs",
     "stack.yaml",
     "stack.yaml.lock",
+    "tools/embed-runtimes.py",
     "wasm/app/Exports.hs",
     "wasm/cabal.project",
     "wasm/cabal.project.freeze",
     "wasm/lawspec-wasm.cabal"
   ],
   "digests": {
-    "package.yaml": "deae9eb35385fd0e08aa44432ae718e7ba6bad8e8320c728018ee9d224733c8c",
-    "src/LawSpec/Api.hs": "00b1e4bc81231ebd387f10652463904084ebf9c3c4486fd2c2217a6d4dbfc157",
-    "src/LawSpec/Compile.hs": "fd696c774025cb0ec6eb29f71661ab71ac603314865ef068778ae9df1355b6cb",
-    "src/LawSpec/Emit.hs": "7f53109a18d2450313c9dc9f9ff0fe31d80f533858baf9b2c30e36b8849b416c",
-    "src/LawSpec/Gen.hs": "c4b5d4f003c52fb31983794187890ef0dad09c86a451d8e1145974605a5ca0e8",
-    "src/LawSpec/Model.hs": "148f133296be537d4e076c2716219fdafa6d2a44b26c9de4b033f87694870911",
-    "src/LawSpec/Parser.hs": "12b652dbbf174a7091609385c4564bd47b99e45329cfc1bcdaa3936901b2f966",
-    "src/LawSpec/Prelude.hs": "98cc20e242d2f70510fa09e59d0f3e387d1ebe438b4d3435ba2f32a1192cfb4e",
+    "package.yaml": "ca15186d8aa807c58258a4b0fef8fa7d64afaa828f2e71803b4e8741066422fe",
+    "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",
+    "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/Prelude.hs": "b1e155c12f58e7c346551a0c65c5d5af76d045b3f1625977ca2a5d1c97cb8c46",
+    "src/LawSpec/Refinement.hs": "060f7bdaaa9cebc17969fa28474e9402cc918ceea0f18cac54050d25010b473c",
+    "src/LawSpec/RuntimeSources.hs": "4a49d98919971bdbe2b9eabda4eb2e7cda643aaa65ef1a4e6892b6da40ee8acd",
+    "src/LawSpec/Scalar.hs": "d89d8233abd893f65bb20d4dabe11066340eb51b982ad6fa7bce04d3e22c3547",
+    "src/LawSpec/ScalarEmit.hs": "e1f05d255db08c8634b6af98fd5d0b938f9a3735f8adf13a952f092a90ee884c",
     "stack.yaml": "20ccf4d599e355e60b7aa4f814a7cd4299fe2048616cc2e6dbdc22a7bd8cec73",
     "stack.yaml.lock": "ae222b9c81af920c56e50fa4596fa57786e7fa5a7b461390362b2b2ff63818c7",
+    "tools/embed-runtimes.py": "7520956a91f4b4ec8a6ab12078195cf1243c989b388a3f9d0b10a0fa60193bc3",
     "wasm/app/Exports.hs": "4ecbdac8faa2449e6fc61b93c82e6278fa14374154f29b4dacf0eef433f06a47",
     "wasm/cabal.project": "021e560afdc5eb4cb7169e7119ecb8f92c9ee170245af909c94b612941bff5cc",
     "wasm/cabal.project.freeze": "733dbed3d2ecccb26e874fd58f136296dad772184deb1658c196b5d54a0814dc",
-    "wasm/lawspec-wasm.cabal": "4c96fa2ec9c6cb61ca16f705c23cdae8723054bb252d27d8ef58043f8e31b868",
-    "npm/core.wasm": "581d42431681aa93b64bcd775d403612974f5cb9c7350be4b07d3ed49575c18e",
+    "wasm/lawspec-wasm.cabal": "afdb97eb4a08de190f7533b7be79c6ba11fab9ef30792aca71ef5fb448001106",
+    "npm/core.wasm": "32e3f553dc8346a0d7aac63ad556eacc0e791803b8957f0804a609b883ed0ea8",
     "npm/core_jsffi.js": "88d136efe92f7cff5758c8fec8d9b6bbc9707fe37741cebeeb415fe34ce3d72b",
     "npm/api.mjs": "d6df654600172131ac66a55b86876fc29cde2a76a0a63bbefff3183488a4837b",
-    "npm/index.d.ts": "9687bedaa439c0888aa54cb94279f4fbda536122f0e55f6ab4ec3ea82ddb4283"
+    "npm/index.d.ts": "ec19e731ed33e0d0481345888c73778ae0d3f2db58e4c3310ba684b801e698bc"
   }
 }

package/examples/specs/algebra.lawspec

@@ -0,0 +1,254 @@
+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
+
+law `addition is commutative` is
+  definition is
+    `commutative` add
+  end
+
+  example `3 plus 5 and 5 plus 3 both produce 8` is
+    x = 3
+    y = 5
+    expect add x y = 8
+    expect add y x = 8
+  end
+end
+
+law `addition is associative` is
+  definition is
+    `associative` add
+  end
+
+  example `both groupings of 3 plus 5 plus 7 produce 15` is
+    x = 3
+    y = 5
+    z = 7
+    expect add (add x y) z = 15
+    expect add x (add y z) = 15
+  end
+end
+
+law `zero is left identity for addition` is
+  definition is
+    `left identity` add 0
+  end
+
+  example `adding zero on left preserves 3` is
+    x = 3
+    expect add 0 x = 3
+  end
+end
+
+law `zero is right identity for addition` is
+  definition is
+    `right identity` add 0
+  end
+
+  example `adding zero on right preserves 3` is
+    x = 3
+    expect add x 0 = 3
+  end
+end
+
+law `zero is two-sided identity for addition` is
+  definition is
+    `identity` add 0
+  end
+
+  example `adding zero on both sides preserves 3` is
+    x = 3
+    expect add 0 x = 3
+    expect add x 0 = 3
+  end
+end
+
+law `zero absorbs multiplication left` is
+  definition is
+    `left absorbing element` multiply 0
+  end
+
+  example `zero on left of multiplication produces zero` is
+    x = 3
+    expect multiply 0 x = 0
+  end
+end
+
+law `zero absorbs multiplication right` is
+  definition is
+    `right absorbing element` multiply 0
+  end
+
+  example `zero on right of multiplication produces zero` is
+    x = 3
+    expect multiply x 0 = 0
+  end
+end
+
+law `zero absorbs multiplication on both sides` is
+  definition is
+    `absorbing element` multiply 0
+  end
+
+  example `zero on both sides of multiplication produces zero` is
+    x = 3
+    expect multiply 0 x = 0
+    expect multiply x 0 = 0
+  end
+end
+
+law `multiplication distributes over addition left` is
+  definition is
+    `left distributive` multiply add
+  end
+
+  example `left distribution produces 36` is
+    x = 3
+    y = 5
+    z = 7
+    expect multiply x (add y z) = 36
+    expect add (multiply x y) (multiply x z) = 36
+  end
+end
+
+law `multiplication distributes over addition right` is
+  definition is
+    `right distributive` multiply add
+  end
+
+  example `right distribution produces 56` is
+    x = 3
+    y = 5
+    z = 7
+    expect multiply (add x y) z = 56
+    expect add (multiply x z) (multiply y z) = 56
+  end
+end
+
+law `multiplication distributes over addition on both sides` is
+  definition is
+    `distributive` multiply add
+  end
+
+  example `left distribution produces 36; right distribution produces 56` is
+    x = 3
+    y = 5
+    z = 7
+    expect multiply x (add y z) = 36
+    expect add (multiply x y) (multiply x z) = 36
+    expect multiply (add x y) z = 56
+    expect add (multiply x z) (multiply y z) = 56
+  end
+end
+
+law `maximum is an idempotent operation` is
+  definition is
+    `idempotent operation` maximumValue
+  end
+
+  example `the maximum of 3 and itself is 3` is
+    x = 3
+    expect maximumValue x x = 3
+  end
+end
+
+law `negation supplies left additive inverses` is
+  definition is
+    `left inverse element` add negateValue 0
+  end
+
+  example `3 has inverse -3; the left inverse equation produces zero` is
+    x = 3
+    expect negateValue x = -3
+    expect add (negateValue x) x = 0
+  end
+end
+
+law `negation supplies right additive inverses` is
+  definition is
+    `right inverse element` add negateValue 0
+  end
+
+  example `3 has inverse -3; the right inverse equation produces zero` is
+    x = 3
+    expect negateValue x = -3
+    expect add x (negateValue x) = 0
+  end
+end
+
+law `negation supplies both additive inverses` is
+  definition is
+    `invertible` add negateValue 0
+  end
+
+  example `3 has inverse -3; the left and right inverse equation produces zero` is
+    x = 3
+    expect negateValue x = -3
+    expect add (negateValue x) x = 0
+    expect add x (negateValue x) = 0
+  end
+end
+
+law `subtraction has left division` is
+  definition is
+    `left division` subtractValue divideLeft
+  end
+
+  example `left solution is -2 since 3 - (-2) = 5; reversing the operation recovers 5` is
+    x = 3
+    y = 5
+    expect divideLeft x y = -2
+    expect subtractValue x (divideLeft x y) = 5
+    expect divideLeft x (subtractValue x y) = 5
+  end
+end
+
+law `subtraction has right division` is
+  definition is
+    `right division` subtractValue divideRight
+  end
+
+  example `right solution is 8 since 8 - 5 = 3; reversing the operation recovers 3` is
+    x = 3
+    y = 5
+    expect divideRight x y = 8
+    expect subtractValue (divideRight x y) y = 3
+    expect divideRight (subtractValue x y) y = 3
+  end
+end
+
+law `subtraction has divisible` is
+  definition is
+    `divisible` subtractValue divideLeft divideRight
+  end
+
+  example `left solution is -2; right solution is 8; both recovery directions hold` is
+    x = 3
+    y = 5
+    expect divideLeft x y = -2
+    expect subtractValue x (divideLeft x y) = 5
+    expect divideLeft x (subtractValue x y) = 5
+    expect divideRight x y = 8
+    expect subtractValue (divideRight x y) y = 3
+    expect divideRight (subtractValue x y) y = 3
+  end
+end
+
+law `negation is an involution` is
+  definition is
+    `involution` negateValue
+  end
+
+  example `negating -3 twice restores -3` is
+    x = -3
+    expect negateValue x = 3
+    expect negateValue (negateValue x) = -3
+  end
+end

package/examples/specs/currying.lawspec

@@ -0,0 +1,60 @@
+unit example.currying
+
+sumFour :: Int32 -> Int32 -> Int32 -> Int32 -> Int32
+format  :: Text -> Bool -> Int32 -> Text -> Text
+referenceFormat :: Text -> Bool -> Int32 -> Text -> Text
+trim    :: Text -> Text
+
+law `a four-argument function partially applied twice is commutative` is
+  definition is
+    `commutative` (sumFour 1 2)
+  end
+
+  example `the fixed 1 and 2 plus 3 and 4 sum to 10 in either order` is
+    x = 3
+    y = 4
+    expect sumFour 1 2 x y = 10
+    expect sumFour 1 2 y x = 10
+  end
+end
+
+law `staged formatter`
+  (render :: Int32 -> Text -> Text)
+  (reference :: Int32 -> Text -> Text)
+is
+  definition is
+    `for all` (port :: Int32) (suffix :: Text) .
+      render port suffix = reference port suffix
+  end
+end
+
+law `partial application preserves heterogeneous argument order` is
+  definition is
+    `staged formatter` (format "port:" true) (referenceFormat "port:" true)
+  end
+
+  example `port 443 with a tcp suffix formats as port:443/tcp` is
+    port = 443
+    suffix = "/tcp"
+    expect format "port:" true port suffix = "port:443/tcp"
+    expect referenceFormat "port:" true port suffix = "port:443/tcp"
+  end
+
+  example `a disabled numeric field keeps the prefix and suffix` is
+    port = 443
+    suffix = "/tcp"
+    expect format "port:" false port suffix = "port:/tcp"
+    expect referenceFormat "port:" false port suffix = "port:/tcp"
+  end
+end
+
+law `composition accepts a partially applied function` is
+  definition is
+    `equivalent` ((format "port:" true 443) . trim) ((referenceFormat "port:" true 443) . trim)
+  end
+
+  example `trim runs before the remaining formatter argument` is
+    x = "  /tcp  "
+    expect ((format "port:" true 443) . trim) x = "port:443/tcp"
+  end
+end