@fncts/test 0.0.20 → 0.0.22

package/api.d.ts

@@ -12,35 +12,35 @@ 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 fluent global assert 1
+ * @tsplus pipeable global assert
  * @tsplus location "@fncts/test/api"
  */
-export declare function assert_<A>(value: A, assertion: Assertion<A>): TestResult;
+export declare function assert<A>(assertion: Assertion<A>): (value: A) => TestResult;
 /**
- * @tsplus fluent global assert 0
+ * @tsplus pipeable fncts.io.IO assert
  * @tsplus location "@fncts/test/api"
  */
-export declare function assertIO_<R, E, A>(io: IO<R, E, A>, assertion: AssertionIO<A>): IO<R, E, TestResult>;
+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>;
 export declare function suite<Specs extends ReadonlyArray<Spec<any, any>>>(label: string, ...specs: Specs): Spec<_R<Specs[number]>, _E<Specs[number]>>;
 export declare function testIO<R, E>(label: string, assertion: Lazy<IO<R, E, TestResult>>): Spec<R, E>;
 export declare function test(label: string, assertion: Lazy<TestResult>): Spec<never, never>;
 /**
- * @tsplus fluent fncts.test.Gen check
+ * @tsplus pipeable fncts.test.Gen check
  * @tsplus location "@fncts/test/api"
  */
-export declare function check<R, A>(rv: Gen<R, A>, test: (a: A) => TestResult): IO<R | TestConfig, never, TestResult>;
+export declare function check<A>(test: (a: A) => TestResult): <R>(rv: Gen<R, A>) => import("@fncts/io/IO.js").IO<TestConfig | R, never, TestResult>;
 /**
- * @tsplus fluent fncts.test.Gen check
+ * @tsplus pipeable fncts.test.Gen check
  * @tsplus location "@fncts/test/api"
  */
-export declare function checkIO<R, A, R1, E>(rv: Gen<R, A>, test: (a: A) => IO<R1, E, TestResult>): IO<R | R1 | TestConfig, E, TestResult>;
+export declare function checkIO<A, R1, E>(test: (a: A) => IO<R1, E, TestResult>): <R>(rv: Gen<R, A>) => import("@fncts/io/IO.js").IO<TestConfig | R1 | R, E, TestResult>;
 /**
- * @tsplus fluent fncts.test.Gen checkAllC
+ * @tsplus pipeable fncts.test.Gen checkAllC
  * @tsplus location "@fncts/test/api"
  */
-export declare function checkAllC<R, A>(rv: Gen<R, A>, concurrency: number, test: (a: A) => TestResult): IO<R | TestConfig, never, TestResult>;
+export declare function checkAllC<A>(concurrency: number, test: (a: A) => TestResult): <R>(rv: Gen<R, A>) => import("@fncts/io/IO.js").IO<TestConfig | R, never, TestResult>;
 /**
- * @tsplus fluent fncts.test.Gen checkAllC
+ * @tsplus pipeable fncts.test.Gen checkAllC
  * @tsplus location "@fncts/test/api"
  */
-export declare function checkAllIOC<R, A, R1, E>(rv: Gen<R, A>, concurrency: number, test: (a: A) => IO<R1, E, TestResult>): IO<R | R1 | TestConfig, E, TestResult>;
+export declare function checkAllIOC<A, R1, E>(concurrency: number, test: (a: A) => IO<R1, E, TestResult>): <R>(rv: Gen<R, A>) => import("@fncts/io/IO.js").IO<TestConfig | R1 | 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

@@ -10,11 +10,11 @@ import { FreeBooleanAlgebra } from "../../data/FreeBooleanAlgebra.js";
 import { RenderParam } from "../../data/RenderParam.js";
 import { Assertion } from "./definition.js";
 /**
- * @tsplus fluent fncts.test.Assertion and
- * @tsplus operator fncts.test.Assertion &&
+ * @tsplus pipeable fncts.test.Assertion and
+ * @tsplus pipeable-operator fncts.test.Assertion &&
  * @tsplus location "@fncts/test/control/Assertion/api"
  */
-export declare function and_<A>(self: Assertion<A>, that: Assertion<A>): Assertion<A>;
+export declare function and<A>(that: Assertion<A>): (self: Assertion<A>) => Assertion<A>;
 /**
  * @tsplus static fncts.test.AssertionOps anything
  * @tsplus location "@fncts/test/control/Assertion/api"
@@ -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>;
@@ -62,25 +62,29 @@ export declare const isEmpty: Assertion<Iterable<any>>;
 export declare const isUnit: Assertion<void>;
 export declare function isLessThanOrEqualTo(n: number): Assertion<number>;
 /**
- * @tsplus fluent fncts.test.Assertion label
+ * @tsplus pipeable fncts.test.Assertion label
  * @tsplus location "@fncts/test/control/Assertion/api"
  */
-export declare function label_<A>(self: Assertion<A>, label: string): Assertion<A>;
+export declare function label(label: string): <A>(self: Assertion<A>) => Assertion<A>;
 /**
  * @tsplus getter fncts.test.Assertion invert
  * @tsplus location "@fncts/test/control/Assertion/api"
  */
 export declare function not<A>(assertion: Assertion<A>): Assertion<A>;
 /**
- * @tsplus fluent fncts.test.Assertion or
- * @tsplus operator fncts.test.Assertion ||
+ * @tsplus pipeable fncts.test.Assertion or
+ * @tsplus pipeable-operator fncts.test.Assertion ||
+ * @tsplus location "@fncts/test/control/Assertion/api"
+ */
+export declare function or<A>(that: Assertion<A>): (self: Assertion<A>) => Assertion<A>;
+/**
+ * @tsplus getter fncts.test.Assertion succeeds
  * @tsplus location "@fncts/test/control/Assertion/api"
  */
-export declare function or_<A>(self: Assertion<A>, that: Assertion<A>): Assertion<A>;
 export declare function succeeds<A>(assertion: Assertion<A>): Assertion<Exit<any, A>>;
 /**
- * @tsplus fluent fncts.test.Assertion test
+ * @tsplus pipeable fncts.test.Assertion test
  * @tsplus location "@fncts/test/control/Assertion/api"
  */
-export declare function test_<A>(self: Assertion<A>, actual: A): boolean;
+export declare function test<A>(actual: A): (self: Assertion<A>) => boolean;
 export declare const completes: Assertion<unknown>;

package/control/AssertionIO/api.d.ts

@@ -1,18 +1,18 @@
 import { AssertionIO } from "./definition.js";
 /**
- * @tsplus fluent fncts.test.AssertionIO and
- * @tsplus operator fncts.test.AssertionIO &&
+ * @tsplus pipeable fncts.test.AssertionIO and
+ * @tsplus pipeable-operator fncts.test.AssertionIO &&
  * @tsplus location "@fncts/test/control/AssertionIO/api"
  */
-export declare function and_<A>(self: AssertionIO<A>, that: AssertionIO<A>): AssertionIO<A>;
+export declare function and<A>(that: AssertionIO<A>): (self: AssertionIO<A>) => AssertionIO<A>;
 /**
- * @tsplus fluent fncts.test.AssertionIO or
- * @tsplus operator fncts.test.AssertionIO ||
+ * @tsplus pipeable fncts.test.AssertionIO or
+ * @tsplus pipeable-operator fncts.test.AssertionIO ||
  * @tsplus location "@fncts/test/control/AssertionIO/api"
  */
-export declare function or_<A>(self: AssertionIO<A>, that: AssertionIO<A>): AssertionIO<A>;
+export declare function or<A>(that: AssertionIO<A>): (self: AssertionIO<A>) => AssertionIO<A>;
 /**
- * @tsplus fluent fncts.test.AssertionIO label
+ * @tsplus pipeable fncts.test.AssertionIO label
  * @tsplus location "@fncts/test/control/AssertionIO/api"
  */
-export declare function label_<A>(self: AssertionIO<A>, label: string): AssertionIO<A>;
+export declare function label(label: string): <A>(self: AssertionIO<A>) => AssertionIO<A>;

package/control/FreeBooleanAlgebraIO/api.d.ts

@@ -1,17 +1,17 @@
 import { IO } from "@fncts/io/IO/definition";
 import type { FreeBooleanAlgebraIO } from "./definition.js";
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebraIO and
- * @tsplus operator fncts.test.FreeBooleanAlgebraIO &&
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebraIO and
+ * @tsplus pipeable-operator fncts.test.FreeBooleanAlgebraIO &&
  * @tsplus location "@fncts/test/control/FreeBooleanAlgebraIO/api"
  */
-export declare 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>;
+export declare function and<R1, E1, A1>(that: FreeBooleanAlgebraIO<R1, E1, A1>): <R, E, A extends A1>(self: FreeBooleanAlgebraIO<R, E, A>) => FreeBooleanAlgebraIO<R1 | R, E1 | E, A1 | A>;
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebraIO or
- * @tsplus operator fncts.test.FreeBooleanAlgebraIO ||
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebraIO or
+ * @tsplus pipeable-operator fncts.test.FreeBooleanAlgebraIO ||
  * @tsplus location "@fncts/test/control/FreeBooleanAlgebraIO/api"
  */
-export declare 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>;
+export declare function or<R1, E1, A1>(that: FreeBooleanAlgebraIO<R1, E1, A1>): <R, E, A extends A1>(self: FreeBooleanAlgebraIO<R, E, A>) => FreeBooleanAlgebraIO<R1 | R, E1 | E, A1 | A>;
 /**
  * @tsplus fluent fncts.test.FreeBooleanAlgebraIO invert
  * @tsplus location "@fncts/test/control/FreeBooleanAlgebraIO/api"

package/control/Gen/api.d.ts

@@ -1,66 +1,178 @@
+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 alphaNumericString: Gen<Sized, string>;
+/**
+ * @tsplus getter fncts.test.Gen array
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function array<R, A>(self: Gen<R, A>): Gen<R | Sized, ReadonlyArray<A>>;
+/**
+ * @tsplus pipeable fncts.test.Gen arrayWith
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare const anyBigInt: Gen<never, bigint>;
+export declare function arrayWith(constraints?: LengthConstraints): <R, A>(g: Gen<R, A>) => Gen<Sized | R, readonly A[]>;
 /**
- * @tsplus static fncts.test.GenOps anyDouble
+ * @tsplus pipeable fncts.test.Gen arrayN
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare const anyDouble: Gen<never, number>;
+export declare function arrayN(n: number): <R, A>(self: Gen<R, A>) => Gen<R, readonly A[]>;
 /**
- * @tsplus static fncts.test.GenOps anyInt
+ * @tsplus static fncts.test.GenOps arrayInt64
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare const anyInt: Gen<never, number>;
+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 static fncts.test.GenOps char16
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+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 fluent fncts.test.Gen flatMap
+ * @tsplus getter fncts.test.Gen conc
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function flatMap_<R, A, R1, B>(ma: Gen<R, A>, f: (a: A) => Gen<R1, B>): Gen<R | R1, B>;
+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 fluent fncts.test.Gen filter
+ * @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"
  */
-export declare function filter_<R, A, B extends A>(fa: Gen<R, A>, p: Refinement<A, B>): Gen<R, B>;
-export declare function filter_<R, A>(fa: Gen<R, A>, p: Predicate<A>): Gen<R, A>;
+export declare function filter<A, B extends A>(p: Refinement<A, B>): <R>(fa: Gen<R, A>) => Gen<R, B>;
+export declare function filter<A>(p: Predicate<A>): <R>(fa: Gen<R, A>) => Gen<R, A>;
 /**
- * @tsplus fluent fncts.test.Gen filterNot
+ * @tsplus pipeable fncts.test.Gen filterNot
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function filterNot_<R, A>(fa: Gen<R, A>, p: Predicate<A>): Gen<R, A>;
+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 fluent fncts.test.Gen map
+ * @tsplus static fncts.test.GenOps fullUnicodeChar
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function map_<R, A, B>(self: Gen<R, A>, f: (a: A) => B): Gen<R, B>;
+export declare const fullUnicodeChar: Gen<never, string>;
 /**
- * @tsplus fluent fncts.test.Gen mapIO
+ * @tsplus static fncts.test.GenOps fullUnicodeString
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function mapIO_<R, A, R1, B>(self: Gen<R, A>, f: (a: A) => IO<R1, never, B>): Gen<R | R1, 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,11 +253,19 @@ 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 fluent fncts.test.Gen reshrink
+ * @tsplus pipeable fncts.test.Gen reshrink
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function reshrink_<R, A, R1, B>(gen: Gen<R, A>, f: (a: A) => Sample<R1, B>): Gen<R | R1, B>;
+export declare function reshrink<A, R1, B>(f: (a: A) => Sample<R1, B>): <R>(gen: Gen<R, A>) => Gen<R1 | R, B>;
 /**
  * @tsplus static fncts.test.GenOps sized
  * @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"
@@ -162,7 +340,12 @@ export declare function unwrap<R, R1, A>(effect: URIO<R, Gen<R1, A>>): Gen<R | R
  */
 export declare function weighted<R, A>(...gens: ReadonlyArray<readonly [Gen<R, A>, number]>): Gen<R, A>;
 /**
- * @tsplus fluent fncts.test.Gen zipWith
+ * @tsplus pipeable fncts.test.Gen zipWith
+ * @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 zipWith_<R, A, R1, B, C>(self: Gen<R, A>, that: Gen<R1, B>, f: (a: A, b: B) => C): Gen<R | R1, C>;
+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/Sample/api.d.ts

@@ -8,45 +8,45 @@ import { Either } from "@fncts/base/data/Either/definition";
 import type { ArrayInt64 } from "@fncts/base/util/rand";
 import { Sample } from "./definition.js";
 /**
- * @tsplus fluent fncts.test.Sample flatMap
+ * @tsplus pipeable fncts.test.Sample flatMap
  * @tsplus location "@fncts/test/control/Sample/api"
  */
-export declare function flatMap_<R, A, R1, B>(ma: Sample<R, A>, f: (a: A) => Sample<R1, B>): Sample<R | R1, B>;
+export declare function flatMap<A, R1, B>(f: (a: A) => Sample<R1, B>): <R>(ma: Sample<R, A>) => Sample<R1 | R, B>;
 /**
- * @tsplus fluent fncts.test.Sample filter
+ * @tsplus pipeable fncts.test.Sample filter
  * @tsplus location "@fncts/test/control/Sample/api"
  */
-export declare function filter_<R, A>(ma: Sample<R, A>, f: Predicate<A>): Stream<R, never, Maybe<Sample<R, A>>>;
+export declare function filter<A>(f: Predicate<A>): <R>(ma: Sample<R, A>) => import("@fncts/io/Stream.js").Stream<R, never, import("@fncts/base/data/Maybe.js").Maybe<Sample<R, A>>>;
 /**
- * @tsplus fluent fncts.test.Sample foreach
+ * @tsplus pipeable fncts.test.Sample foreach
  * @tsplus location "@fncts/test/control/Sample/api"
  */
-export declare function foreach_<R, A, R1, B>(ma: Sample<R, A>, f: (a: A) => IO<R1, never, B>): IO<R | R1, never, Sample<R | R1, B>>;
+export declare function foreach<A, R1, B>(f: (a: A) => IO<R1, never, B>): <R>(ma: Sample<R, A>) => import("@fncts/io/IO.js").IO<R1 | R, never, Sample<R1 | R, B>>;
 /**
- * @tsplus fluent fncts.test.Sample map
+ * @tsplus pipeable fncts.test.Sample map
  * @tsplus location "@fncts/test/control/Sample/api"
  */
-export declare function map_<R, A, B>(ma: Sample<R, A>, f: (a: A) => B): Sample<R, B>;
+export declare function map<A, B>(f: (a: A) => B): <R>(ma: Sample<R, A>) => Sample<R, B>;
 /**
- * @tsplus fluent fncts.test.Sample shrinkSearch
+ * @tsplus pipeable fncts.test.Sample shrinkSearch
  * @tsplus location "@fncts/test/control/Sample/api"
  */
-export declare function shrinkSearch_<R, A>(ma: Sample<R, A>, p: Predicate<A>): Stream<R, never, A>;
+export declare function shrinkSearch<A>(p: Predicate<A>): <R>(ma: Sample<R, A>) => import("@fncts/io/Stream.js").Stream<R, never, A>;
 /**
  * @tsplus static fncts.test.SampleOps unfold
  * @tsplus location "@fncts/test/control/Sample/api"
  */
 export declare function unfold<R, A, S>(s: S, f: (s: S) => readonly [A, Stream<R, never, S>]): Sample<R, A>;
 /**
- * @tsplus fluent fncts.test.Sample zip
+ * @tsplus pipeable fncts.test.Sample zip
  * @tsplus location "@fncts/test/control/Sample/api"
  */
-export declare function zip<R, A, R1, B>(ma: Sample<R, A>, mb: Sample<R1, B>): Sample<R | R1, readonly [A, B]>;
+export declare function zip<R1, B>(mb: Sample<R1, B>): <R, A>(ma: Sample<R, A>) => Sample<R1 | R, readonly [A, B]>;
 /**
- * @tsplus fluent fncts.test.Sample zipWith
+ * @tsplus pipeable fncts.test.Sample zipWith
  * @tsplus location "@fncts/test/control/Sample/api"
  */
-export declare function zipWith_<R, A, R1, B, C>(ma: Sample<R, A>, mb: Sample<R1, B>, f: (a: A, b: B) => C): Sample<R | R1, C>;
+export declare function zipWith<A, R1, B, C>(mb: Sample<R1, B>, f: (a: A, b: B) => C): <R>(ma: Sample<R, A>) => Sample<R1 | R, C>;
 /**
  * @tsplus static fncts.test.SampleOps noShrink
  * @tsplus location "@fncts/test/control/Sample/api"