tslaws 0.6.1 → 0.6.3

package/dist/generators.js

@@ -4,6 +4,7 @@
 import * as fc from 'fast-check';
 import ts from 'typescript';
 import { arbitraryRegistry } from "./api.js";
+import { sequence } from "./sequence.js";
 export class UnsupportedType extends Error {
 }
 const numbers = fc.oneof({ weight: 4, arbitrary: fc.integer({ min: -8, max: 8 }) }, { weight: 3, arbitrary: fc.integer({ min: -1000, max: 1000 }) }, { weight: 1, arbitrary: fc.integer() }, { weight: 2, arbitrary: fc.double({ noNaN: true, noDefaultInfinity: true }) });
@@ -138,7 +139,7 @@ export class GeneratorFactory {
             return fc.constant(/x/);
         if (checker.isArrayType(type)) {
             const element = checker.getTypeArguments(type)[0];
-            return fc.array(this.of(element, depth + 1), { maxLength: 8 });
+            return sequence(this.of(element, depth + 1), { maxLength: 8 });
         }
         if (checker.isTupleType(type)) {
             const target = type.target;

package/dist/sequence.d.ts

@@ -0,0 +1,30 @@
+import * as fc from 'fast-check';
+/** Arrays of up to this many elements are shrunk by trying every subset of them: 2^12 - 1 = 4095 candidates at most. */
+export declare const EXHAUSTIVE_LENGTH = 12;
+/** The most candidates enumerated for one longer array, whatever its length. */
+export declare const CANDIDATE_CAP = 50000;
+/** The longest array whose one- and two-span removals all fit in `CANDIDATE_CAP`: C(34, 4) + 33 * 34 / 2 = 46937. */
+export declare const TWO_SPAN_LENGTH = 33;
+/**
+ * The smaller arrays to try in place of `value`, one at a time (nothing is built before it is asked for), without
+ * repeating one and never shorter than `minLength`. `fc.array` removes a run only when its length is one its integer
+ * shrinker proposes (it halves, so it skips lengths such as 2 of 3 elements), and never two separate runs, so on its own it
+ * can stop at a failing array that is longer than the shortest, such as `inc, inc, dec, reset` for `inc, reset`, and
+ * whether it does depends on the seed.
+ *
+ * - Up to `EXHAUSTIVE_LENGTH` elements: every subset of them, fewest remaining first. fast-check shrinks to a fixpoint, so
+ *   the result is a shortest failing subsequence of the array it started from.
+ * - Longer: every run removed, then every pair of runs that are apart, at most `CANDIDATE_CAP` candidates. The result is
+ *   locally minimal under removing up to two runs when all of them fit, which is the case up to `TWO_SPAN_LENGTH` elements.
+ *   Beyond that the cap cuts the search short, and repeats are no longer filtered (a repeat costs one more property run).
+ */
+export declare function withoutElements<T>(value: readonly T[], minLength: number): Generator<T[]>;
+/**
+ * `fc.array(item, { minLength, maxLength })` that also shrinks by removing elements (see `withoutElements` for what that
+ * guarantees). The values generated for a seed are those of `fc.array`; only the search for a smaller failing array differs,
+ * and it is deterministic.
+ */
+export declare function sequence<T>(item: fc.Arbitrary<T>, options: {
+    minLength?: number;
+    maxLength: number;
+}): fc.Arbitrary<T[]>;

package/dist/sequence.js

@@ -0,0 +1,131 @@
+import * as fc from 'fast-check';
+/** Arrays of up to this many elements are shrunk by trying every subset of them: 2^12 - 1 = 4095 candidates at most. */
+export const EXHAUSTIVE_LENGTH = 12;
+/** The most candidates enumerated for one longer array, whatever its length. */
+export const CANDIDATE_CAP = 50_000;
+/** The longest array whose one- and two-span removals all fit in `CANDIDATE_CAP`: C(34, 4) + 33 * 34 / 2 = 46937. */
+export const TWO_SPAN_LENGTH = 33;
+/** Combinations of `size` of the indexes `0..length - 1`, in lexicographic order, one at a time. */
+function* combinations(length, size) {
+    const at = Array.from({ length: size }, (_, i) => i);
+    for (;;) {
+        yield at.slice();
+        let i = size - 1;
+        while (i >= 0 && at[i] === length - size + i)
+            i--;
+        if (i < 0)
+            return;
+        at[i]++;
+        for (let j = i + 1; j < size; j++)
+            at[j] = at[j - 1] + 1;
+    }
+}
+/** A key that is equal for two arrays exactly when they hold the same elements (`Object.is`, objects by identity). */
+function keyOf(elements, ids) {
+    return elements
+        .map((element) => {
+        if (Object.is(element, -0))
+            return 'z';
+        let id = ids.get(element);
+        if (id === undefined) {
+            id = ids.size;
+            ids.set(element, id);
+        }
+        return id;
+    })
+        .join(',');
+}
+function* spans(value, minLength) {
+    const n = value.length;
+    let enumerated = 0;
+    // Every run of consecutive elements, shortest runs first.
+    for (let size = 1; size <= n - minLength; size++)
+        for (let start = 0; start + size <= n; start++) {
+            if (enumerated++ >= CANDIDATE_CAP)
+                return;
+            yield [...value.slice(0, start), ...value.slice(start + size)];
+        }
+    // Every two runs that are apart from each other: [a, b) and [c, d) with b < c.
+    for (let a = 0; a < n; a++)
+        for (let b = a + 1; b < n; b++)
+            for (let c = b + 1; c < n; c++)
+                for (let d = c + 1; d <= n; d++) {
+                    if (n - (b - a) - (d - c) < minLength)
+                        continue;
+                    if (enumerated++ >= CANDIDATE_CAP)
+                        return;
+                    yield [...value.slice(0, a), ...value.slice(b, c), ...value.slice(d)];
+                }
+}
+/**
+ * The smaller arrays to try in place of `value`, one at a time (nothing is built before it is asked for), without
+ * repeating one and never shorter than `minLength`. `fc.array` removes a run only when its length is one its integer
+ * shrinker proposes (it halves, so it skips lengths such as 2 of 3 elements), and never two separate runs, so on its own it
+ * can stop at a failing array that is longer than the shortest, such as `inc, inc, dec, reset` for `inc, reset`, and
+ * whether it does depends on the seed.
+ *
+ * - Up to `EXHAUSTIVE_LENGTH` elements: every subset of them, fewest remaining first. fast-check shrinks to a fixpoint, so
+ *   the result is a shortest failing subsequence of the array it started from.
+ * - Longer: every run removed, then every pair of runs that are apart, at most `CANDIDATE_CAP` candidates. The result is
+ *   locally minimal under removing up to two runs when all of them fit, which is the case up to `TWO_SPAN_LENGTH` elements.
+ *   Beyond that the cap cuts the search short, and repeats are no longer filtered (a repeat costs one more property run).
+ */
+export function* withoutElements(value, minLength) {
+    const n = value.length;
+    const ids = new Map();
+    const seen = new Set();
+    const fresh = (candidate) => {
+        if (n > TWO_SPAN_LENGTH)
+            return true;
+        const key = keyOf(candidate, ids);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    };
+    if (n <= EXHAUSTIVE_LENGTH) {
+        for (let size = minLength; size < n; size++)
+            for (const kept of combinations(n, size)) {
+                const candidate = kept.map((i) => value[i]);
+                if (fresh(candidate))
+                    yield candidate;
+            }
+        return;
+    }
+    for (const candidate of spans(value, minLength))
+        if (fresh(candidate))
+            yield candidate;
+}
+class SequenceArbitrary extends fc.Arbitrary {
+    inner;
+    minLength;
+    constructor(inner, minLength) {
+        super();
+        this.inner = inner;
+        this.minLength = minLength;
+    }
+    generate(mrng, biasFactor) {
+        const made = this.inner.generate(mrng, biasFactor);
+        return new fc.Value(made.value, { inner: made.context });
+    }
+    canShrinkWithoutContext(value) {
+        return this.inner.canShrinkWithoutContext(value);
+    }
+    shrink(value, context) {
+        const origin = context;
+        const own = this.inner
+            .shrink(value, origin?.inner)
+            .map((shrunk) => new fc.Value(shrunk.value, { inner: shrunk.context }));
+        const fewer = new fc.Stream(withoutElements(value, this.minLength)).map((shorter) => new fc.Value(shorter, { inner: undefined }));
+        return own.join(fewer);
+    }
+}
+/**
+ * `fc.array(item, { minLength, maxLength })` that also shrinks by removing elements (see `withoutElements` for what that
+ * guarantees). The values generated for a seed are those of `fc.array`; only the search for a smaller failing array differs,
+ * and it is deterministic.
+ */
+export function sequence(item, options) {
+    const minLength = options.minLength ?? 0;
+    return new SequenceArbitrary(fc.array(item, { minLength, maxLength: options.maxLength }), minLength);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tslaws",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Runs and checks `law` declarations compiled by tsc-laws: property tests, SMT proofs, tamper lock.",
   "bin": {
     "tslaws": "bin/tslaws.js"
@@ -71,11 +71,11 @@
     }
   },
   "optionalDependencies": {
-    "tslaws-compiler-darwin-arm64": "0.6.1",
-    "tslaws-compiler-darwin-x64": "0.6.1",
-    "tslaws-compiler-linux-arm64-gnu": "0.6.1",
-    "tslaws-compiler-linux-x64-gnu": "0.6.1",
-    "tslaws-compiler-win32-x64-msvc": "0.6.1"
+    "tslaws-compiler-darwin-arm64": "0.6.3",
+    "tslaws-compiler-darwin-x64": "0.6.3",
+    "tslaws-compiler-linux-arm64-gnu": "0.6.3",
+    "tslaws-compiler-linux-x64-gnu": "0.6.3",
+    "tslaws-compiler-win32-x64-msvc": "0.6.3"
   },
   "publishConfig": {
     "access": "public"