lawspec 0.6.0 → 0.8.0

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

@@ -0,0 +1,86 @@
+unit example.refinements
+
+refinement Between (T :: Type) (minimum :: T) (maximum :: T)
+  requires Ordered T is
+  (value :: T where minimum <= value && value <= maximum)
+end
+
+refinement Positive (T :: Type) requires Integer T is
+  (value :: T where value > 0)
+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)
+successor :: (x :: Int8) -> (result :: Integer where result == x + 1)
+count :: (text :: Text where prelude.length text > 0)
+      -> (result :: Integer where result == prelude.length text)
+preserve :: (x :: UInt64) -> (result :: Integer where result == x)
+positive :: (x :: Positive Int8) -> (result :: Positive Int8 where result == x)
+
+law `maximum input` is
+  definition is `for all` (x :: Int8) . successor x = x + 1 end
+  example `beyond Int8` is x = 127 expect successor x = 128 end
+end
+
+law `overflow pairs` is
+  definition is
+    `for all` (x :: Int8) (y :: AdditionOverflows Int8 x) .
+      add x y = x + y
+  end
+  example `smallest overflowing sum` is x = 127 y = 1 expect add x y = 128 end
+  example `largest sum` is x = 127 y = 127 expect add x y = 254 end
+end
+
+law `bounded input` is
+  definition is `for all` (x :: Between Int8 1 3) . positive x = x end
+  example `middle` is x = 2 expect positive x = 2 end
+end
+
+law `large integer` is
+  definition is `for all` (x :: UInt64) . preserve x = x end
+  example `maximum UInt64` is x = 18446744073709551615 expect preserve x = 18446744073709551615 end
+end
+
+abstractEcho :: (x :: Integer) -> (result :: Integer where result == x)
+
+law `nested presence` is
+  definition is `for all` (x :: Optional (Nullable (Positive Int8))) . x = x end
+end
+
+law `finite positive floats` is
+  definition is
+    `for all` (x :: Float32 where prelude.isFinite x && x > 0) .
+      prelude.isFinite x
+  end
+  example `positive` is x = 0.5 expect x = 0.5 end
+end
+
+law `raw byte length` is
+  definition is `for all` (x :: Bytes where prelude.length x == 3) . prelude.length x = 3 end
+  example `arbitrary octets` is x = bytes([0,128,255]) expect prelude.length x = 3 end
+end
+
+law `guarded predicate arithmetic` is
+  definition is `for all` (x :: Int8) (y :: Int8 where x != 0 && y > 10 / x) . y > 10 / x end
+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/specs/scalar_adapters.lawspec

@@ -0,0 +1,83 @@
+unit example.scalar_adapters
+echoChar :: Char -> Char
+echoCodePoint :: CodePoint -> CodePoint
+echoCodeUnit :: CodeUnit16 -> CodeUnit16
+echoBytes :: Bytes -> Bytes
+echoComplex :: Complex64 -> Complex64
+successor :: Int8 -> BigInt
+narrow :: Int8 -> Int8
+addDecimal :: Decimal -> Decimal -> Decimal
+sameSymbol :: Symbol -> Symbol -> Bool
+echoRaw :: Utf16Text -> Utf16Text
+echoPresence :: Optional (Nullable Int8) -> Optional (Nullable Int8)
+finish :: Unit -> Unit
+preserveBig :: UInt64 -> UInt64
+machineEcho :: IntSize -> IntSize
+
+law `promoted successor` is
+  definition is `for all` (x :: Int8) . successor x = x + 1 end
+  example `no overflow` is x = 127 expect successor x = 128 end
+end
+law `checked bridge` is
+  definition is `for all` (x :: Int8) . narrow (x + 0) = x end
+  example `maximum` is x = 127 expect narrow (x + 0) = 127 end
+end
+law `exact decimal adapter` is
+  definition is `for all` (x :: Decimal) (y :: Decimal) . addDecimal x y = x + y end
+  example `tenths` is x = 0.1 y = 0.2 expect addDecimal x y = 0.3 end
+end
+law `symbol identity adapter` is
+  definition is `for all` (x :: Symbol) (y :: Symbol) . sameSymbol x x and sameSymbol y y end
+  example `same description distinct identities` is
+    x = symbol("a", "same") y = symbol("b", "same")
+    expect sameSymbol x y = false
+    expect sameSymbol x x = true
+  end
+end
+law `raw adapter` is
+  definition is `for all` (x :: Utf16Text) . echoRaw x = x end
+  example `lone surrogate` is x = utf16([55296]) expect echoRaw x = utf16([55296]) end
+end
+law `presence adapter` is
+  definition is `for all` (x :: Optional (Nullable Int8)) . echoPresence x = x end
+  example `missing` is x = undefined expect echoPresence x = undefined end
+  example `null present` is x = optional(null) expect echoPresence x = optional(null) end
+end
+law `unit adapter` is
+  definition is `for all` (x :: Unit) . finish x = unitValue end
+  example `completed` is x = unitValue expect finish x = unitValue end
+end
+
+law `no safe-number truncation` is
+  definition is `for all` (x :: UInt64) . preserveBig x = x end
+  example `unsigned maximum` is x = 18446744073709551615 expect preserveBig x = 18446744073709551615 end
+end
+law `machine profile binding` is
+  definition is `for all` (x :: IntSize) . machineEcho x = x end
+  example `portable width` is x = 2147483647 expect machineEcho x = 2147483647 end
+end
+
+law `Char native bridge` is
+  definition is `for all` (x :: Char) . echoChar x = x end
+  example `native value` is x = char(128512) expect echoChar x = char(128512) end
+end
+
+law `CodePoint native bridge` is
+  definition is `for all` (x :: CodePoint) . echoCodePoint x = x end
+  example `native value` is x = codePoint(55296) expect echoCodePoint x = codePoint(55296) end
+end
+
+law `CodeUnit16 native bridge` is
+  definition is `for all` (x :: CodeUnit16) . echoCodeUnit x = x end
+  example `native value` is x = codeUnit16(65535) expect echoCodeUnit x = codeUnit16(65535) end
+end
+
+law `Bytes native bridge` is
+  definition is `for all` (x :: Bytes) . echoBytes x = x end
+  example `native value` is x = bytes([0,128,255]) expect echoBytes x = bytes([0,128,255]) end
+end
+
+law `Complex64 native bridge` is
+  definition is `for all` (x :: Complex64) . prelude.isNaN (prelude.real (echoComplex x)) = prelude.isNaN (prelude.real x) end
+  example `native value` is x = complex64(1,2) expect echoComplex x = complex64(1,2) end
+end

package/examples/specs/scalar_catalog.lawspec

@@ -0,0 +1,166 @@
+unit example.scalar_catalog
+
+law `Bool representation` is
+  definition is `for all` (x :: Bool) . x = x end
+  example `explicit value` is x = true expect x = true end
+end
+
+law `Int8 representation` is
+  definition is `for all` (x :: Int8) . x = x end
+  example `explicit value` is x = -128 expect x = -128 end
+end
+
+law `Int16 representation` is
+  definition is `for all` (x :: Int16) . x = x end
+  example `explicit value` is x = 32767 expect x = 32767 end
+end
+
+law `Int32 representation` is
+  definition is `for all` (x :: Int32) . x = x end
+  example `explicit value` is x = 2147483647 expect x = 2147483647 end
+end
+
+law `Int64 representation` is
+  definition is `for all` (x :: Int64) . x = x end
+  example `explicit value` is x = 9223372036854775807 expect x = 9223372036854775807 end
+end
+
+law `UInt8 representation` is
+  definition is `for all` (x :: UInt8) . x = x end
+  example `explicit value` is x = 255 expect x = 255 end
+end
+
+law `UInt16 representation` is
+  definition is `for all` (x :: UInt16) . x = x end
+  example `explicit value` is x = 65535 expect x = 65535 end
+end
+
+law `UInt32 representation` is
+  definition is `for all` (x :: UInt32) . x = x end
+  example `explicit value` is x = 4294967295 expect x = 4294967295 end
+end
+
+law `UInt64 representation` is
+  definition is `for all` (x :: UInt64) . x = x end
+  example `explicit value` is x = 18446744073709551615 expect x = 18446744073709551615 end
+end
+
+law `IntSize representation` is
+  definition is `for all` (x :: IntSize) . x = x end
+  example `explicit value` is x = 2147483647 expect x = 2147483647 end
+end
+
+law `UIntSize representation` is
+  definition is `for all` (x :: UIntSize) . x = x end
+  example `explicit value` is x = 4294967295 expect x = 4294967295 end
+end
+
+law `UIntPtr representation` is
+  definition is `for all` (x :: UIntPtr) . x = x end
+  example `explicit value` is x = 4294967295 expect x = 4294967295 end
+end
+
+law `BigInt representation` is
+  definition is `for all` (x :: BigInt) . x = x end
+  example `explicit value` is x = -1234567890123456789012345678901234567890 expect x = -1234567890123456789012345678901234567890 end
+end
+
+law `BigUInt representation` is
+  definition is `for all` (x :: BigUInt) . x = x end
+  example `explicit value` is x = 1234567890123456789012345678901234567890 expect x = 1234567890123456789012345678901234567890 end
+end
+
+law `Decimal representation` is
+  definition is `for all` (x :: Decimal) . x = x end
+  example `explicit value` is x = 0.000000000000000000000000000000000001 expect x = 0.000000000000000000000000000000000001 end
+end
+
+law `Rational representation` is
+  definition is `for all` (x :: Rational) . x = x end
+  example `explicit value` is x = rational(-7, 11) expect x = rational(-7, 11) end
+end
+
+law `Float32 representation` is
+  definition is `for all` (x :: Float32) . prelude.isNaN x = prelude.isNaN x end
+  example `explicit value` is x = float32Bits("80000000") expect x = float32Bits("80000000") end
+end
+
+law `Float64 representation` is
+  definition is `for all` (x :: Float64) . prelude.isNaN x = prelude.isNaN x end
+  example `explicit value` is x = float64Bits("7ff0000000000000") expect x = float64Bits("7ff0000000000000") end
+end
+
+law `Complex64 representation` is
+  definition is `for all` (x :: Complex64) . prelude.isNaN (prelude.real x) = prelude.isNaN (prelude.real x) end
+  example `explicit value` is x = complex64(1, -2) expect x = complex64(1, -2) end
+end
+
+law `Complex128 representation` is
+  definition is `for all` (x :: Complex128) . prelude.isNaN (prelude.real x) = prelude.isNaN (prelude.real x) end
+  example `explicit value` is x = complex128(0.5, -3.5) expect x = complex128(0.5, -3.5) end
+end
+
+law `Char representation` is
+  definition is `for all` (x :: Char) . x = x end
+  example `explicit value` is x = char(128512) expect x = char(128512) end
+end
+
+law `CodePoint representation` is
+  definition is `for all` (x :: CodePoint) . x = x end
+  example `explicit value` is x = codePoint(55296) expect x = codePoint(55296) end
+end
+
+law `CodeUnit16 representation` is
+  definition is `for all` (x :: CodeUnit16) . x = x end
+  example `explicit value` is x = codeUnit16(65535) expect x = codeUnit16(65535) end
+end
+
+law `Text representation` is
+  definition is `for all` (x :: Text) . x = x end
+  example `explicit value` is x = "λ日本語😀" expect x = "λ日本語😀" end
+end
+
+law `CodePointText representation` is
+  definition is `for all` (x :: CodePointText) . x = x end
+  example `explicit value` is x = codePoints([55296, 1114111]) expect x = codePoints([55296, 1114111]) end
+end
+
+law `Utf16Text representation` is
+  definition is `for all` (x :: Utf16Text) . x = x end
+  example `explicit value` is x = utf16([55296, 0, 65535]) expect x = utf16([55296, 0, 65535]) end
+end
+
+law `Bytes representation` is
+  definition is `for all` (x :: Bytes) . x = x end
+  example `explicit value` is x = bytes([0, 128, 255]) expect x = bytes([0, 128, 255]) end
+end
+
+law `Symbol representation` is
+  definition is `for all` (x :: Symbol) . x = x end
+  example `explicit value` is x = symbol("catalog", "same") expect x = symbol("catalog", "same") end
+end
+
+law `Unit representation` is
+  definition is `for all` (x :: Unit) . x = x end
+  example `explicit value` is x = unitValue expect x = unitValue end
+end
+
+law `Null representation` is
+  definition is `for all` (x :: Null) . x = x end
+  example `explicit value` is x = null expect x = null end
+end
+
+law `Undefined representation` is
+  definition is `for all` (x :: Undefined) . x = x end
+  example `explicit value` is x = undefined expect x = undefined end
+end
+
+law `Nullable Int8 representation` is
+  definition is `for all` (x :: Nullable Int8) . x = x end
+  example `explicit value` is x = nullable(127) expect x = nullable(127) end
+end
+
+law `Optional Int8 representation` is
+  definition is `for all` (x :: Optional Int8) . x = x end
+  example `explicit value` is x = undefined expect x = undefined end
+end

package/examples/specs/scalars.lawspec

@@ -0,0 +1,138 @@
+unit example.scalars
+
+law `integer promotion` is
+  definition is `for all` (x :: Int8) . x + 1 = 1 + x end
+  example `overflow is preserved` is
+    x = 127
+    expect x + 1 = 128
+  end
+end
+
+law `unsigned precision` is
+  definition is `for all` (x :: UInt64) . x + 0 = x end
+  example `maximum` is
+    x = 18446744073709551615
+    expect x + 1 = 18446744073709551616
+  end
+end
+
+law `decimal exactness` is
+  definition is `for all` (x :: Decimal) . x + 0.1 = 0.1 + x end
+  example `tenths` is
+    x = 0.1
+    expect x + 0.2 = 0.3
+  end
+end
+
+law `exact division` is
+  definition is `for all` (x :: Int16) . x / 2 = x / 2 end
+  example `one half` is
+    x = 1
+    expect x / 2 = rational(1, 2)
+    expect prelude.quot -7 3 = -2
+    expect prelude.rem -7 3 = -1
+    expect prelude.round rational(125, 100) 1 = 1.2
+  end
+end
+
+law `IEEE classification` is
+  definition is `for all` (x :: Float32) . prelude.isNaN x = prelude.isNaN x end
+  example `NaN` is
+    x = float32Bits("7fc00000")
+    expect prelude.isNaN x = true
+  end
+  example `negative zero` is
+    x = float32Bits("80000000")
+    expect prelude.isNegativeZero x = true
+    expect x = (0 :: Float32)
+  end
+  example `infinity` is
+    x = float32Bits("7f800000")
+    expect prelude.isInfinite x = true
+    expect prelude.Float32 0.1 = (0.1 :: Float32)
+  end
+end
+
+law `complex arithmetic` is
+  definition is `for all` (x :: Unit) . complex64(1, 2) * complex64(3, 4) = complex64(-5, 10) end
+  example `product` is
+    x = unitValue
+    expect complex64(1, 2) * complex64(3, 4) = complex64(-5, 10)
+  end
+end
+
+law `raw units survive` is
+  definition is `for all` (x :: Utf16Text) . x = x end
+  example `unpaired surrogate` is
+    x = utf16([55296, 0, 56320])
+    expect x = utf16([55296, 0, 56320])
+  end
+end
+
+law `arbitrary bytes` is
+  definition is `for all` (x :: Bytes) . x = x end
+  example `octets` is
+    x = bytes([0, 128, 255])
+    expect x = bytes([0, 128, 255])
+  end
+end
+
+law `symbol fixture identity` is
+  definition is `for all` (x :: Symbol) . x = x end
+  example `same reference` is
+    x = symbol("first", "description")
+    expect x = symbol("first", "description")
+  end
+end
+
+law `nested absence` is
+  definition is `for all` (x :: Optional (Nullable Int8)) . x = x end
+  example `undefined` is
+    x = undefined
+    expect x = undefined
+  end
+  example `present null` is
+    x = optional(null)
+    expect x = optional(null)
+  end
+  example `present integer` is
+    x = optional(nullable(7))
+    expect x = optional(nullable(7))
+  end
+end
+
+law `supplementary scalar` is
+  definition is `for all` (x :: Char) . x = x end
+  example `emoji` is
+    x = char(128512)
+    expect x = char(128512)
+  end
+end
+
+law `surrogate code point` is
+  definition is `for all` (x :: CodePointText) . x = x end
+  example `surrogate` is
+    x = codePoints([55296, 128512])
+    expect x = codePoints([55296, 128512])
+  end
+end
+
+law `explicit float rounding` is
+  definition is `for all` (x :: Unit) . x = x end
+  example `IEEE halfway cases` is
+    x = unitValue
+    expect prelude.Complex128 complex64(1, 2) = complex128(1, 2)
+    expect prelude.Complex64 complex128(1.25, -2.5) = complex64(1.25, -2.5)
+    expect prelude.Float32 rational(16777217, 16777216) = float32Bits("3f800000")
+    expect prelude.Float32 rational(1208925891672223212634113, 1208925819614629174706176) = float32Bits("3f800001")
+    expect prelude.Float64 rational(9007199254740993, 9007199254740992) = float64Bits("3ff0000000000000")
+    expect prelude.Float64 rational(1606938044258990453947923680586147734807949174969684883144705, 1606938044258990275541962092341162602522202993782792835301376) = float64Bits("3ff0000000000001")
+    expect prelude.Float32 rational(1, 1427247692705959881058285969449495136382746624) = float32Bits("00000000")
+    expect prelude.Float32 rational(1125899906842625, 1606938044258990275541962092341162602522202993782792835301376) = float32Bits("00000001")
+  end
+end
+
+law `short circuit exact failures` is
+  definition is `for all` (x :: Unit) . false implies 1 / 0 = rational(1, 2) end
+  example `guard prevents division` is x = unitValue expect x = unitValue end
+end

package/examples-command.mjs

@@ -21,7 +21,7 @@ export async function generateExamples(options) {
   const compiler = await createCompiler();
   const artifacts = [];
   for (const target of selected) {
-    const result = await compiler.planGeneration({ sources, target });
+    const result = await compiler.planGeneration({ sources, target, machineBits: options.machineBits ?? 64 });
     if (result.diagnostics.length)
       throw Object.assign(new Error("Bundled examples failed to compile"), {
         diagnostics: result.diagnostics,
@@ -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,