@fncts/test 0.0.20 → 0.0.22

package/_src/data/ExecutionResult.ts

@@ -67,7 +67,6 @@ export class ExecutionResult {
     readonly annotations: List<TestAnnotationMap>,
     readonly lines: List<Line>,
   ) {}
-
   withAnnotations(annotations: List<TestAnnotationMap>): ExecutionResult {
     return new ExecutionResult(this.resultType, this.label, this.status, this.offset, annotations, this.lines);
   }
@@ -84,61 +83,65 @@ export function rendered(
 }
 
 /**
- * @tsplus operator fncts.test.ExecutionResult &&
+ * @tsplus pipeable-operator fncts.test.ExecutionResult &&
  */
-export function and_(self: ExecutionResult, that: ExecutionResult): ExecutionResult {
-  if (self.status._tag === "Ignored") {
-    return that;
-  }
-  if (that.status._tag === "Ignored") {
-    return self;
-  }
-  if (self.status._tag === "Failed" && that.status._tag === "Failed") {
-    return new ExecutionResult(
-      self.resultType,
-      self.label,
-      self.status,
-      self.offset,
-      self.annotations,
-      self.lines.concat(that.lines.tail.getOrElse(Nil())),
-    );
-  }
-  if (self.status._tag === "Passed") {
-    return that;
-  }
-  if (that.status._tag === "Passed") {
-    return self;
-  }
-  throw new Error("BUG");
+export function and(that: ExecutionResult) {
+  return (self: ExecutionResult): ExecutionResult => {
+    if (self.status._tag === "Ignored") {
+      return that;
+    }
+    if (that.status._tag === "Ignored") {
+      return self;
+    }
+    if (self.status._tag === "Failed" && that.status._tag === "Failed") {
+      return new ExecutionResult(
+        self.resultType,
+        self.label,
+        self.status,
+        self.offset,
+        self.annotations,
+        self.lines.concat(that.lines.tail.getOrElse(Nil())),
+      );
+    }
+    if (self.status._tag === "Passed") {
+      return that;
+    }
+    if (that.status._tag === "Passed") {
+      return self;
+    }
+    throw new Error("BUG");
+  };
 }
 
 /**
- * @tsplus operator fncts.test.ExecutionResult ||
+ * @tsplus pipeable-operator fncts.test.ExecutionResult ||
  */
-export function or_(self: ExecutionResult, that: ExecutionResult): ExecutionResult {
-  if (self.status._tag === "Ignored") {
-    return that;
-  }
-  if (that.status._tag === "Ignored") {
-    return self;
-  }
-  if (self.status._tag === "Failed" && that.status._tag === "Failed") {
-    return new ExecutionResult(
-      self.resultType,
-      self.label,
-      self.status,
-      self.offset,
-      self.annotations,
-      self.lines.concat(that.lines.tail.getOrElse(Nil())),
-    );
-  }
-  if (self.status._tag === "Passed") {
-    return self;
-  }
-  if (that.status._tag === "Passed") {
-    return that;
-  }
-  throw new Error("BUG");
+export function or(that: ExecutionResult) {
+  return (self: ExecutionResult): ExecutionResult => {
+    if (self.status._tag === "Ignored") {
+      return that;
+    }
+    if (that.status._tag === "Ignored") {
+      return self;
+    }
+    if (self.status._tag === "Failed" && that.status._tag === "Failed") {
+      return new ExecutionResult(
+        self.resultType,
+        self.label,
+        self.status,
+        self.offset,
+        self.annotations,
+        self.lines.concat(that.lines.tail.getOrElse(Nil())),
+      );
+    }
+    if (self.status._tag === "Passed") {
+      return self;
+    }
+    if (that.status._tag === "Passed") {
+      return that;
+    }
+    throw new Error("BUG");
+  };
 }
 
 /**

package/_src/data/FreeBooleanAlgebra/api.ts

@@ -1,30 +1,36 @@
 import { And, FreeBooleanAlgebra, FreeBooleanAlgebraTag, Not, Or, Value } from "./definition.js";
 
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebra and
- * @tsplus operator fncts.test.FreeBooleanAlgebra &&
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebra and
+ * @tsplus pipeable-operator fncts.test.FreeBooleanAlgebra &&
  */
-export function and_<A>(left: FreeBooleanAlgebra<A>, right: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A> {
-  return new And(left, right);
+export function and<A>(right: FreeBooleanAlgebra<A>) {
+  return (left: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A> => {
+    return new And(left, right);
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebra flatMap
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebra flatMap
  */
-export function flatMap_<A, B>(self: FreeBooleanAlgebra<A>, f: (a: A) => FreeBooleanAlgebra<B>): FreeBooleanAlgebra<B> {
-  return self.fold({
-    Value: f,
-    And: (l, r) => l && r,
-    Or: (l, r) => l || r,
-    Not: (v) => v.invert,
-  });
+export function flatMap<A, B>(f: (a: A) => FreeBooleanAlgebra<B>) {
+  return (self: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<B> => {
+    return self.fold({
+      Value: f,
+      And: (l, r) => l && r,
+      Or: (l, r) => l || r,
+      Not: (v) => v.invert,
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebra map
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebra map
  */
-export function map_<A, B>(self: FreeBooleanAlgebra<A>, f: (a: A) => B): FreeBooleanAlgebra<B> {
-  return self.flatMap((a) => FreeBooleanAlgebra.success(f(a)));
+export function map<A, B>(f: (a: A) => B) {
+  return (self: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<B> => {
+    return self.flatMap((a) => FreeBooleanAlgebra.success(f(a)));
+  };
 }
 
 /**
@@ -69,58 +75,60 @@ export function failures<A>(self: FreeBooleanAlgebra<A>): Maybe<FreeBooleanAlgeb
 }
 
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebra foldEval
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebra foldEval
  */
-export function foldEval_<A, B>(
-  self: FreeBooleanAlgebra<A>,
-  cases: {
-    Value: (value: A) => B;
-    And: (left: B, right: B) => B;
-    Or: (left: B, right: B) => B;
-    Not: (value: B) => B;
-  },
-): Eval<B> {
-  return Eval.defer(() => {
-    switch (self._tag) {
-      case FreeBooleanAlgebraTag.Value:
-        return Eval.now(cases.Value(self.value));
-      case FreeBooleanAlgebraTag.And:
-        return self.left.foldEval(cases).zipWith(self.right.foldEval(cases), cases.And);
-      case FreeBooleanAlgebraTag.Or:
-        return self.left.foldEval(cases).zipWith(self.right.foldEval(cases), cases.Or);
-      case FreeBooleanAlgebraTag.Not:
-        return self.result.foldEval(cases).map(cases.Not);
-    }
-  });
+export function foldEval<A, B>(cases: {
+  Value: (value: A) => B;
+  And: (left: B, right: B) => B;
+  Or: (left: B, right: B) => B;
+  Not: (value: B) => B;
+}) {
+  return (self: FreeBooleanAlgebra<A>): Eval<B> => {
+    return Eval.defer(() => {
+      switch (self._tag) {
+        case FreeBooleanAlgebraTag.Value:
+          return Eval.now(cases.Value(self.value));
+        case FreeBooleanAlgebraTag.And:
+          return self.left.foldEval(cases).zipWith(self.right.foldEval(cases), cases.And);
+        case FreeBooleanAlgebraTag.Or:
+          return self.left.foldEval(cases).zipWith(self.right.foldEval(cases), cases.Or);
+        case FreeBooleanAlgebraTag.Not:
+          return self.result.foldEval(cases).map(cases.Not);
+      }
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebra fold
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebra fold
  */
-export function fold_<A, B>(
-  self: FreeBooleanAlgebra<A>,
-  cases: {
-    Value: (value: A) => B;
-    And: (left: B, right: B) => B;
-    Or: (left: B, right: B) => B;
-    Not: (value: B) => B;
-  },
-): B {
-  return self.foldEval(cases).run;
+export function fold<A, B>(cases: {
+  Value: (value: A) => B;
+  And: (left: B, right: B) => B;
+  Or: (left: B, right: B) => B;
+  Not: (value: B) => B;
+}) {
+  return (self: FreeBooleanAlgebra<A>): B => {
+    return self.foldEval(cases).run;
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebra iff
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebra iff
  */
-export function iff_<A>(left: FreeBooleanAlgebra<A>, right: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A> {
-  return left.implies(right) && right.implies(left);
+export function iff<A>(right: FreeBooleanAlgebra<A>) {
+  return (left: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A> => {
+    return left.implies(right) && right.implies(left);
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebra implies
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebra implies
  */
-export function implies_<A>(left: FreeBooleanAlgebra<A>, right: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A> {
-  return left.invert || right;
+export function implies<A>(right: FreeBooleanAlgebra<A>) {
+  return (left: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A> => {
+    return left.invert || right;
+  };
 }
 
 /**
@@ -150,11 +158,13 @@ export function not<A>(self: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A> {
 }
 
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebra or
- * @tsplus operator fncts.test.FreeBooleanAlgebra ||
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebra or
+ * @tsplus pipeable-operator fncts.test.FreeBooleanAlgebra ||
  */
-export function or_<A>(left: FreeBooleanAlgebra<A>, right: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A> {
-  return new Or(left, right);
+export function or<A>(right: FreeBooleanAlgebra<A>) {
+  return (left: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A> => {
+    return new Or(left, right);
+  };
 }
 
 /**

package/_src/data/LogLine/Line.ts

@@ -57,10 +57,12 @@ export function prependTo(self: Line, message: Message): Message {
 }
 
 /**
- * @tsplus fluent fncts.test.data.Line withOffset
+ * @tsplus pipeable fncts.test.data.Line withOffset
  */
-export function withOffset(self: Line, shift: number): Line {
-  return new Line(self.fragments, self.offset + shift);
+export function withOffset(shift: number) {
+  return (self: Line): Line => {
+    return new Line(self.fragments, self.offset + shift);
+  };
 }
 
 /**

package/_src/data/LogLine/Message.ts

@@ -44,14 +44,14 @@ export function prependFragment(fragment: Fragment, self: Message): Message {
 /**
  * @tsplus operator fncts.test.data.Message +
  */
-export function concat_(self: Message, that: Message): Message {
+export function concat(self: Message, that: Message): Message {
   return Message(self.lines.concat(that.lines));
 }
 
 /**
  * @tsplus operator fncts.test.data.Message |
  */
-export function combine_(self: Message, that: Message): Message {
+export function combine(self: Message, that: Message): Message {
   const last = self.lines.last;
   const head = that.lines.head;
   if (last.isJust() && head.isJust()) {
@@ -62,33 +62,41 @@ export function combine_(self: Message, that: Message): Message {
 }
 
 /**
- * @tsplus fluent fncts.test.data.Message drop
+ * @tsplus pipeable fncts.test.data.Message drop
  */
-export function drop_(self: Message, n: number): Message {
-  return Message(self.lines.drop(n));
+export function drop(n: number) {
+  return (self: Message): Message => {
+    return Message(self.lines.drop(n));
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.data.Message map
+ * @tsplus pipeable fncts.test.data.Message map
  */
-export function map_(self: Message, f: (line: Line) => Line): Message {
-  return Message(self.lines.map(f));
+export function map(f: (line: Line) => Line) {
+  return (self: Message): Message => {
+    return Message(self.lines.map(f));
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.data.Message withOffset
+ * @tsplus pipeable fncts.test.data.Message withOffset
  */
-export function withOffset(self: Message, offset: number): Message {
-  return self.map((line) => line.withOffset(offset));
+export function withOffset(offset: number) {
+  return (self: Message): Message => {
+    return self.map((line) => line.withOffset(offset));
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.data.Message intersperse
+ * @tsplus pipeable fncts.test.data.Message intersperse
  */
-export function intersperse(self: Message, line: Line): Message {
-  return new Message(
-    Vector.from(
-      self.lines.foldRight(List.empty<Line>(), (ln, rest) => Cons(ln, rest.isEmpty() ? Nil() : Cons(line, rest))),
-    ),
-  );
+export function intersperse(line: Line) {
+  return (self: Message): Message => {
+    return new Message(
+      Vector.from(
+        self.lines.foldRight(List.empty<Line>(), (ln, rest) => Cons(ln, rest.isEmpty() ? Nil() : Cons(line, rest))),
+      ),
+    );
+  };
 }

package/_src/data/LogLine/Style.ts

@@ -1,5 +1,4 @@
 import type { Fragment } from "./Fragment.js";
-
 export const enum StyleTag {
   Primary = "Primary",
   Default = "Default",

package/_src/data/Render/definition.ts

@@ -8,7 +8,6 @@ export const enum RenderTag {
 export class RenderFunction {
   readonly _tag = RenderTag.Function;
   constructor(readonly name: string, readonly paramLists: Conc<Conc<RenderParam>>) {}
-
   get rendered(): string {
     return `${this.name}(${this.paramLists.map((ps) => ps.map((p) => p.rendered).join(", ")).join("")})`;
   }
@@ -17,7 +16,6 @@ export class RenderFunction {
 export class RenderInfix {
   readonly _tag = RenderTag.Infix;
   constructor(readonly left: RenderParam, readonly op: string, readonly right: RenderParam) {}
-
   get rendered(): string {
     return `(${this.left.rendered} ${this.op} ${this.right.rendered})`;
   }

package/_src/data/RenderParam/api.ts

@@ -1,7 +1,7 @@
 import type { AssertionIO } from "../../control/AssertionIO/definition.js";
 import type { RenderParam } from "./definition.js";
 
-import { show } from "@fncts/base/typeclass/Showable";
+import { show } from "@fncts/base/data/Showable";
 
 import { isAssertionIO } from "../../control/AssertionIO/definition.js";
 import { RenderAssertionIO, RenderParamTag, RenderValue } from "./definition.js";

package/_src/data/TestAnnotation/api.ts

@@ -22,7 +22,7 @@ export const TaggedTag = Tag<HashSet<string>>("fncts.test.TestAnnotation.Tagged"
 /**
  * @tsplus static fncts.test.TestAnnotationOps Tagged
  */
-export const Tagged = new TestAnnotation(TaggedTag, "tagged", HashSet.makeDefault(), (x, y) => x.union(y));
+export const Tagged = new TestAnnotation(TaggedTag, "tagged", HashSet.empty(), (x, y) => x.union(y));
 
 export const TimingTag = Tag<number>("fncts.test.TestAnnotation.Timing");
 /**
@@ -30,7 +30,9 @@ export const TimingTag = Tag<number>("fncts.test.TestAnnotation.Timing");
  */
 export const Timing = new TestAnnotation(TimingTag, "timing", 0, (x, y) => x + y);
 
-export const FibersTag = Tag<Either<number, Conc<Ref<HashSet<Fiber.Runtime<any, any>>>>>>("fncts.test.TestAnnotation.Fibers");
+export const FibersTag = Tag<Either<number, Conc<Ref<HashSet<Fiber.Runtime<any, any>>>>>>(
+  "fncts.test.TestAnnotation.Fibers",
+);
 /**
  * @tsplus static fncts.test.TestAnnotationOps Fibers
  */

package/_src/data/TestAnnotation/definition.ts

@@ -10,18 +10,15 @@ export type TestAnnotationTypeId = typeof TestAnnotationTypeId;
 export class TestAnnotation<V> implements Hashable, Equatable {
   readonly _typeId: TestAnnotationTypeId = TestAnnotationTypeId;
   readonly _V!: () => V;
-
   constructor(
     readonly tag: Tag<V>,
     readonly identifier: string,
     readonly initial: V,
     readonly combine: (v1: V, v2: V) => V,
   ) {}
-
   get [Symbol.hash]() {
     return Hashable.combine(Hashable.string(this.identifier), Hashable.unknown(this.tag));
   }
-
   [Symbol.equals](that: unknown) {
     return (
       isTestAnnotation(that) &&

package/_src/data/TestAnnotationMap.ts

@@ -4,12 +4,11 @@ import { identity } from "@fncts/base/data/function";
 
 export class TestAnnotationMap {
   constructor(private readonly map: HashMap<TestAnnotation<any>, any>) {}
-
   combine(that: TestAnnotationMap): TestAnnotationMap {
     return new TestAnnotationMap(
       Conc.from(this.map)
         .concat(Conc.from(that.map))
-        .foldLeft(HashMap.makeDefault(), (acc, [k, v]) =>
+        .foldLeft(HashMap.empty(), (acc, [k, v]) =>
           acc.set(
             k,
             acc.get(k).match(
@@ -20,22 +19,17 @@ export class TestAnnotationMap {
         ),
     );
   }
-
   get<V>(key: TestAnnotation<V>): V {
     return this.map.get(key).match(() => key.initial, identity);
   }
-
   private overwrite<V>(key: TestAnnotation<V>, value: V): TestAnnotationMap {
     return new TestAnnotationMap(this.map.set(key, value));
   }
-
   private update<V>(key: TestAnnotation<V>, f: (v: V) => V): TestAnnotationMap {
     return this.overwrite(key, f(this.get(key)));
   }
-
   annotate<V>(key: TestAnnotation<V>, value: V): TestAnnotationMap {
     return this.update(key, (_) => key.combine(_, value));
   }
-
-  static empty: TestAnnotationMap = new TestAnnotationMap(HashMap.makeDefault());
+  static empty: TestAnnotationMap = new TestAnnotationMap(HashMap.empty());
 }

package/_src/demo.ts

@@ -2,9 +2,9 @@ import { DefaultRunnableSpec } from "@fncts/test/control/DefaultRunnableSpec";
 
 import { suite, test, testIO } from "./api.js";
 import { strictEqualTo } from "./control/Assertion.js";
-
-const ServiceATag = Tag<{ x: number }>("fncts.test.demo.ServiceA");
-
+const ServiceATag = Tag<{
+  x: number;
+}>("fncts.test.demo.ServiceA");
 class DemoSpec extends DefaultRunnableSpec {
   spec = suite(
     "TestSuite",
@@ -12,5 +12,4 @@ class DemoSpec extends DefaultRunnableSpec {
     test("Demo failure", { a: { b: { c: { d: 100 } } } }.assert(strictEqualTo({ a: { b: { c: { d: 0 } } } }))),
   );
 }
-
 new DemoSpec().main();

package/_src/util/math.ts

@@ -4,7 +4,6 @@ export const MIN_VALUE_32 = 2 ** -126 * 2 ** -23;
 export const MAX_VALUE_32 = 2 ** 127 * (1 + (2 ** 23 - 1) / 2 ** 23);
 /** @internal */
 export const EPSILON_32 = 2 ** -23;
-
 /** @internal */
 const INDEX_POSITIVE_INFINITY_32 = 2139095040; // floatToIndex(MAX_VALUE_32) + 1;
 /** @internal */
@@ -23,7 +22,10 @@ export function safeFloatToIndex(f: number, label: string): IO<never, never, num
   return IO.succeedNow(index);
 }
 
-export function decomposeFloat(f: number): { exponent: number; significand: number } {
+export function decomposeFloat(f: number): {
+  exponent: number;
+  significand: number;
+} {
   // 1 => significand 0b1   - exponent 1 (will be preferred)
   //   => significand 0b0.1 - exponent 2
   const maxSignificand = 1 + (2 ** 23 - 1) / 2 ** 23;
@@ -45,11 +47,9 @@ export function floatToIndex(f: number): number {
     return INDEX_NEGATIVE_INFINITY_32;
   }
   const { exponent, significand } = decomposeFloat(f);
-
   if (Number.isNaN(exponent) || Number.isNaN(significand) || !Number.isInteger(significand * 0x800000)) {
     return Number.NaN;
   }
-
   if (f > 0 || (f === 0 && 1 / f === Number.POSITIVE_INFINITY)) {
     return indexInFloatFromDecomp(exponent, significand);
   } else {
@@ -60,10 +60,8 @@ export function floatToIndex(f: number): number {
 /** @internal */
 export function indexInFloatFromDecomp(exponent: number, significand: number) {
   // WARNING: significand >= 0
-
   // By construct of significand in decomposeFloat,
   // significand is always max-ed.
-
   // The float close to zero are the only one having a significand <1, they also have an exponent of -126.
   // They are in range: [2**(-126) * 2**(-23), 2**(-126) * (2 - 2 ** 23)]
   // In other words there are 2**24 elements in that range if we include zero.
@@ -104,15 +102,17 @@ export function indexToFloat(index: number): number {
 }
 
 /** @internal */
-export type ArrayInt64 = { sign: 1 | -1; data: [number, number] };
+export type ArrayInt64 = {
+  sign: 1 | -1;
+  data: [number, number];
+};
 
 /** @internal */
 export const Zero64: ArrayInt64 = { sign: 1, data: [0, 0] };
-
 /** @internal */
 export const Unit64: ArrayInt64 = { sign: 1, data: [0, 1] };
-
 /** @internal */
+
 export function isZero64(a: ArrayInt64): boolean {
   return a.data[0] === 0 && a.data[1] === 0;
 }
@@ -178,7 +178,6 @@ function substract64Internal(a: ArrayInt64, b: ArrayInt64): ArrayInt64 {
     const high = a.data[0] + b.data[0] + (low > 0xffffffff ? 1 : 0);
     return { sign: 1, data: [high >>> 0, low >>> 0] };
   }
-
   // a.sign === -1 with b.sign === 1 is impossible given: a - b >= 0, except for a = 0 and b = 0
   // Operation is a substraction
   return {
@@ -270,7 +269,10 @@ const INDEX_NEGATIVE_INFINITY: ArrayInt64 = { sign: -1, data: [2146435072, 1] };
  *
  * @internal
  */
-export function decomposeDouble(d: number): { exponent: number; significand: number } {
+export function decomposeDouble(d: number): {
+  exponent: number;
+  significand: number;
+} {
   // 1 => significand 0b1   - exponent 1 (will be preferred)
   //   => significand 0b0.1 - exponent 2
   const maxSignificand = 2 - Number.EPSILON;
@@ -292,10 +294,8 @@ function positiveNumberToInt64(n: number): ArrayInt64["data"] {
 /** @internal */
 function indexInDoubleFromDecomp(exponent: number, significand: number): ArrayInt64["data"] {
   // WARNING: significand >= 0
-
   // By construct of significand in decomposeDouble,
   // significand is always max-ed.
-
   // The double close to zero are the only one having a significand <1, they also have an exponent of -1022.
   // They are in range: [2**(-1022) * 2**(-52), 2**(-1022) * (2 - 2 ** 52)]
   // In other words there are 2**53 elements in that range if we include zero.
@@ -447,8 +447,14 @@ export function nextAfter(x: number, y: number) {
 export function computeBiasedRanges(
   min: ArrayInt64,
   max: ArrayInt64,
-  biasedRanges?: { min: ArrayInt64; max: ArrayInt64 }[],
-): { min: ArrayInt64; max: ArrayInt64 }[] {
+  biasedRanges?: {
+    min: ArrayInt64;
+    max: ArrayInt64;
+  }[],
+): {
+  min: ArrayInt64;
+  max: ArrayInt64;
+}[] {
   if (biasedRanges != null) {
     return biasedRanges;
   }
@@ -477,8 +483,16 @@ export function computeArrayInt64GenerateRange(
   min: ArrayInt64,
   max: ArrayInt64,
   biasFactor: number | undefined,
-  biasedRanges: { min: ArrayInt64; max: ArrayInt64 }[] | undefined,
-): UIO<{ min: ArrayInt64; max: ArrayInt64 }> {
+  biasedRanges:
+    | {
+        min: ArrayInt64;
+        max: ArrayInt64;
+      }[]
+    | undefined,
+): UIO<{
+  min: ArrayInt64;
+  max: ArrayInt64;
+}> {
   return IO.gen(function* (_) {
     if (biasFactor === undefined || (yield* _(Random.nextIntBetween(1, biasFactor))) !== 1) {
       return { min, max };