@fncts/test 0.0.21 → 0.0.23

package/_src/control/TestClock/definition.ts

@@ -4,6 +4,7 @@ import type { Live } from "@fncts/test/control/Live";
 
 import { matchTag } from "@fncts/base/util/pattern";
 import { Console } from "@fncts/io/Console";
+import { FiberStatusTag } from "@fncts/io/FiberStatus";
 import { TestAnnotation } from "@fncts/test/data/TestAnnotation";
 
 export class Data {
@@ -95,27 +96,27 @@ export class TestClock extends Clock {
   }
   sleeps = this.clockState.get.map((data) => data.sleeps.map(([_]) => _));
   get supervizedFibers(): UIO<HashSet<Fiber.Runtime<any, any>>> {
-    return IO.descriptorWith((descriptor) =>
+    return IO.fiberId.flatMap((fiberId) =>
       this.annotations.get(TestAnnotation.Fibers).flatMap((_) =>
         _.match(
-          (_) => IO.succeed(HashSet.makeDefault()),
+          (_) => IO.succeed(HashSet.empty()),
           (fibers) =>
             IO.foreach(fibers, (ref) => ref.get)
-              .map((_) => _.foldLeft(HashSet.makeDefault<Fiber.Runtime<any, any>>(), (s0, s1) => s0.union(s1)))
-              .map((set) => set.filter((f) => !Equatable.strictEquals(f.id, descriptor.id))),
+              .map((_) => _.foldLeft(HashSet.empty<Fiber.Runtime<any, any>>(), (s0, s1) => s0.union(s1)))
+              .map((set) => set.filter((f) => !Equatable.strictEquals(f.id, fiberId))),
         ),
       ),
     );
   }
   private get freeze(): IO<never, void, HashMap<FiberId, FiberStatus>> {
     return this.supervizedFibers.flatMap((fibers) =>
-      IO.foldLeft(fibers, HashMap.makeDefault<FiberId, FiberStatus>(), (map, fiber) =>
+      IO.foldLeft(fibers, HashMap.empty<FiberId, FiberStatus>(), (map, fiber) =>
         fiber.status.flatMap((status) => {
           switch (status._tag) {
-            case "Done": {
+            case FiberStatusTag.Done: {
               return IO.succeed(map.set(fiber.id, status));
             }
-            case "Suspended": {
+            case FiberStatusTag.Suspended: {
               return IO.succeed(map.set(fiber.id, status));
             }
             default: {
@@ -139,7 +140,7 @@ export class TestClock extends Clock {
       this.awaitSuspended >
       this.clockState.modify((data) => {
         const end    = f(data.duration);
-        const sorted = data.sleeps.sortWith(([x], [y]) => Number.Ord.compare(x, y));
+        const sorted = data.sleeps.sortWith(([x], [y]) => Number.Ord.compare(y)(x));
         return sorted.head
           .flatMap(([duration, promise]) =>
             duration <= end

package/_src/control/TestConsole/definition.ts

@@ -1,7 +1,7 @@
 import type { Console } from "@fncts/io/Console";
 import type { Live } from "@fncts/test/control/Live";
 
-import { showWithOptions } from "@fncts/base/typeclass/Showable";
+import { showWithOptions } from "@fncts/base/data/Showable";
 
 export class ConsoleData extends CaseClass<{
   readonly input: Vector<string>;

package/_src/control/TestRunner.ts

@@ -5,8 +5,6 @@ import type { Spec } from "@fncts/test/control/Spec";
 import type { TestExecutor } from "@fncts/test/control/TestExecutor";
 import type { ExecutedSpec } from "@fncts/test/data/ExecutedSpec";
 
-import { Console } from "@fncts/io/Console";
-import { defaultRuntimeConfig } from "@fncts/io/IO";
 import { DefaultTestReporter } from "@fncts/test/control/DefaultTestReporter";
 import { TestAnnotationRenderer } from "@fncts/test/control/TestAnnotationRenderer";
 import { TestLogger } from "@fncts/test/control/TestLogger";
@@ -17,7 +15,6 @@ export class TestRunner<R, E> {
   readonly bootstrap: Layer<never, never, TestLogger>;
   constructor(
     readonly executor: TestExecutor<R>,
-    readonly runtimeConfig: RuntimeConfig = defaultRuntimeConfig,
     reporter?: TestReporter<E>,
     bootstrap?: Layer<never, never, TestLogger>,
   ) {

package/_src/data/AssertionData.ts

@@ -10,7 +10,7 @@ export type AssertionDataTypeId = typeof AssertionDataTypeId;
  * @tsplus type fncts.test.data.AssertionData
  */
 export class AssertionData<A> {
-  readonly _typeId: AssertionDataTypeId = AssertionDataTypeId;
+  readonly [AssertionDataTypeId]: AssertionDataTypeId = AssertionDataTypeId;
   constructor(readonly value: A, readonly assertion: Assertion<A>) {}
 }
 

package/_src/data/AssertionValue/api.ts

@@ -1,4 +1,4 @@
-import { showWithOptions } from "@fncts/base/typeclass/Showable";
+import { showWithOptions } from "@fncts/base/data/Showable";
 
 import { AssertionValue } from "./definition.js";
 

package/_src/data/AssertionValue/definition.ts

@@ -8,7 +8,7 @@ export type AssertionValueTypeId = typeof AssertionValueTypeId;
  * @tsplus companion fncts.test.data.AssertionValueOps
  */
 export class AssertionValue<A> {
-  readonly _typeId: AssertionValueTypeId = AssertionValueTypeId;
+  readonly [AssertionValueTypeId]: AssertionValueTypeId = AssertionValueTypeId;
   constructor(
     readonly assertion: LazyValue<AssertionIO<A>>,
     readonly value: A,

package/_src/data/ExecutedSpec/api.ts

@@ -73,14 +73,14 @@ export function transform<E, E1>(f: (_: SpecCase<E, ExecutedSpec<E1>>) => SpecCa
 }
 
 /**
- * @tsplus pipeable fncts.test.data.ExecutedSpec exists
+ * @tsplus pipeable fncts.test.data.ExecutedSpec some
  */
-export function exists<E>(f: (_: SpecCase<E, boolean>) => boolean) {
+export function some<E>(f: (_: SpecCase<E, boolean>) => boolean) {
   return (self: ExecutedSpec<E>): boolean => {
     return self.fold(
       matchTag({
         Labeled: (c) => c.spec || f(c),
-        Multiple: (c) => c.specs.exists(identity) || f(c),
+        Multiple: (c) => c.specs.some(identity) || f(c),
         Test: f,
       }),
     );

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");
 /**

package/_src/data/TestAnnotation/definition.ts

@@ -1,4 +1,5 @@
-import { hasTypeId } from "@fncts/base/util/predicates";
+export const TestAnnotationVariance = Symbol.for("fncts.test.TestAnnotation.Variance");
+export type TestAnnotationVariance = typeof TestAnnotationVariance;
 
 export const TestAnnotationTypeId = Symbol.for("fncts.test.TestAnnotation");
 export type TestAnnotationTypeId = typeof TestAnnotationTypeId;
@@ -8,8 +9,10 @@ export type TestAnnotationTypeId = typeof TestAnnotationTypeId;
  * @tsplus companion fncts.test.TestAnnotationOps
  */
 export class TestAnnotation<V> implements Hashable, Equatable {
-  readonly _typeId: TestAnnotationTypeId = TestAnnotationTypeId;
-  readonly _V!: () => V;
+  readonly [TestAnnotationTypeId]: TestAnnotationTypeId = TestAnnotationTypeId;
+  declare [TestAnnotationVariance]: {
+    readonly _V: (_: never) => V;
+  };
   constructor(
     readonly tag: Tag<V>,
     readonly identifier: string,
@@ -30,5 +33,5 @@ export class TestAnnotation<V> implements Hashable, Equatable {
 }
 
 export function isTestAnnotation(u: unknown): u is TestAnnotation<unknown> {
-  return hasTypeId(u, TestAnnotationTypeId);
+  return isObject(u) && TestAnnotationTypeId in u;
 }

package/_src/data/TestAnnotationMap.ts

@@ -8,7 +8,7 @@ export class 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(
@@ -31,5 +31,5 @@ export class TestAnnotationMap {
   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/api.d.ts

@@ -12,12 +12,12 @@ import { Spec } from "./control/Spec.js";
 import { TestConfig } from "./data/TestConfig.js";
 export declare function traverseResult<A>(value: A, assertResult: AssertResult<A>, assertion: AssertionIO<A>): TestResult;
 /**
- * @tsplus pipeable global assert 1
+ * @tsplus pipeable global assert
  * @tsplus location "@fncts/test/api"
  */
 export declare function assert<A>(assertion: Assertion<A>): (value: A) => TestResult;
 /**
- * @tsplus pipeable global assert 0
+ * @tsplus pipeable fncts.io.IO assert
  * @tsplus location "@fncts/test/api"
  */
 export declare function assertIO<A>(assertion: AssertionIO<A>): <R, E>(io: import("@fncts/io/IO.js").IO<R, E, A>) => import("@fncts/io/IO.js").IO<R, E, TestResult>;

package/control/AbstractRunnableSpec.d.ts

@@ -10,5 +10,4 @@ export declare abstract class AbstractRunnableSpec<R, E> {
     abstract spec: Spec<R, E>;
     get _run(): URIO<TestLogger, ExecutedSpec<E>>;
     runSpec(spec: Spec<R, E>): URIO<TestLogger, ExecutedSpec<E>>;
-    get platform(): import("@fncts/io/RuntimeConfig").RuntimeConfig;
 }

package/control/Annotations/live.d.ts

@@ -2,7 +2,7 @@ import { FiberRef } from "@fncts/io/FiberRef/definition";
 import { UIO, IO } from "@fncts/io/IO/definition";
 import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 import { Fiber } from "@fncts/io/Fiber/definition";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Equatable } from "@fncts/base/data/Equatable";
 import { TestAnnotation } from "../../data/TestAnnotation.js";
 import { TestAnnotationMap } from "../../data/TestAnnotationMap.js";
 import { Annotations } from "./definition.js";

package/control/Assertion/api.d.ts

@@ -43,9 +43,9 @@ export declare function assertionRec<A, B>(name: string, params: ReadonlyArray<R
 export declare function contains<A>(element: A): Assertion<Iterable<A>>;
 export declare function containsCause<E>(cause: Cause<E>): Assertion<Cause<E>>;
 export declare function containsString(element: string): Assertion<string>;
-export declare function exists<A>(assertion: Assertion<A>): Assertion<Iterable<A>>;
+export declare function some<A>(assertion: Assertion<A>): Assertion<Iterable<A>>;
 export declare function fails<E>(assertion: Assertion<E>): Assertion<Exit<E, any>>;
-export declare function forall<A>(assertion: Assertion<A>): Assertion<Iterable<A>>;
+export declare function every<A>(assertion: Assertion<A>): Assertion<Iterable<A>>;
 export declare function halts(assertion: Assertion<any>): Assertion<Exit<any, any>>;
 export declare function strictEqualTo<A>(expected: A): Assertion<A>;
 export declare function deepEqualTo<A>(expected: A): Assertion<A>;

package/control/AssertionIO/definition.d.ts

@@ -11,7 +11,7 @@ export type AssertionIOTypeId = typeof AssertionIOTypeId;
 export declare class AssertionIO<A> {
     readonly render: Render;
     readonly runIO: (actual: A) => AssertResultIO<A>;
-    readonly _typeId: AssertionIOTypeId;
+    readonly [AssertionIOTypeId]: AssertionIOTypeId;
     constructor(render: Render, runIO: (actual: A) => AssertResultIO<A>);
     get rendered(): string;
 }

package/control/Gen/api.d.ts

@@ -1,55 +1,162 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { IO, URIO } from "@fncts/io/IO/definition";
 import { Stream } from "@fncts/io/Stream/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
-import { Conc } from "@fncts/base/collection/immutable/Conc";
-import type { NumberConstraints } from "./constraints.js";
+import { Eq } from "@fncts/base/data/Eq/definition";
+import type { EqConstraint, FloatConstraints, LengthConstraints, NumberConstraints } from "./constraints.js";
 import type { _A, _R } from "@fncts/base/types.js";
+import type { ArrayInt64 } from "@fncts/base/util/rand";
 import { Sample } from "../Sample.js";
 import { Sized } from "../Sized.js";
 import { Gen } from "./definition.js";
 /**
- * @tsplus static fncts.test.GenOps anyBigInt
+ * @tsplus static fncts.test.GenOps size
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const size: Gen<Sized, number>;
+/**
+ * @tsplus static fncts.test.GenOps uniform
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const uniform: Gen<never, number>;
+/**
+ * @tsplus static fncts.test.GenOps alphaNumericChar
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const alphaNumericChar: Gen<never, string>;
+/**
+ * @tsplus static fncts.test.GenOps alphaNumericStringWith
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function alphaNumericStringWith(constraints?: LengthConstraints): Gen<Sized, string>;
+/**
+ * @tsplus static fncts.test.GenOps alphaNumericString
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare const anyBigInt: Gen<never, bigint>;
+export declare const alphaNumericString: Gen<Sized, string>;
 /**
- * @tsplus static fncts.test.GenOps anyDouble
+ * @tsplus getter fncts.test.Gen array
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare const anyDouble: Gen<never, number>;
+export declare function array<R, A>(self: Gen<R, A>): Gen<R | Sized, ReadonlyArray<A>>;
 /**
- * @tsplus static fncts.test.GenOps anyInt
+ * @tsplus pipeable fncts.test.Gen arrayWith
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare const anyInt: Gen<never, number>;
+export declare function arrayWith(constraints?: LengthConstraints): <R, A>(g: Gen<R, A>) => Gen<Sized | R, readonly A[]>;
+/**
+ * @tsplus pipeable fncts.test.Gen arrayN
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function arrayN(n: number): <R, A>(self: Gen<R, A>) => Gen<R, readonly A[]>;
+/**
+ * @tsplus static fncts.test.GenOps arrayInt64
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function arrayInt64(min: ArrayInt64, max: ArrayInt64): Gen<never, ArrayInt64>;
+/**
+ * @tsplus static fncts.test.GenOps asciiChar
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const asciiChar: Gen<never, string>;
+/**
+ * @tsplus static fncts.test.GenOps asciiStringWith
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function asciiStringWith(constraints?: LengthConstraints): Gen<Sized, string>;
+/**
+ * @tsplus static fncts.test.GenOps asciiString
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const asciiString: Gen<Sized, string>;
+/**
+ * @tsplus static fncts.test.GenOps base64Char
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const base64Char: Gen<never, string>;
+/**
+ * @tsplus static fncts.test.GenOps base64String
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const base64String: Gen<Sized, string>;
+/**
+ * @tsplus static fncts.test.GenOps base64StringWith
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function base64StringWith(constraints?: LengthConstraints): Gen<Sized, string>;
+/**
+ * @tsplus static fncts.test.GenOps bigInt
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const bigInt: Gen<never, bigint>;
+/**
+ * @tsplus static fncts.test.GenOps boolean
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const boolean: Gen<never, boolean>;
 /**
  * @tsplus static fncts.test.GenOps bounded
  * @tsplus location "@fncts/test/control/Gen/api"
  */
 export declare function bounded<R, A>(min: number, max: number, f: (n: number) => Gen<R, A>): Gen<R, A>;
 /**
- * @tsplus static fncts.test.GenOps constant
+ * @tsplus static fncts.test.GenOps char
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function constant<A>(a: A): Gen<never, A>;
+export declare function char(constraints: Required<NumberConstraints>): Gen<never, string>;
 /**
- * @tsplus pipeable fncts.test.Gen flatMap
+ * @tsplus static fncts.test.GenOps char16
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function flatMap<A, R1, B>(f: (a: A) => Gen<R1, B>): <R>(ma: Gen<R, A>) => Gen<R1 | R, B>;
+export declare const char16: Gen<never, string>;
+/**
+ * @tsplus pipeable fncts.test.Gen conc
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function concWith(constraints?: LengthConstraints): <R, A>(self: Gen<R, A>) => Gen<Sized | R, import("@fncts/base/collection/immutable/Conc.js").Conc<A>>;
+/**
+ * @tsplus getter fncts.test.Gen conc
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function conc<R, A>(self: Gen<R, A>): Gen<R | Sized, Conc<A>>;
+/**
+ * @tsplus pipeable fncts.test.Gen concN
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function concN(n: number): <R, A>(g: Gen<R, A>) => Gen<R, import("@fncts/base/collection/immutable/Conc.js").Conc<A>>;
+/**
+ * @tsplus static fncts.test.GenOps constant
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function constant<A>(a: A): Gen<never, A>;
 /**
  * @tsplus static fncts.test.GenOps defer
  * @tsplus location "@fncts/test/control/Gen/api"
  */
 export declare function defer<R, A>(gen: Lazy<Gen<R, A>>): Gen<R, A>;
+/**
+ * @tsplus static fncts.test.GenOps double
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const double: Gen<never, number>;
+/**
+ * @tsplus static fncts.test.GenOps doubleWith
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function doubleWith(constraints?: NumberConstraints & FloatConstraints): Gen<never, number>;
 /**
  * @tsplus static fncts.test.GenOps empty
  * @tsplus location "@fncts/test/control/Gen/api"
  */
 export declare const empty: Gen<never, never>;
+/**
+ * @tsplus static fncts.test.GenOps exponential
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const exponential: Gen<never, number>;
 /**
  * @tsplus pipeable fncts.test.Gen filter
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -61,6 +168,11 @@ export declare function filter<A>(p: Predicate<A>): <R>(fa: Gen<R, A>) => Gen<R,
  * @tsplus location "@fncts/test/control/Gen/api"
  */
 export declare function filterNot<A>(p: Predicate<A>): <R>(fa: Gen<R, A>) => Gen<R, A>;
+/**
+ * @tsplus pipeable fncts.test.Gen flatMap
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function flatMap<A, R1, B>(f: (a: A) => Gen<R1, B>): <R>(ma: Gen<R, A>) => Gen<R1 | R, B>;
 /**
  * @tsplus getter fncts.test.Gen flatten
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -77,30 +189,50 @@ export declare function fromIO<R, A>(effect: IO<R, never, A>): Gen<R, A>;
  */
 export declare function fromIOSample<R, A>(effect: IO<R, never, Sample<R, A>>): Gen<R, A>;
 /**
- * @tsplus static fncts.test.GenOps int
+ * @tsplus static fncts.test.GenOps floatWith
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function int(constraints?: NumberConstraints): Gen<never, number>;
+export declare function floatWith(constraints?: NumberConstraints & FloatConstraints): Gen<never, number>;
 /**
- * @tsplus pipeable fncts.test.Gen map
+ * @tsplus static fncts.test.GenOps fullUnicodeChar
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function map<A, B>(f: (a: A) => B): <R>(self: Gen<R, A>) => Gen<R, B>;
+export declare const fullUnicodeChar: Gen<never, string>;
 /**
- * @tsplus pipeable fncts.test.Gen mapIO
+ * @tsplus static fncts.test.GenOps fullUnicodeString
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function mapIO<A, R1, B>(f: (a: A) => IO<R1, never, B>): <R>(self: Gen<R, A>) => Gen<R1 | R, B>;
+export declare function fullUnicodeString(constraints?: LengthConstraints): Gen<Sized, string>;
 /**
- * @tsplus static fncts.test.GenOps exponential
+ * @tsplus static fncts.test.GenOps hexChar
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare const exponential: Gen<never, number>;
+export declare const hexChar: Gen<never, string>;
 /**
- * @tsplus static fncts.test.GenOps size
+ * @tsplus static fncts.test.GenOps hexString
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare const size: Gen<Sized, number>;
+export declare function hexString(constraints?: LengthConstraints): Gen<Sized, string>;
+/**
+ * @tsplus static fncts.test.GenOps int
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const int: Gen<never, number>;
+/**
+ * @tsplus static fncts.test.GenOps intWith
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function intWith(constraints?: NumberConstraints): Gen<never, number>;
+/**
+ * @tsplus pipeable fncts.test.Gen map
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function map<A, B>(f: (a: A) => B): <R>(self: Gen<R, A>) => Gen<R, B>;
+/**
+ * @tsplus pipeable fncts.test.Gen mapIO
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function mapIO<A, R1, B>(f: (a: A) => IO<R1, never, B>): <R>(self: Gen<R, A>) => Gen<R1 | R, B>;
 /**
  * @tsplus static fncts.test.GenOps medium
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -121,6 +253,14 @@ export declare function nat(max?: number): Gen<unknown, number>;
  * @tsplus location "@fncts/test/control/Gen/api"
  */
 export declare function oneOf<A extends ReadonlyArray<Gen<any, any>>>(...gens: A): Gen<_R<A[number]>, _A<A[number]>>;
+export declare function partial<P extends Record<string, Gen<any, any>>>(properties: P): Gen<_R<P[keyof P]>, Partial<{
+    readonly [K in keyof P]: _A<P[K]>;
+}>>;
+/**
+ * @tsplus static fncts.test.GenOps printableChar
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const printableChar: Gen<never, string>;
 /**
  * @tsplus pipeable fncts.test.Gen reshrink
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -136,6 +276,24 @@ export declare function sized<R, A>(f: (size: number) => Gen<R, A>): Gen<R | Siz
  * @tsplus location "@fncts/test/control/Gen/api"
  */
 export declare function small<R, A>(f: (size: number) => Gen<R, A>, min?: number): Gen<R | Sized, A>;
+/**
+ * @tsplus static fncts.test.GenOps string16
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function string16(constraints?: LengthConstraints): Gen<Sized, string>;
+/**
+ * @tsplus pipeable fncts.test.Gen string
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function string(constraints?: LengthConstraints): <R>(char: Gen<R, string>) => Gen<Sized | R, string>;
+/**
+ * @tsplus pipeable fncts.test.Gen stringN
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function stringN(n: number): <R>(char: Gen<R, string>) => Gen<R, string>;
+export declare function struct<P extends Record<string, Gen<any, any>>>(properties: P): Gen<_R<P[keyof P]>, {
+    readonly [K in keyof P]: _A<P[K]>;
+}>;
 /**
  * @tsplus static fncts.test.GenOps unfoldGen
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -147,10 +305,30 @@ export declare function unfoldGen<S, R, A>(s: S, f: (s: S) => Gen<R, readonly [S
  */
 export declare function unfoldGenN<S, R, A>(n: number, s: S, f: (s: S) => Gen<R, readonly [S, A]>): Gen<R, Conc<A>>;
 /**
- * @tsplus static fncts.test.GenOps uniform
+ * @tsplus static fncts.test.GenOps unicodeChar
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare const uniform: Gen<never, number>;
+export declare const unicodeChar: Gen<never, string>;
+/**
+ * @tsplus static fncts.test.GenOps unicodeString
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function unicodeString(constraints?: LengthConstraints): Gen<Sized, string>;
+/**
+ * @tsplus pipeable fncts.test.Gen uniqueArray
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function uniqueArray<A>(constraints?: LengthConstraints & EqConstraint<A>): <R>(gen: Gen<R, A>) => Gen<Sized | R, readonly A[]>;
+/**
+ * @tsplus pipeable fncts.test.Gen uniqueConc
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function uniqueConc<A>(constraints?: LengthConstraints & EqConstraint<A>): <R>(self: Gen<R, A>) => Gen<Sized | R, import("@fncts/base/collection/immutable/Conc.js").Conc<A>>;
+/**
+ * @tsplus pipeable fncts.test.Gen uniqueConcN
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function uniqueConcN<A>(n: number, /** @tsplus auto */ E: Eq<A>): <R>(self: Gen<R, A>) => Gen<R, import("@fncts/base/collection/immutable/Conc.js").Conc<A>>;
 /**
  * @tsplus static fncts.test.GenOps unwrap
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -166,3 +344,8 @@ export declare function weighted<R, A>(...gens: ReadonlyArray<readonly [Gen<R, A
  * @tsplus location "@fncts/test/control/Gen/api"
  */
 export declare function zipWith<A, R1, B, C>(that: Gen<R1, B>, f: (a: A, b: B) => C): <R>(self: Gen<R, A>) => Gen<R1 | R, C>;
+/**
+ * @tsplus pipeable fncts.test.Gen zip
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function zip<R1, B>(that: Gen<R1, B>): <R, A>(self: Gen<R, A>) => Gen<R1 | R, readonly [A, B]>;

package/control/Gen.d.ts

@@ -1,10 +1,3 @@
 export * from "./Gen/api.js";
 export * from "./Gen/constraints.js";
 export * from "./Gen/definition.js";
-export * from "./Gen/api/array.js";
-export * from "./Gen/api/char.js";
-export * from "./Gen/api/conc.js";
-export * from "./Gen/api/double.js";
-export * from "./Gen/api/float.js";
-export * from "./Gen/api/string.js";
-export * from "./Gen/api/struct.js";

package/control/TestClock/definition.d.ts

@@ -3,12 +3,12 @@ import { Future } from "@fncts/io/Future";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { Fiber } from "@fncts/io/Fiber/definition";
 import { Clock } from "@fncts/io/Clock/definition";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Duration } from "@fncts/base/data/Duration/definition";
 import { IO, UIO } from "@fncts/io/IO/definition";
 import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Equatable } from "@fncts/base/data/Equatable";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { Just, Nothing } from "@fncts/base/data/Maybe/definition";
 import type { Annotations } from "@fncts/test/control/Annotations";

package/control/TestConsole/definition.d.ts

@@ -1,6 +1,6 @@
 import { CaseClass } from "@fncts/base/data/CaseClass";
 import { Vector } from "@fncts/base/collection/immutable/Vector";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 import { FiberRef } from "@fncts/io/FiberRef/definition";
 import { UIO, IO } from "@fncts/io/IO/definition";
 import type { Console } from "@fncts/io/Console";
@@ -24,8 +24,8 @@ export declare class TestConsole implements Console {
     show(...input: ReadonlyArray<unknown>): UIO<void>;
     print(line: string): UIO<void>;
     error(line: string): UIO<void>;
-    clearInput: import("@fncts/io/IO").UIO<void>;
-    clearOutput: import("@fncts/io/IO").UIO<void>;
+    clearInput: import("@fncts/io/IO").IO<never, never, void>;
+    clearOutput: import("@fncts/io/IO").IO<never, never, void>;
     output: import("@fncts/io/IO").IO<never, never, import("@fncts/base/collection/immutable/Vector").Vector<string>>;
     errOutput: import("@fncts/io/IO").IO<never, never, import("@fncts/base/collection/immutable/Vector").Vector<string>>;
     debugOutput: import("@fncts/io/IO").IO<never, never, import("@fncts/base/collection/immutable/Vector").Vector<string>>;

package/control/TestRandom/definition.d.ts

@@ -1,5 +1,5 @@
 import { Random } from "@fncts/io/Random/definition";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 import { UIO, IO } from "@fncts/io/IO/definition";
 import { Vector } from "@fncts/base/collection/immutable/Vector";
 import { Byte } from "@fncts/base/data/Byte";