lawspec 0.5.0 → 0.6.0

package/README.md

@@ -2,7 +2,7 @@
 
 **State the law once. Check it everywhere.**
 
-LawSpec 0.5 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.5.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.5.0 -- lawspec init --target javascript
-npm install --save-dev lawspec@0.5.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
@@ -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.5'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.
@@ -161,10 +161,10 @@ Reusable laws can declare typed unary function parameters and `requires Eq a`.
 Definitions support law application, function application/composition, universal
 quantification, `implies`, Boolean predicates, scalar literals, and equality.
 Function signatures use `Int32`, `Text`, and `Bool`; generic variables are
-supported in reusable laws. v0.5 generates quantified inputs of all three types,
+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 unary. Text literals are double-quoted, with escapes such as `\"`, `\\`,
+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.
 
@@ -179,6 +179,140 @@ Additional primitives, external law packages, cross-unit imports beyond the
 prelude, async functions, direct existing-symbol binding and browser hosting are
 outside this release.
 
+## 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
@@ -218,7 +352,7 @@ law `valid ports round trip` is
 end
 ```
 
-The [complete port example](https://github.com/brain-fuel/lawspec/blob/v0.5.0/examples/specs/parse_port.lawspec)
+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
@@ -236,7 +370,7 @@ 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.5.0/examples/specs/boolean_flags.lawspec)
+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.
@@ -315,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.5.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:
 
@@ -352,7 +486,7 @@ law `normalizers agree` is
 end
 ```
 
-The [slug example](https://github.com/brain-fuel/lawspec/blob/v0.5.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()`,
@@ -379,7 +513,7 @@ law `canonicalization reaches a fixed point` is
 end
 ```
 
-The [canonical URL example](https://github.com/brain-fuel/lawspec/blob/v0.5.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:
 
@@ -388,7 +522,7 @@ 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.5.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 | boolean`.
 Each example includes `expectations: { actual: Expr; expected: number | string | boolean }[]`.
@@ -453,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.5.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

@@ -185,13 +185,13 @@ function explainExamples(law) {
 async function main() {
   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.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.5.0");
+    output("0.6.0");
     return;
   }
   if (positional.length > (verb === "explain" ? 1 : 0))

package/build.json

@@ -17,23 +17,23 @@
     "wasm/lawspec-wasm.cabal"
   ],
   "digests": {
-    "package.yaml": "deae9eb35385fd0e08aa44432ae718e7ba6bad8e8320c728018ee9d224733c8c",
+    "package.yaml": "25d79d741039fe21e1164d789fdf4f698f135df7e4c96c82560e4f7efe8fbdf9",
     "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",
+    "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": "4c96fa2ec9c6cb61ca16f705c23cdae8723054bb252d27d8ef58043f8e31b868",
-    "npm/core.wasm": "581d42431681aa93b64bcd775d403612974f5cb9c7350be4b07d3ed49575c18e",
+    "wasm/lawspec-wasm.cabal": "d0d9c395b96de75264d5dc62f7995f02b285aebc696a2cf603a62b4e280f9132",
+    "npm/core.wasm": "e90e71610ca9f58a1b1e88d65f593c74d2a5b09347a4b47802bd771c954b7e42",
     "npm/core_jsffi.js": "88d136efe92f7cff5758c8fec8d9b6bbc9707fe37741cebeeb415fe34ce3d72b",
     "npm/api.mjs": "d6df654600172131ac66a55b86876fc29cde2a76a0a63bbefff3183488a4837b",
-    "npm/index.d.ts": "9687bedaa439c0888aa54cb94279f4fbda536122f0e55f6ab4ec3ea82ddb4283"
+    "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/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/index.d.ts

@@ -6,11 +6,12 @@ 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: '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: 'Invoke'; contents: [string, 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; guards: 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.5.0",
+  "version": "0.6.0",
   "description": "State the law once. Check it everywhere.",
   "license": "MIT",
   "type": "module",