lawspec 0.4.0 → 0.6.0

package/README.md

@@ -2,7 +2,7 @@
 
 **State the law once. Check it everywhere.**
 
-LawSpec 0.4 compiles reusable laws into native property tests, executable examples,
+LawSpec 0.6 compiles reusable laws into native property tests, executable examples,
 and implementation adapters. The compiler is Haskell, distributed as prebuilt
 WebAssembly with a Node CLI and an asynchronous, typed JavaScript API.
 
@@ -11,7 +11,7 @@ WebAssembly with a Node CLI and an asynchronous, typed JavaScript API.
 Install [LawSpec from npm](https://www.npmjs.com/package/lawspec):
 
 ```sh
-npm install --save-dev lawspec@0.4.0
+npm install --save-dev lawspec@0.6.0
 npx lawspec --version
 ```
 
@@ -25,8 +25,8 @@ local dependencies so LawSpec can create its `package.json` and test script:
 ```sh
 mkdir lawspec-example
 cd lawspec-example
-npm exec --package=lawspec@0.4.0 -- lawspec init --target javascript
-npm install --save-dev lawspec@0.4.0
+npm exec --package=lawspec@0.6.0 -- lawspec init --target javascript
+npm install --save-dev lawspec@0.6.0
 npx lawspec check
 npx lawspec explain 'example.atoi_codec::itoa and then atoi yields a'
 npx lawspec doctor
@@ -52,7 +52,7 @@ properties with the selected framework's shrinking and failure reporting.
 
 | Target | Build setup | Test libraries | Test command |
 | --- | --- | --- | --- |
-| `java` | Maven, JDK 25, release 25 | JetCheck 0.4.0, JUnit Jupiter 5.14.x | `mvn test` |
+| `java` | Maven, JDK 25, release 25 | JetCheck 0.3.0, JUnit Jupiter 5.14.x | `mvn test` |
 | `python` | Python 3.13 or 3.14, pyproject | pytest 8.4.x, Hypothesis 6.135.26+ (6.x) | `python -m pytest` |
 | `javascript` | Node 22+, npm, ESM | fast-check 4.x, node:test | `npm test` |
 | `typescript` | Node 22+, npm, TypeScript 5.9.x, ESM | fast-check 4.x, node:test | `npm test` |
@@ -61,7 +61,7 @@ properties with the selected framework's shrinking and failure reporting.
 | `kotlin` | JDK/JVM 25, Gradle 9.1–9.3, Kotlin 2.3.21 | Kotest 5.9.1 | `gradle test` |
 
 Java 25 and Python 3.13 are the minimum baselines. New JVM releases are admitted
-through compatibility profiles after testing; v0.4's current JVM profile certifies
+through compatibility profiles after testing; v0.6's current JVM profile certifies
 25. Python templates declare `requires-python = ">=3.13"` and runtime checks
 currently recognize 3.13 and 3.14. Kotlin templates pin Gradle's supported build
 configuration to Kotlin 2.3.21 and target JVM 25.
@@ -159,11 +159,12 @@ for all (x :: Int32) . atoi (itoa (x)) = x
 
 Reusable laws can declare typed unary function parameters and `requires Eq a`.
 Definitions support law application, function application/composition, universal
-quantification, integer and text literals, and equality. Function signatures use `Int32`
-and `Text`; generic variables are supported in reusable laws. v0.4 generates
-quantified `Int32` and `Text` inputs, including mixed and multiple inputs. Both
-types can also be intermediate or compared results. Functions are synchronous
-and unary. Text literals are double-quoted, with escapes such as `\"`, `\\`,
+quantification, `implies`, Boolean predicates, scalar literals, and equality.
+Function signatures use `Int32`, `Text`, and `Bool`; generic variables are
+supported in reusable laws. v0.6 generates quantified inputs of all three types,
+including mixed and multiple inputs. These types can also be intermediate or
+compared results. Functions are synchronous and support curried signatures with any positive
+number of scalar arguments. Text literals are double-quoted, with escapes such as `\"`, `\\`,
 `\n`, and `\t`; examples must bind each input to a literal of its declared type.
 Text values contain Unicode scalar values; surrogate code points are rejected.
 
@@ -178,11 +179,219 @@ Additional primitives, external law packages, cross-unit imports beyond the
 prelude, async functions, direct existing-symbol binding and browser hosting are
 outside this release.
 
-## Expected results and migration to 0.4
+## Algebra and currying (0.6)
+
+Version 0.6 adds algebra laws, scalar law parameters, curried signatures,
+and conjunctions.
+
+```lawspec
+unit example.addition
+
+add :: Int32 -> Int32 -> Int32
+
+law `addition commutes` 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 `zero is an identity on both sides` is
+  definition is
+    `identity` add 0
+  end
+
+  example `zero preserves 3 on either side` is
+    x = 3
+    expect add 0 x = 3
+    expect add x 0 = 3
+  end
+end
+```
+
+Arrows associate to the right and application associates to the left:
+`f :: a -> b -> c` takes two arguments, and `f x y` means `(f x) y`.
+A partial application such as `add 1` can be passed to a reusable unary law;
+`sumFour 1 2` can be passed to a binary law. Partial applications also compose.
+The compiler specializes these expressions before emission. Java, Kotlin,
+Python, JavaScript, TypeScript and Go adapters take ordinary positional arguments
+(`add(x, y)`); Haskell adapters use native currying (`add x y`). Argument order
+and types are preserved, including mixtures of `Text`, `Bool` and `Int32`.
+
+Law parameters can also be scalar values: `(e :: a)` supplies an identity and
+`(zero :: a)` supplies an absorbing element. Pass literals directly, for example
+`left identity` with arguments `add 0`, or `absorbing element` with `multiply 0`.
+Functions declared by a unit take one or more scalar inputs and return a scalar;
+reusable laws accept these curried functions, their partial applications, and
+scalar parameters. Quantified test inputs remain scalar.
+
+The prelude defines the following laws. Every row has an executable example in
+[algebra.lawspec](https://github.com/brain-fuel/lawspec/blob/v0.6.0/examples/specs/algebra.lawspec), including both sides of every
+combined law. `f` and `g` are binary operations, `inverse` is unary, and `e` and
+`zero` are scalar parameters. All these laws require equality of the element type.
+
+| Law and arguments | Equations checked for every quantified input |
+| --- | --- |
+| `commutative f` | `f x y = f y x` |
+| `associative f` | `f (f x y) z = f x (f y z)` |
+| `left identity f e` | `f e x = x` |
+| `right identity f e` | `f x e = x` |
+| `identity f e` | Both identity equations |
+| `left absorbing element f zero` | `f zero x = zero` |
+| `right absorbing element f zero` | `f x zero = zero` |
+| `absorbing element f zero` | Both absorbing equations |
+| `left distributive f g` | `f x (g y z) = g (f x y) (f x z)` |
+| `right distributive f g` | `f (g x y) z = g (f x z) (f y z)` |
+| `distributive f g` | Both distributive equations |
+| `idempotent operation f` | `f x x = x` (the existing `idempotent` law is unary) |
+| `left inverse element f inverse e` | `f (inverse x) x = e` |
+| `right inverse element f inverse e` | `f x (inverse x) = e` |
+| `invertible f inverse e` | Both inverse equations |
+| `left division f divideLeft` | `f x (divideLeft x y) = y` and `divideLeft x (f x y) = y` |
+| `right division f divideRight` | `f (divideRight x y) y = x` and `divideRight (f x y) y = x` |
+| `divisible f divideLeft divideRight` | All four division equations |
+| `involution f` | `f (f x) = x` |
+
+Here **divisible** means algebraic left/right division. `divideLeft x y` solves
+`f x result = y`; `divideRight x y` solves `f result y = x`. The subtraction
+example deliberately uses a noncommutative operation: with `x = 3` and `y = 5`,
+the left solution is `-2` and the right solution is `8`. Recovery is checked in
+both directions. These are total laws; a partially defined division needs an
+explicit domain predicate and conditional equations.
+
+`invertible` checks the supplied inverse operation. Check `identity` and
+`associative` as well when specifying a group. The prelude states contracts;
+it does not supply arithmetic implementations or prove a structure from random
+tests. The numeric examples use Int32 arithmetic modulo 2^32 so their laws hold
+at overflow boundaries on every target. JavaScript uses `Math.imul` for products,
+and Python explicitly wraps results into the signed Int32 range in the test
+adapters.
+
+Use `and` to require multiple conclusions in one law. For example:
+
+```lawspec
+unit example.absorption
+multiply :: Int32 -> Int32 -> Int32
+
+law `zero absorbs on both sides` is
+  definition is
+    `for all` (x :: Int32) .
+      multiply 0 x = 0 and multiply x 0 = 0
+  end
+
+  example `3 times zero and zero times 3 both produce zero` is
+    x = 3
+    expect multiply 0 x = 0
+    expect multiply x 0 = 0
+  end
+end
+```
+
+Quantification and implication extend through the following conjunction:
+`p x implies A and B` guards both conclusions. Write `(p x implies A) and B`
+to guard only the first. A shared guard runs once per check; false guards skip
+their entire consequence. Every conjunct is type-checked and emitted. As with
+existing assertions, the first failure stops that individual test. `and` is now
+a reserved word.
+
+[Currying examples](https://github.com/brain-fuel/lawspec/blob/v0.6.0/examples/specs/currying.lawspec) demonstrate a four-argument
+function partially applied twice, a formatter with four heterogeneous arguments,
+and composition after partial application. Each example states its exact outputs.
+Run `node npm/bin/lawspec.mjs examples` after rebuilding to inspect all nine units
+in all seven target languages (126 artifacts).
+
+The expanded API's **`assertion` tree is authoritative**: `AssertEqual` contains
+two expressions, `AssertImplies` contains a condition and consequence, and
+`AssertAll` contains every conjunct. Existing `left`, `right`, and `guards`
+fields are compatibility projections of the first conclusion only; consumers
+checking compound laws must traverse `assertion`. Source definitions add `And`.
+`lawspec explain` prints the full conjunction and its conditional scope.
+
+## Predicates and conditional laws (0.5)
+
+A predicate is a unary function returning `Bool`. Use `true` and `false` in
+expressions, example bindings, and expected results. A Boolean expression can
+stand alone as a law's definition: it must evaluate to `true`.
+
+`condition implies consequence` checks the consequence only when the condition
+is true. Conditions must have type `Bool`; nested implications short-circuit in
+source order. The consequence can be an equality, another implication, a Boolean
+predicate, or a reusable law application. Quantify any inputs before using them.
+
+```lawspec
+unit example.parse_port
+
+validPort :: Int32 -> Bool
+render    :: Int32 -> Text
+parse     :: Text -> Int32
+
+law `valid ports round trip` is
+  definition is
+    `for all` (x :: Int32) .
+      validPort x implies
+        parse (render x) = x
+  end
+
+  example `ordinary port` is
+    x = 443
+    expect validPort x = true
+    expect render x = "443"
+    expect parse (render x) = 443
+  end
+
+  example `zero is rejected; the round trip is skipped` is
+    x = 0
+    expect validPort x = false
+  end
+end
+```
+
+The [complete port example](https://github.com/brain-fuel/lawspec/blob/v0.6.0/examples/specs/parse_port.lawspec)
+defines valid ports as 1–65535, and covers both endpoints, ordinary ports, zero,
+negative values, and 65536. All explicit `expect` assertions run regardless of
+the law's condition. A false condition skips only the consequence: invalid ports
+never reach `render` or `parse` through the law. Predicate errors still fail the
+test; they are not treated as false.
+
+Implication is logical implication, not generator filtering or an assumption.
+Randomized tests still sample the full input domain and count a false condition
+as satisfying the law. A narrow predicate may therefore exercise few or no
+consequences during a random run. Explicit valid examples ensure the important
+cases run, and expectations of both `true` and `false` catch always-false and
+always-true predicate implementations.
+
+The prelude includes `satisfies predicate` (the predicate holds for every input)
+and `left inverse when predicate parse render` (the guarded round trip above).
+These reusable laws preserve the condition and its lexical bindings when expanded.
+`equivalent` can also compare two predicates, since `Bool` supports equality.
+The [Boolean flags example](https://github.com/brain-fuel/lawspec/blob/v0.6.0/examples/specs/boolean_flags.lawspec)
+checks that flipping twice restores both `false` and `true`; all targets generate
+Boolean property inputs and explicit tests for both Boolean boundary values. Java caps Boolean-only JetCheck runs at the number of
+possible input combinations (up to 100), avoiding generator exhaustion.
+
+In 0.5, `implies`, `true`, and `false` become reserved words. Existing 0.4 specs
+that use those words as identifiers need renaming. The API adds `BoolLit`,
+`Holds`, and `Implies` AST variants, Boolean literal values, and an ordered
+`guards` array on expanded laws. `lawspec explain` prints the conditions.
+
+Kotlin adapters now group functions in an `object` named after the unit (for
+example, `object ParsePort` in package `example`). This allows both the port and
+alternatives units to define `render(Int)`. When upgrading a Kotlin project,
+move existing top-level adapter functions into the indicated object; generation
+preserves your adapter and reports the required stub shape. Generated tests call
+`ParsePort.validPort(...)`, `ParsePort.render(...)`, and `ParsePort.parse(...)`.
+
+## Expected results and migration from 0.3
 
 Every `example` must bind all quantified inputs and then include one or more
 `expect <expression> = <literal>` assertions. The expected literal must have the
-same `Int32` or `Text` type as the expression. Expressions can reference the
+same `Int32`, `Text`, or `Bool` type as the expression. Expressions can reference the
 example's inputs and the unit's functions, including composed function calls.
 Input names shadow function names within expectations, following lexical scope.
 
@@ -240,7 +449,7 @@ This expands to `for all (x :: Int32) . render (x) = referenceRender (x)`.
 The example inherits the input name `x` from the prelude. Both functions are
 user-owned adapter functions; either may delegate to your existing code.
 
-[The complete example](https://github.com/brain-fuel/lawspec/blob/v0.4.0/examples/specs/equivalent.lawspec) compares decimal
+[The complete example](https://github.com/brain-fuel/lawspec/blob/v0.6.0/examples/specs/equivalent.lawspec) compares decimal
 renderers and two implementations that clamp negative integers to zero. For
 JavaScript, their adapters can be:
 
@@ -255,7 +464,7 @@ The same specification generates native tests for all seven targets. The
 integration suite checks both examples with matching implementations, then
 breaks each alternative separately to verify detection. The general equivalence law alone does not establish independent correctness;
 two implementations can share the same bug. Explicit expectations additionally
-check the specified outputs at the supplied example inputs. Quantified inputs can be `Int32` or `Text`.
+check the specified outputs at the supplied example inputs. Quantified inputs can be `Int32`, `Text`, or `Bool`.
 
 ## Text properties and idempotence
 
@@ -277,7 +486,7 @@ law `normalizers agree` is
 end
 ```
 
-The [slug example](https://github.com/brain-fuel/lawspec/blob/v0.4.0/examples/specs/slug.lawspec)
+The [slug example](https://github.com/brain-fuel/lawspec/blob/v0.6.0/examples/specs/slug.lawspec)
 compares two implementations of ASCII-space replacement. It includes empty,
 Unicode and escaped text. Each target uses its native string generator:
 JetCheck `Generator.stringsOf(Generator.asciiPrintableChars())`, Hypothesis `st.text()`, fast-check `fc.string()`,
@@ -304,7 +513,7 @@ law `canonicalization reaches a fixed point` is
 end
 ```
 
-The [canonical URL example](https://github.com/brain-fuel/lawspec/blob/v0.4.0/examples/specs/canonical_url.lawspec)
+The [canonical URL example](https://github.com/brain-fuel/lawspec/blob/v0.6.0/examples/specs/canonical_url.lawspec)
 uses removal of **all trailing slashes** as a small fixed-point demonstration,
 not a complete URL canonicalization algorithm. For JavaScript:
 
@@ -313,10 +522,10 @@ export const canonicalize = value => value.replace(/\/+$/, "");
 ```
 
 Removing just one trailing slash fails the supplied repeated-slash example.
-The [mixed-input example](https://github.com/brain-fuel/lawspec/blob/v0.4.0/examples/specs/mixed_inputs.lawspec)
+The [mixed-input example](https://github.com/brain-fuel/lawspec/blob/v0.6.0/examples/specs/mixed_inputs.lawspec)
 shows `Text` and `Int32` in the same quantified property and executable example.
-The JavaScript API represents input bindings and expected values as `number | string`.
-Each example includes `expectations: { actual: Expr; expected: number | string }[]`.
+The JavaScript API represents input bindings and expected values as `number | string | boolean`.
+Each example includes `expectations: { actual: Expr; expected: number | string | boolean }[]`.
 
 ## Generate all example artifacts
 
@@ -378,7 +587,7 @@ by the JS shim.
 ## Build and verify
 
 For contributors working from a repository checkout, build a local archive with
-`npm pack ./npm` and install it with `npm install --save-dev ./lawspec-0.4.0.tgz`.
+`npm pack ./npm` and install it with `npm install --save-dev ./lawspec-0.6.0.tgz`.
 The package payload lives in `npm/`.
 
 ```sh

package/bin/lawspec.mjs

@@ -154,7 +154,11 @@ async function init() {
 function showExpression(expr) {
   const value = expr.contents;
   if (expr.tag === "Var") return value;
-  if (expr.tag === "Number" || expr.tag === "StringLit")
+  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])})`;
@@ -181,13 +185,13 @@ function explainExamples(law) {
 async function main() {
   if (!verb || ["help", "--help", "-h"].includes(verb)) {
     output(
-      "LawSpec 0.4.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.6.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: " +
         targets.join(", "),
     );
     return;
   }
   if (verb === "--version") {
-    output("0.4.0");
+    output("0.6.0");
     return;
   }
   if (positional.length > (verb === "explain" ? 1 : 0))
@@ -207,7 +211,7 @@ async function main() {
         : result
             .map(
               (r) =>
-                `${r.target}: ${r.files.length} artifacts in ${r.directory}; ${r.preservedAdapters.length} user adapters preserved.`,
+                `${r.target}: ${r.files.length} artifacts in ${r.directory}; ${r.preservedAdapters.length} user adapters preserved.${r.adapterUpdates.length ? "\nReview required adapter signatures:\n" + r.adapterUpdates.map((a) => a.path + "\n" + a.requiredAdapter).join("\n") : ""}`,
             )
             .join("\n") +
             "\nInspection artifacts only; native toolchains and dependencies are not checked. Stubs must be implemented before running tests.",

package/build.json

@@ -17,23 +17,23 @@
     "wasm/lawspec-wasm.cabal"
   ],
   "digests": {
-    "package.yaml": "2c1176c912901bd218743a88df1b67fb1ee8d58ed73fcbe7e2f23827f10a3a0f",
+    "package.yaml": "25d79d741039fe21e1164d789fdf4f698f135df7e4c96c82560e4f7efe8fbdf9",
     "src/LawSpec/Api.hs": "00b1e4bc81231ebd387f10652463904084ebf9c3c4486fd2c2217a6d4dbfc157",
-    "src/LawSpec/Compile.hs": "336eca415ed6c8594612ad5acfc7ff6f29ef387cf3cb374b60b2407f811c31c7",
-    "src/LawSpec/Emit.hs": "2e23ca38aa5c4c65305283705633209843dd6ba116c43ba8a42ee8731040f7c3",
-    "src/LawSpec/Gen.hs": "305d7710dbc69b25d95fa6c0ac9a59622481f6b89682c1e5c9048def3962315a",
-    "src/LawSpec/Model.hs": "d1eda2b420edbc327b1adbf437c6f39a9e576ef0ab9b82f468c28202a433eb96",
-    "src/LawSpec/Parser.hs": "7fef1876c52d2204f852704150288910bb0c12bcde1d3159219ad25526a879b6",
-    "src/LawSpec/Prelude.hs": "0b60dd85bdf0642077dfb497043c63606d507e71e12d3ed8bfe2bf773214c66b",
+    "src/LawSpec/Compile.hs": "64aa042ce2f0f460d691ea43fa27bf75576a49a6e852a068f62a2cf5a28e81b7",
+    "src/LawSpec/Emit.hs": "85ab85d789c4e2c98703e2768075cb1c0bed42b987c45b5060b9a9df56e8d291",
+    "src/LawSpec/Gen.hs": "c596e411790a47cb15b2945d391b9909cbec1972bf6e502ed8c069db2c67e991",
+    "src/LawSpec/Model.hs": "549f553d1cc5d65c804a5acfac0cc06e63ff10eb80674893e32fcd3c0a71a5b3",
+    "src/LawSpec/Parser.hs": "ae7c5ad29871b99441db2dae10548afafb2ae4931dd1a62208ca0f5e3545002c",
+    "src/LawSpec/Prelude.hs": "b1e155c12f58e7c346551a0c65c5d5af76d045b3f1625977ca2a5d1c97cb8c46",
     "stack.yaml": "20ccf4d599e355e60b7aa4f814a7cd4299fe2048616cc2e6dbdc22a7bd8cec73",
     "stack.yaml.lock": "ae222b9c81af920c56e50fa4596fa57786e7fa5a7b461390362b2b2ff63818c7",
     "wasm/app/Exports.hs": "4ecbdac8faa2449e6fc61b93c82e6278fa14374154f29b4dacf0eef433f06a47",
     "wasm/cabal.project": "021e560afdc5eb4cb7169e7119ecb8f92c9ee170245af909c94b612941bff5cc",
     "wasm/cabal.project.freeze": "733dbed3d2ecccb26e874fd58f136296dad772184deb1658c196b5d54a0814dc",
-    "wasm/lawspec-wasm.cabal": "098f1d0fc52575907312c95095846d1d4f6e7ace7cfbe0419a305b9fe8a75a92",
-    "npm/core.wasm": "0a4ce15cefcd866cd7dd584c32d683c7f8a46823104afcceba1298570883a88a",
+    "wasm/lawspec-wasm.cabal": "d0d9c395b96de75264d5dc62f7995f02b285aebc696a2cf603a62b4e280f9132",
+    "npm/core.wasm": "e90e71610ca9f58a1b1e88d65f593c74d2a5b09347a4b47802bd771c954b7e42",
     "npm/core_jsffi.js": "88d136efe92f7cff5758c8fec8d9b6bbc9707fe37741cebeeb415fe34ce3d72b",
     "npm/api.mjs": "d6df654600172131ac66a55b86876fc29cde2a76a0a63bbefff3183488a4837b",
-    "npm/index.d.ts": "85ad409ae09d243d3b3f21243d0784390d7b0209e2a09fc7c3b733e8dd2e8765"
+    "npm/index.d.ts": "628016928dc71dc735d59d15ccde45500d9a4133e3b20c8d3c21cb9c65ccb604"
   }
 }

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/boolean_flags.lawspec

@@ -0,0 +1,21 @@
+unit example.boolean_flags
+
+flipFlag :: Bool -> Bool
+
+law `flipping twice restores either flag` is
+  definition is
+    `left inverse` flipFlag flipFlag
+  end
+
+  example `disabled becomes enabled and then disabled again` is
+    x = false
+    expect flipFlag x = true
+    expect flipFlag (flipFlag x) = false
+  end
+
+  example `enabled becomes disabled and then enabled again` is
+    x = true
+    expect flipFlag x = false
+    expect flipFlag (flipFlag x) = true
+  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

package/examples/specs/parse_port.lawspec

@@ -0,0 +1,66 @@
+unit example.parse_port
+
+validPort :: Int32 -> Bool
+render    :: Int32 -> Text
+parse     :: Text -> Int32
+
+law `valid ports round trip` is
+  definition is
+    `for all` (x :: Int32) .
+      validPort x implies
+        parse (render x) = x
+  end
+
+  description is
+    "For ports in 1 through 65535, {parse} recovers the value written by {render}"
+  end
+
+  example `ordinary port` is
+    x = 443
+    expect validPort x = true
+    expect render x = "443"
+    expect parse (render x) = 443
+  end
+
+  example `lowest port is accepted and round trips` is
+    x = 1
+    expect validPort x = true
+    expect render x = "1"
+    expect parse (render x) = 1
+  end
+
+  example `highest port is accepted and round trips` is
+    x = 65535
+    expect validPort x = true
+    expect render x = "65535"
+    expect parse (render x) = 65535
+  end
+
+  example `zero is rejected; rendering and parsing are skipped` is
+    x = 0
+    expect validPort x = false
+  end
+
+  example `negative port is rejected; rendering and parsing are skipped` is
+    x = -1
+    expect validPort x = false
+  end
+
+  example `65536 is rejected; rendering and parsing are skipped` is
+    x = 65536
+    expect validPort x = false
+  end
+end
+
+law `the same port contract via the prelude` is
+  definition is
+    `left inverse when` validPort parse render
+  end
+
+  example `port 8080 satisfies the inherited condition and round trips` is
+    x = 8080
+    expect validPort x = true
+    expect render x = "8080"
+    expect parse (render x) = 8080
+  end
+end

package/index.d.ts

@@ -5,12 +5,13 @@ export interface Location { file: string; line: number; column: number }
 export interface Diagnostic { code: string; message: string; at: Location | null }
 export interface Artifact { path: string; content: string; ownership: 'user' | 'generated' }
 export type Type = {tag: 'Named' | 'Variable'; contents: string} | {tag: 'Arrow'; contents: [Type, Type]};
-export type Expr = {tag: 'Var' | 'StringLit'; contents: string} | {tag: 'Number'; contents: number} | {tag: 'Apply' | 'Compose'; contents: [Expr, Expr]};
-export type Definition = {tag: 'Forall'; contents: [[string, Type][], Definition]} | {tag: 'Equal'; contents: [Expr, Expr]} | {tag: 'Invoke'; contents: [string, Expr[]]};
-export interface Expectation { actual: Expr; expected: number | string }
-export interface Example { exampleName: string; bindings: [string, number | string][]; expectations: Expectation[] }
+export type Expr = {tag: 'Var' | 'StringLit'; contents: string} | {tag: 'Number'; contents: number} | {tag: 'BoolLit'; contents: boolean} | {tag: 'Apply' | 'Compose'; contents: [Expr, Expr]};
+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: number | string | boolean }
+export interface Example { exampleName: string; bindings: [string, number | string | boolean][]; expectations: Expectation[] }
 export interface Law { lawName: string; parameters: [string, Type][]; requirements: Type[]; definition: Definition; description: string; rationale: string; examples: Example[]; references: string[]; location: Location }
-export interface Expanded { owner: string; name: string; inputs: {inputName: string; inputId: string; inputType: Type}[]; left: Expr; right: Expr; trace: string[]; original: Law }
+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: {inputName: string; inputId: string; inputType: Type}[]; left: Expr; right: Expr; guards: Expr[]; assertion: Assertion; trace: string[]; original: Law }
 export interface CheckRequest { sources: Source[] }
 export interface GenerationRequest extends CheckRequest { target: Target; sourceDir?: string; testDir?: string }
 export interface Result { diagnostics: Diagnostic[]; laws?: Expanded[]; expansions?: string[]; files?: Artifact[] }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lawspec",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "State the law once. Check it everywhere.",
   "license": "MIT",
   "type": "module",