@fncts/test 0.0.1

package/_src/control/DefaultTestReporter/render.ts

@@ -0,0 +1,295 @@
+import type { AssertionResult, FailureDetailsResult } from "../../data/AssertionResult.js";
+import type { AssertionValue } from "../../data/AssertionValue.js";
+import type { ExecutedSpec } from "../../data/ExecutedSpec.js";
+import type { ExecutionResult } from "../../data/ExecutionResult.js";
+import type { TestResult } from "../../data/FailureDetails.js";
+import type { GenFailureDetails } from "../../data/GenFailureDetails.js";
+import type { TestAnnotationRenderer } from "../TestAnnotationRenderer.js";
+import type { TestRenderer } from "../TestRenderer/definition.js";
+
+import { matchTag } from "@fncts/base/util/pattern";
+
+import { ExecutedSpecCaseTag } from "../../data/ExecutedSpec.js";
+import { Other } from "../../data/ExecutionResult.js";
+import { Failed, Ignored, Passed, rendered, Suite, Test } from "../../data/ExecutionResult.js";
+import { detail, primary, Style } from "../../data/LogLine.js";
+import { error, fr, warn } from "../../data/LogLine.js";
+import { Fragment } from "../../data/LogLine/Fragment.js";
+import { Line } from "../../data/LogLine/Line.js";
+import { Message } from "../../data/LogLine/Message.js";
+import { TestAnnotationMap } from "../../data/TestAnnotationMap.js";
+import { TestTimeoutException } from "../../data/TestTimeoutException.js";
+import { TestLogger } from "../TestLogger.js";
+
+export type TestReporter<E> = (duration: number, spec: ExecutedSpec<E>) => URIO<Has<TestLogger>, void>;
+
+/**
+ * @tsplus static fncts.test.DefaultTestReporter report
+ */
+export function report<E>(renderTest: TestRenderer, testAnnotationRenderer: TestAnnotationRenderer): TestReporter<E> {
+  return (duration, executedSpec) => {
+    const rendered = renderTest(renderLoop(executedSpec, 0, List.empty(), List.empty()), testAnnotationRenderer);
+    const stats    = renderTest(Vector(renderStats(duration, executedSpec)), testAnnotationRenderer);
+    return IO.serviceWithIO((l) => l.logLine(rendered.concat(stats).join("\n")), TestLogger.Tag);
+  };
+}
+
+export function renderStats<E>(duration: number, executedSpec: ExecutedSpec<E>) {
+  const [success, ignore, failure] = executedSpec.fold<E, readonly [number, number, number]>(
+    matchTag({
+      Labeled: ({ spec }) => spec,
+      Multiple: ({ specs }) =>
+        specs.foldLeft(
+          [0, 0, 0] as readonly [number, number, number],
+          ([x1, x2, x3], [y1, y2, y3]) => [x1 + y1, x2 + y2, x3 + y3] as const,
+        ),
+      Test: ({ test }) =>
+        test.match(() => [0, 0, 1], matchTag({ Succeeded: () => [1, 0, 0], Ignored: () => [0, 1, 0] })) as readonly [
+          number,
+          number,
+          number,
+        ],
+    }),
+  );
+
+  const total = success + ignore + failure;
+
+  const stats = detail(
+    `Ran ${total} test${
+      total === 1 ? "" : "s"
+    } in ${duration}ms: ${success} succeeded, ${ignore} ignored, ${failure} failed`,
+  );
+
+  return rendered(Other, "", Passed, 0, List(stats.toLine));
+}
+
+/**
+ * @tsplus static fncts.test.DefaultTestRenderer render
+ */
+export function render<E>(executedSpec: ExecutedSpec<E>): Vector<ExecutionResult> {
+  return renderLoop(executedSpec, 0, Nil(), Nil());
+}
+
+function renderLoop<E>(
+  executedSpec: ExecutedSpec<E>,
+  depth: number,
+  ancestors: List<TestAnnotationMap>,
+  labels: List<string>,
+): Vector<ExecutionResult> {
+  switch (executedSpec.caseValue._tag) {
+    case ExecutedSpecCaseTag.Labeled: {
+      return renderLoop(executedSpec.caseValue.spec, depth, ancestors, labels.prepend(executedSpec.caseValue.label));
+    }
+    case ExecutedSpecCaseTag.Multiple: {
+      const specs       = executedSpec.caseValue.specs;
+      const hasFailures = executedSpec.exists((specCase) => {
+        if (specCase._tag === ExecutedSpecCaseTag.Test) {
+          return specCase.test.isLeft();
+        } else {
+          return false;
+        }
+      });
+
+      const annotations = executedSpec.fold<E, TestAnnotationMap>(
+        matchTag({
+          Labeled: ({ spec }) => spec,
+          Multiple: ({ specs }) => specs.foldLeft(TestAnnotationMap.empty, (a, b) => a.combine(b)),
+          Test: ({ annotations }) => annotations,
+        }),
+      );
+
+      const [status, renderedLabel] = specs.isEmpty
+        ? [Ignored, Vector(renderSuiteIgnored(labels.reverse.join(" - "), depth))]
+        : hasFailures
+        ? [Failed, Vector(renderSuiteFailed(labels.reverse.join(" - "), depth))]
+        : [Passed, Vector(renderSuiteSucceeded(labels.reverse.join(" - "), depth))];
+
+      const allAnnotations = ancestors.prepend(annotations);
+
+      const rest = Vector.from(specs).flatMap((spec) =>
+        renderLoop(spec, depth + 1, ancestors.prepend(annotations), List.empty()),
+      );
+
+      return rest.prepend(
+        rendered(
+          Suite,
+          labels.reverse.join(" - "),
+          status,
+          depth,
+          List.from(renderedLabel.flatMap((r) => r.lines)),
+        ).withAnnotations(allAnnotations),
+      );
+    }
+    case ExecutedSpecCaseTag.Test: {
+      const renderedResult = executedSpec.caseValue.test.match(
+        matchTag({
+          AssertionFailure: ({ result }) =>
+            result.fold<FailureDetailsResult, ExecutionResult>({
+              Value: (details) =>
+                rendered(
+                  Test,
+                  labels.reverse.join(" - "),
+                  Failed,
+                  depth,
+                  List.from(renderFailure(labels.reverse.join(" - "), depth, details).lines),
+                ),
+              And: (l, r) => l && r,
+              Or: (l, r) => l || r,
+              Not: (v) => v.invert,
+            }),
+          RuntimeFailure: ({ cause }) => renderRuntimeCause(cause, labels.reverse.join(" - "), depth, true),
+        }),
+        matchTag({
+          Succeeded: () =>
+            rendered(Test, labels.reverse.join(" - "), Passed, depth, List(fr(labels.reverse.join(" - ")).toLine)),
+          Ignored: () =>
+            rendered(Test, labels.reverse.join(" - "), Ignored, depth, List(warn(labels.reverse.join(" - ")).toLine)),
+        }),
+      );
+      return Vector(renderedResult.withAnnotations(ancestors.prepend(executedSpec.caseValue.annotations)));
+    }
+  }
+}
+
+function renderSuiteIgnored(label: string, offset: number) {
+  return rendered(Suite, label, Ignored, offset, Cons(warn(`- ${label}`).toLine));
+}
+
+function renderSuiteFailed(label: string, offset: number) {
+  return rendered(Suite, label, Failed, offset, Cons(error(`- ${label}`).toLine));
+}
+
+function renderSuiteSucceeded(label: string, offset: number) {
+  return rendered(Suite, label, Passed, offset, Cons(fr(label).toLine));
+}
+
+function renderFailure(label: string, offset: number, details: AssertionResult): Message {
+  return renderFailureLabel(label, offset).toMessage + renderAssertionResult(details, offset);
+}
+
+function renderAssertionResult(assertionResult: AssertionResult, offset: number): Message {
+  return (
+    renderGenFailureDetails(assertionResult.genFailureDetails, offset) +
+    renderAssertionFailureDetails(assertionResult.failureDetails.assertion, offset)
+  );
+}
+
+function renderFailureLabel(label: string, offset: number): Line {
+  return error("- " + label).toLine.withOffset(offset);
+}
+
+function renderAssertFailure(result: TestResult, label: string, depth: number): ExecutionResult {
+  return result.fold({
+    Value: (details) => rendered(Test, label, Failed, depth, List.from(renderFailure(label, depth, details).lines)),
+    And: (l, r) => l && r,
+    Or: (l, r) => l || r,
+    Not: (v) => v.invert,
+  });
+}
+
+function renderAssertionFailureDetails(failureDetails: Cons<AssertionValue<any>>, offset: number): Message {
+  /**
+   * @tsplus tailrec
+   */
+  function loop(failureDetails: List<AssertionValue<any>>, rendered: Message): Message {
+    const fragment = failureDetails.head;
+    const whole    = failureDetails.tail.flatMap((l) => l.head);
+    const details  = failureDetails.tail.flatMap((l) => l.tail);
+    if (fragment.isJust() && whole.isJust() && details.isJust()) {
+      return loop(Cons(whole.value, details.value), rendered + renderWhole(fragment.value, whole.value, offset));
+    } else {
+      return rendered;
+    }
+  }
+  return renderFragment(failureDetails.head, offset) + loop(failureDetails, Message.empty);
+}
+
+function renderGenFailureDetails(failureDetails: Maybe<GenFailureDetails>, offset: number): Message {
+  return failureDetails.match(
+    () => Message.empty,
+    (details) => {
+      const shrunken       = `${details.shrunkenInput}`;
+      const initial        = `${details.initialInput}`;
+      const renderShrunken = (
+        Fragment(
+          `Test failed after ${details.iterations + 1} iteration${details.iterations > 0 ? "s" : ""} with input: `,
+        ) + error(shrunken)
+      ).withOffset(offset + 1);
+
+      return initial === shrunken
+        ? renderShrunken.toMessage
+        : renderShrunken | (Fragment("Original input before shrinking was: ") + error(initial)).withOffset(offset + 1);
+    },
+  );
+}
+
+function renderFragment<A>(fragment: AssertionValue<A>, offset: number): Message {
+  return (
+    (primary(renderValue(fragment, offset + 1)) + renderSatisfied(fragment)).withOffset(offset).toMessage +
+    Message(
+      Vector.from(fragment.assertion.value.rendered.split(/\n/).map((s) => detail(s).toLine.withOffset(offset))),
+    ).withOffset(offset)
+  );
+}
+
+function renderWhole<A>(fragment: AssertionValue<A>, whole: AssertionValue<A>, offset: number) {
+  return (
+    primary(renderValue(whole, offset + 1)) +
+    renderSatisfied(whole) +
+    highlight(detail(whole.assertion.value.rendered), fragment.assertion.value.rendered)
+  );
+}
+
+function renderValue<A>(av: AssertionValue<A>, offset: number) {
+  return av.showValue(offset);
+}
+
+function expressionRedundant(valueStr: string, expression: string) {
+  const strip = (s: string) => s.replace('"', "").replace(" ", "").replace("\n", "").replace("\\n", "");
+
+  return strip(valueStr) === strip(expression);
+}
+
+function renderSatisfied<A>(assertionValue: AssertionValue<A>): Fragment {
+  return assertionValue.result.value.isSuccess ? Fragment(" satisfied ") : Fragment(" did not satisfy ");
+}
+
+function renderRuntimeCause<E>(cause: Cause<E>, label: string, depth: number, includeCause: boolean) {
+  const failureDetails = List(renderFailureLabel(label, depth)).concat(
+    List(renderCause(cause, depth))
+      .filter(() => includeCause)
+      .flatMap((l) => l.lines),
+  );
+  return rendered(Test, label, Failed, depth, List.from(failureDetails));
+}
+
+function renderCause(cause: Cause<any>, offset: number): Message {
+  const defects  = cause.defects;
+  const timeouts = defects.filterMap((u) =>
+    u instanceof TestTimeoutException ? Just(new Fragment(u.message).toLine.toMessage) : Nothing(),
+  );
+  const remaining = cause.filterDefects((u) => u instanceof TestTimeoutException);
+  const prefix    = timeouts.foldLeft(Message.empty, (b, a) => b + a);
+  return remaining.match(
+    () => prefix,
+    (remainingCause) =>
+      prefix +
+      Message(
+        Vector.from(remainingCause.prettyPrint.split("\n").map((s) => Line.fromString(s).withOffset(offset + 1))),
+      ),
+  );
+}
+
+function highlight(fragment: Fragment, substring: string, style: Style = Style.Warning): Line {
+  const parts = fragment.text.split(substring);
+  if (parts.length === 1) return fragment.toLine;
+  else {
+    return parts.foldLeft(Line.empty, (line, part) => {
+      if (line.fragments.length < parts.length * 2 - 2) {
+        return line + Fragment(part, fragment.style) + Fragment(substring, style);
+      } else {
+        return line + Fragment(part, fragment.style);
+      }
+    });
+  }
+}

package/_src/control/DefaultTestReporter.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./DefaultTestReporter/*.ts }
+export * from "./DefaultTestReporter/definition.js";
+export * from "./DefaultTestReporter/render.js";
+// codegen:end

package/_src/control/FreeBooleanAlgebraIO/api.ts

@@ -0,0 +1,67 @@
+import type { FreeBooleanAlgebraIO } from "./definition.js";
+
+import { FreeBooleanAlgebra } from "../../data/FreeBooleanAlgebra.js";
+
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebraIO and
+ * @tsplus operator fncts.test.FreeBooleanAlgebraIO &&
+ */
+export function and_<R, E, A extends A1, R1, E1, A1>(
+  self: FreeBooleanAlgebraIO<R, E, A>,
+  that: FreeBooleanAlgebraIO<R1, E1, A1>,
+): FreeBooleanAlgebraIO<R & R1, E | E1, A | A1> {
+  return self.zipWith(that, (a, b) => a && b);
+}
+
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebraIO or
+ * @tsplus operator fncts.test.FreeBooleanAlgebraIO ||
+ */
+export function or_<R, E, A extends A1, R1, E1, A1>(
+  self: FreeBooleanAlgebraIO<R, E, A>,
+  that: FreeBooleanAlgebraIO<R1, E1, A1>,
+): FreeBooleanAlgebraIO<R & R1, E | E1, A | A1> {
+  return self.zipWith(that, (a, b) => a || b);
+}
+
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebraIO invert
+ */
+export function not<R, E, A>(self: FreeBooleanAlgebraIO<R, E, A>): FreeBooleanAlgebraIO<R, E, A> {
+  return self.map((a) => a.invert);
+}
+
+/**
+ * @tsplus getter fncts.test.FreeBooleanAlgebraIO isSuccess
+ */
+export function isSuccess<R, E, A>(self: FreeBooleanAlgebraIO<R, E, A>): IO<R, E, boolean> {
+  return self.map((a) => a.isSuccess);
+}
+
+/**
+ * @tsplus getter fncts.test.FreeBooleanAlgebraIO isFailure
+ */
+export function isFailure<R, E, A>(self: FreeBooleanAlgebraIO<R, E, A>): IO<R, E, boolean> {
+  return self.map((a) => a.isFailure);
+}
+
+/**
+ * @tsplus static fncts.test.FreeBooleanAlgebraIOOps success
+ */
+export function success<A>(a: A): FreeBooleanAlgebraIO<unknown, never, A> {
+  return IO.succeedNow(FreeBooleanAlgebra.success(a));
+}
+
+/**
+ * @tsplus static fncts.test.FreeBooleanAlgebraIOOps failure
+ */
+export function failure<A>(a: A): FreeBooleanAlgebraIO<unknown, never, A> {
+  return IO.succeedNow(FreeBooleanAlgebra.failure(a));
+}
+
+/**
+ * @tsplus static fncts.test.FreeBooleanAlgebraIOOps fromIO
+ */
+export function fromIO<R, E, A>(io: IO<R, E, A>): FreeBooleanAlgebraIO<R, E, A> {
+  return io.map(FreeBooleanAlgebra.success);
+}

package/_src/control/FreeBooleanAlgebraIO/definition.ts

@@ -0,0 +1,13 @@
+import type { FreeBooleanAlgebra } from "../../data/FreeBooleanAlgebra.js";
+
+/**
+ * @tsplus type fncts.test.FreeBooleanAlgebraIO
+ */
+export type FreeBooleanAlgebraIO<R, E, A> = IO<R, E, FreeBooleanAlgebra<A>>;
+
+/**
+ * @tsplus type fncts.test.FreeBooleanAlgebraIOOps
+ */
+export interface FreeBooleanAlgebraIOOps {}
+
+export const FreeBooleanAlgebraIO: FreeBooleanAlgebraIOOps = {};

package/_src/control/FreeBooleanAlgebraIO.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./FreeBooleanAlgebraIO/*.ts }
+export * from "./FreeBooleanAlgebraIO/api.js";
+export * from "./FreeBooleanAlgebraIO/definition.js";
+// codegen:end

package/_src/control/Gen/api/array.ts

@@ -0,0 +1,31 @@
+import type { Sized } from "../../Sized.js";
+import type { EqConstraint, LengthConstraints } from "../constraints.js";
+
+import { Gen } from "../definition.js";
+
+/**
+ * @tsplus fluent fncts.test.Gen array
+ */
+export function array<R, A>(g: Gen<R, A>, constraints: LengthConstraints = {}): Gen<R & Has<Sized>, ReadonlyArray<A>> {
+  const minLength = constraints.minLength || 0;
+  return constraints.maxLength
+    ? Gen.int({ min: minLength, max: constraints.maxLength }).flatMap((n) => g.arrayN(n))
+    : Gen.small((n) => g.arrayN(n), minLength);
+}
+
+/**
+ * @tsplus fluent fncts.test.Gen arrayN
+ */
+export function arrayN_<R, A>(self: Gen<R, A>, n: number): Gen<R, ReadonlyArray<A>> {
+  return self.concN(n).map((conc) => conc.toArray);
+}
+
+/**
+ * @tsplus fluent fncts.test.Gen uniqueArray
+ */
+export function uniqueArray_<R, A>(
+  gen: Gen<R, A>,
+  constraints: LengthConstraints & EqConstraint<A> = {},
+): Gen<Has<Sized> & R, ReadonlyArray<A>> {
+  return gen.uniqueConc(constraints).map((conc) => conc.toArray);
+}

package/_src/control/Gen/api/char.ts

@@ -0,0 +1,83 @@
+import type { NumberConstraints } from "../constraints.js";
+
+import { identity } from "@fncts/base/data/function";
+
+import { Gen } from "../definition.js";
+
+const gapSize = 0xdfff + 1 - 0xd800;
+
+/**
+ * @tsplus static fncts.test.GenOps alphaNumericChar
+ */
+export const alphaNumericChar: Gen<unknown, string> = Gen.weighted(
+  [Gen.char({ min: 48, max: 57 }), 10],
+  [Gen.char({ min: 65, max: 90 }), 26],
+  [Gen.char({ min: 97, max: 122 }), 26],
+);
+
+/**
+ * @tsplus static fncts.test.GenOps asciiChar
+ */
+export const asciiChar: Gen<unknown, string> = _char(0x00, 0x7f, indexToPrintableIndex);
+
+/**
+ * @tsplus static fncts.test.GenOps base64Char
+ */
+export const base64Char: Gen<unknown, string> = _char(0, 63, base64ToCharCode);
+
+/**
+ * @tsplus static fncts.test.GenOps char
+ */
+export function char(constraints: Required<NumberConstraints>): Gen<unknown, string> {
+  return _char(constraints.min, constraints.max, identity);
+}
+
+/**
+ * @tsplus static fncts.test.GenOps char16
+ */
+export const char16: Gen<unknown, string> = _char(0x0000, 0xffff, indexToPrintableIndex);
+
+/**
+ * @tsplus static fncts.test.GenOps fullUnicodeChar
+ */
+export const fullUnicodeChar: Gen<unknown, string> = _char(0x0000, 0x10ffff - gapSize, unicodeToCharCode);
+
+/**
+ * @tsplus static fncts.test.GenOps hexChar
+ */
+export const hexChar: Gen<unknown, string> = _char(0, 15, hexToCharCode);
+
+/**
+ * @tsplus static fncts.test.GenOps printableChar
+ */
+export const printableChar: Gen<unknown, string> = char({ min: 0x20, max: 0x7e });
+
+/**
+ * @tsplus static fncts.test.GenOps unicodeChar
+ */
+export const unicodeChar: Gen<unknown, string> = _char(0x0000, 0xffff - gapSize, unicodeToCharCode);
+
+function _char(min: number, max: number, mapToCode: (v: number) => number): Gen<unknown, string> {
+  return Gen.int({ min, max }).map((n) => String.fromCharCode(mapToCode(n)));
+}
+
+function indexToPrintableIndex(v: number): number {
+  return v < 95 ? v + 0x20 : v <= 0x7e ? v - 95 : v;
+}
+
+function base64ToCharCode(v: number): number {
+  if (v < 26) return v + 65; // A-Z
+  if (v < 52) return v + 97 - 26; // a-z
+  if (v < 62) return v + 48 - 52; // 0-9
+  return v === 62 ? 43 : 47; // +/
+}
+
+function hexToCharCode(v: number): number {
+  return v < 10
+    ? v + 48 // 0-9
+    : v + 97 - 10; // a-f
+}
+
+function unicodeToCharCode(v: number): number {
+  return v < 0xd800 ? indexToPrintableIndex(v) : v + gapSize;
+}

package/_src/control/Gen/api/conc.ts

@@ -0,0 +1,50 @@
+import type { Sized } from "../../Sized.js";
+import type { EqConstraint, LengthConstraints } from "../constraints.js";
+
+import { Eq, Equatable } from "@fncts/base/typeclass";
+
+import { Gen } from "../definition.js";
+
+/**
+ * @tsplus fluent fncts.test.Gen conc
+ */
+export function conc<R, A>(self: Gen<R, A>, constraints: LengthConstraints = {}): Gen<R & Has<Sized>, Conc<A>> {
+  const minLength = constraints.minLength ?? 0;
+  return constraints.maxLength
+    ? Gen.int({ min: minLength, max: constraints.maxLength }).flatMap((n) => self.concN(n))
+    : Gen.small((n) => self.concN(n), minLength);
+}
+
+/**
+ * @tsplus fluent fncts.test.Gen concN
+ */
+export function concN_<R, A>(g: Gen<R, A>, n: number): Gen<R, Conc<A>> {
+  return Conc.replicate(n, g).foldLeft(Gen.constant(Conc.empty()) as Gen<R, Conc<A>>, (gen, a) =>
+    gen.zipWith(a, (as, a) => as.append(a)),
+  );
+}
+
+/**
+ * @tsplus fluent fncts.test.Gen uniqueConc
+ */
+export function uniqueConc_<R, A>(
+  self: Gen<R, A>,
+  constraints: LengthConstraints & EqConstraint<A> = {},
+): Gen<Has<Sized> & R, Conc<A>> {
+  const minLength = constraints.minLength ?? 0;
+  const eq        = constraints.eq ?? Eq({ equals_: Equatable.strictEquals });
+  return constraints.maxLength
+    ? Gen.bounded(minLength, constraints.maxLength, (n) => self.uniqueConcN(eq)(n))
+    : Gen.small((n) => self.uniqueConcN(eq)(n), minLength);
+}
+
+/**
+ * @tsplus getter fncts.test.Gen uniqueConcN
+ */
+export function uniqueConcN_<R, A>(self: Gen<R, A>) {
+  return (E: Eq<A>) =>
+    (n: number): Gen<R, Conc<A>> =>
+      Conc.replicate(n, self).foldLeft(Gen.constant(Conc.empty()) as Gen<R, Conc<A>>, (gen, a) =>
+        gen.zipWith(a, (as, a) => (as.elem(E)(a) ? as : as.append(a))),
+      );
+}

package/_src/control/Gen/api/double.ts

@@ -0,0 +1,64 @@
+import type { FloatConstraints, NumberConstraints } from "../constraints.js";
+import type { ArrayInt64 } from "@fncts/base/util/rand";
+
+import { IllegalArgumentError } from "@fncts/base/data/exceptions";
+
+import {
+  add64,
+  computeArrayInt64GenerateRange,
+  indexToDouble,
+  isStrictlyPositive64,
+  isStrictlySmaller64,
+  safeDoubleToIndex,
+  substract64,
+  Unit64,
+} from "../../../util/math.js";
+import { Sample } from "../../Sample.js";
+import { Gen } from "../definition.js";
+
+/**
+ * @tsplus static fncts.test.GenOps arrayInt64
+ */
+export function arrayInt64(min: ArrayInt64, max: ArrayInt64): Gen<unknown, ArrayInt64> {
+  return new Gen(
+    Stream.fromIO(computeArrayInt64GenerateRange(min, max, undefined, undefined))
+      .flatMap(({ min, max }) => Stream.repeatIO(Random.nextArrayIntBetween(min, max)))
+      .map((uncheckedValue) => {
+        if (uncheckedValue.data.length === 1) {
+          uncheckedValue.data.unshift(0);
+        }
+        return Just(Sample.shrinkArrayInt64(min)(uncheckedValue as ArrayInt64));
+      }),
+  );
+}
+
+/**
+ * @tsplus static fncts.test.GenOps double
+ */
+export function double(constraints: NumberConstraints & FloatConstraints = {}): Gen<unknown, number> {
+  const {
+    noDefaultInfinity = false,
+    noNaN = false,
+    min = noDefaultInfinity ? -Number.MAX_VALUE : Number.NEGATIVE_INFINITY,
+    max = noDefaultInfinity ? Number.MAX_VALUE : Number.POSITIVE_INFINITY,
+  } = constraints;
+  return Gen.unwrap(
+    IO.gen(function* (_) {
+      const minIndex = yield* _(safeDoubleToIndex(min, "min"));
+      const maxIndex = yield* _(safeDoubleToIndex(max, "max"));
+      if (isStrictlySmaller64(maxIndex, minIndex)) {
+        return yield* _(IO.haltNow(new IllegalArgumentError("min must be less than or equal to max", "Gen.double")));
+      }
+      if (noNaN) {
+        return arrayInt64(minIndex, maxIndex).map(indexToDouble);
+      }
+      const positiveMaxIdx  = isStrictlyPositive64(maxIndex);
+      const minIndexWithNaN = positiveMaxIdx ? minIndex : substract64(minIndex, Unit64);
+      const maxIndexWithNaN = positiveMaxIdx ? add64(maxIndex, Unit64) : maxIndex;
+      return arrayInt64(minIndexWithNaN, maxIndexWithNaN).map((index) => {
+        if (isStrictlySmaller64(maxIndex, index) || isStrictlySmaller64(index, minIndex)) return Number.NaN;
+        else return indexToDouble(index);
+      });
+    }),
+  );
+}

package/_src/control/Gen/api/float.ts

@@ -0,0 +1,36 @@
+import type { FloatConstraints, NumberConstraints } from "../constraints.js";
+
+import { indexToFloat, MAX_VALUE_32, safeFloatToIndex } from "../../../util/math.js";
+import { Gen } from "../definition.js";
+
+/**
+ * @tsplus static fncts.test.GenOps float
+ */
+export function float(constraints: NumberConstraints & FloatConstraints = {}): Gen<unknown, number> {
+  const {
+    noDefaultInfinity = false,
+    min = noDefaultInfinity ? -MAX_VALUE_32 : Number.NEGATIVE_INFINITY,
+    max = noDefaultInfinity ? MAX_VALUE_32 : Number.POSITIVE_INFINITY,
+    noNaN = false,
+  } = constraints;
+  return Gen.unwrap(
+    IO.gen(function* (_) {
+      const minIndex = yield* _(safeFloatToIndex(min, "min"));
+      const maxIndex = yield* _(safeFloatToIndex(max, "max"));
+      if (minIndex > maxIndex) {
+        return yield* _(
+          IO.haltNow(new Error("Gen.float constraints.min must be less than or equal to constraints.max")),
+        );
+      }
+      if (noNaN) {
+        return Gen.int({ min: minIndex, max: maxIndex }).map(indexToFloat);
+      }
+      const minIndexWithNaN = maxIndex > 0 ? minIndex : minIndex - 1;
+      const maxIndexWithNaN = maxIndex > 0 ? maxIndex + 1 : maxIndex;
+      return Gen.int({ min: minIndexWithNaN, max: maxIndexWithNaN }).map((index) => {
+        if (index > maxIndex || index < minIndex) return Number.NaN;
+        else return indexToFloat(index);
+      });
+    }),
+  );
+}