@fncts/test 0.0.19 → 0.0.21

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 1
  * @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 global assert 0
  * @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/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"
@@ -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/array.d.ts

@@ -2,17 +2,17 @@ import type { Sized } from "../../Sized.js";
 import type { EqConstraint, LengthConstraints } from "../constraints.js";
 import { Gen } from "../definition.js";
 /**
- * @tsplus fluent fncts.test.Gen array
+ * @tsplus pipeable fncts.test.Gen array
  * @tsplus location "@fncts/test/control/Gen/api/array"
  */
-export declare function array<R, A>(g: Gen<R, A>, constraints?: LengthConstraints): Gen<R | Sized, ReadonlyArray<A>>;
+export declare function array(constraints?: LengthConstraints): <R, A>(g: Gen<R, A>) => Gen<Sized | R, readonly A[]>;
 /**
- * @tsplus fluent fncts.test.Gen arrayN
+ * @tsplus pipeable fncts.test.Gen arrayN
  * @tsplus location "@fncts/test/control/Gen/api/array"
  */
-export declare function arrayN_<R, A>(self: Gen<R, A>, n: number): Gen<R, ReadonlyArray<A>>;
+export declare function arrayN(n: number): <R, A>(self: Gen<R, A>) => Gen<R, readonly A[]>;
 /**
- * @tsplus fluent fncts.test.Gen uniqueArray
+ * @tsplus pipeable fncts.test.Gen uniqueArray
  * @tsplus location "@fncts/test/control/Gen/api/array"
  */
-export declare function uniqueArray_<R, A>(gen: Gen<R, A>, constraints?: LengthConstraints & EqConstraint<A>): Gen<Sized | R, ReadonlyArray<A>>;
+export declare function uniqueArray<A>(constraints?: LengthConstraints & EqConstraint<A>): <R>(gen: Gen<R, A>) => Gen<Sized | R, readonly A[]>;

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

@@ -4,22 +4,22 @@ import type { EqConstraint, LengthConstraints } from "../constraints.js";
 import { Eq } from "@fncts/base/typeclass";
 import { Gen } from "../definition.js";
 /**
- * @tsplus fluent fncts.test.Gen conc
+ * @tsplus pipeable fncts.test.Gen conc
  * @tsplus location "@fncts/test/control/Gen/api/conc"
  */
-export declare function conc<R, A>(self: Gen<R, A>, constraints?: LengthConstraints): Gen<R | Sized, Conc<A>>;
+export declare function conc(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 concN
+ * @tsplus pipeable fncts.test.Gen concN
  * @tsplus location "@fncts/test/control/Gen/api/conc"
  */
-export declare function concN_<R, A>(g: Gen<R, A>, n: number): Gen<R, Conc<A>>;
+export declare function concN(n: number): <R, A>(g: Gen<R, A>) => Gen<R, import("@fncts/base/collection/immutable/Conc.js").Conc<A>>;
 /**
- * @tsplus fluent fncts.test.Gen uniqueConc
+ * @tsplus pipeable fncts.test.Gen uniqueConc
  * @tsplus location "@fncts/test/control/Gen/api/conc"
  */
-export declare function uniqueConc_<R, A>(self: Gen<R, A>, constraints?: LengthConstraints & EqConstraint<A>): Gen<Sized | R, Conc<A>>;
+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 fluent fncts.test.Gen uniqueConcN
+ * @tsplus pipeable fncts.test.Gen uniqueConcN
  * @tsplus location "@fncts/test/control/Gen/api/conc"
  */
-export declare function uniqueConcN_<R, A>(self: Gen<R, A>, n: number, /** @tsplus auto */ E: Eq<A>): Gen<R, Conc<A>>;
+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>>;

package/control/Gen/api/string.d.ts

@@ -32,15 +32,15 @@ export declare function hexString(constraints?: LengthConstraints): Gen<Sized, s
  */
 export declare function string16(constraints?: LengthConstraints): Gen<Sized, string>;
 /**
- * @tsplus fluent fncts.test.Gen string
+ * @tsplus pipeable fncts.test.Gen string
  * @tsplus location "@fncts/test/control/Gen/api/string"
  */
-export declare function string<R>(char: Gen<R, string>, constraints?: LengthConstraints): Gen<R | Sized, string>;
+export declare function string(constraints?: LengthConstraints): <R>(char: Gen<R, string>) => Gen<Sized | R, string>;
 /**
- * @tsplus fluent fncts.test.Gen stringN
+ * @tsplus pipeable fncts.test.Gen stringN
  * @tsplus location "@fncts/test/control/Gen/api/string"
  */
-export declare function stringN<R>(char: Gen<R, string>, n: number): Gen<R, string>;
+export declare function stringN(n: number): <R>(char: Gen<R, string>) => Gen<R, string>;
 /**
  * @tsplus static fncts.test.GenOps unicodeString
  * @tsplus location "@fncts/test/control/Gen/api/string"

package/control/Gen/api.d.ts

@@ -36,10 +36,10 @@ export declare function bounded<R, A>(min: number, max: number, f: (n: number) =
  */
 export declare function constant<A>(a: A): Gen<never, A>;
 /**
- * @tsplus fluent fncts.test.Gen flatMap
+ * @tsplus pipeable fncts.test.Gen flatMap
  * @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 flatMap<A, R1, B>(f: (a: A) => Gen<R1, B>): <R>(ma: Gen<R, A>) => Gen<R1 | R, B>;
 /**
  * @tsplus static fncts.test.GenOps defer
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -51,16 +51,16 @@ export declare function defer<R, A>(gen: Lazy<Gen<R, A>>): Gen<R, A>;
  */
 export declare const empty: Gen<never, never>;
 /**
- * @tsplus fluent fncts.test.Gen filter
+ * @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 getter fncts.test.Gen flatten
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -82,15 +82,15 @@ export declare function fromIOSample<R, A>(effect: IO<R, never, Sample<R, A>>):
  */
 export declare function int(constraints?: NumberConstraints): Gen<never, number>;
 /**
- * @tsplus fluent fncts.test.Gen map
+ * @tsplus pipeable fncts.test.Gen map
  * @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 function map<A, B>(f: (a: A) => B): <R>(self: Gen<R, A>) => Gen<R, B>;
 /**
- * @tsplus fluent fncts.test.Gen mapIO
+ * @tsplus pipeable fncts.test.Gen mapIO
  * @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 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 exponential
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -122,10 +122,10 @@ export declare function nat(max?: number): Gen<unknown, number>;
  */
 export declare function oneOf<A extends ReadonlyArray<Gen<any, any>>>(...gens: A): Gen<_R<A[number]>, _A<A[number]>>;
 /**
- * @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"
@@ -162,7 +162,7 @@ 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_<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 zipWith<A, R1, B, C>(that: Gen<R1, B>, f: (a: A, b: B) => C): <R>(self: Gen<R, A>) => Gen<R1 | R, C>;

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"

package/control/Spec/api.d.ts

@@ -22,20 +22,20 @@ import { PSpec } from "./definition.js";
  */
 export declare function annotated<R, E, T>(spec: PSpec<R, E, T>): PSpec<R | Annotations, Annotated<E>, Annotated<T>>;
 /**
- * @tsplus fluent fncts.test.PSpec combine
+ * @tsplus pipeable fncts.test.PSpec combine
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function combine_<R, E, T, R1, E1, T1>(self: PSpec<R, E, T>, that: PSpec<R1, E1, T1>): PSpec<R | R1, E | E1, T | T1>;
+export declare function combine<R1, E1, T1>(that: PSpec<R1, E1, T1>): <R, E, T>(self: PSpec<R, E, T>) => PSpec<R1 | R, E1 | E, T1 | T>;
 /**
- * @tsplus fluent fncts.test.PSpec contramapEnvironment
+ * @tsplus pipeable fncts.test.PSpec contramapEnvironment
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function contramapEnvironment_<R, E, T, R0>(self: PSpec<R, E, T>, f: (r0: Environment<R0>) => Environment<R>): PSpec<R0, E, T>;
+export declare function contramapEnvironment<R, R0>(f: (r0: Environment<R0>) => Environment<R>): <E, T>(self: PSpec<R, E, T>) => PSpec<R0, E, T>;
 /**
- * @tsplus fluent fncts.test.PSpec countTests
+ * @tsplus pipeable fncts.test.PSpec countTests
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function countTests_<R, E, T>(spec: PSpec<R, E, T>, f: (t: T) => boolean): IO<R | Scope, E, number>;
+export declare function countTests<T>(f: (t: T) => boolean): <R, E>(spec: PSpec<R, E, T>) => import("@fncts/io/IO.js").IO<import("@fncts/io/Scope.js").Scope | R, E, number>;
 /**
  * @tsplus static fncts.test.PSpecOps empty
  * @tsplus location "@fncts/test/control/Spec/api"
@@ -48,45 +48,45 @@ export declare const empty: PSpec<never, never, never>;
  */
 export declare function exec<R, E, T>(spec: PSpec<R, E, T>, exec: ExecutionStrategy): PSpec<R, E, T>;
 /**
- * @tsplus fluent fncts.test.PSpec execute
+ * @tsplus pipeable fncts.test.PSpec execute
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function execute<R, E, T>(self: PSpec<R, E, T>, defExec: ExecutionStrategy): IO<R | Scope, never, PSpec<never, E, T>>;
+export declare function execute(defExec: ExecutionStrategy): <R, E, T>(self: PSpec<R, E, T>) => import("@fncts/io/IO.js").IO<import("@fncts/io/Scope.js").Scope | R, never, PSpec<never, E, T>>;
 /**
- * @tsplus fluent fncts.test.PSpec filterAnnotations
+ * @tsplus pipeable fncts.test.PSpec filterAnnotations
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function filterAnnotations_<R, E, T, V>(spec: PSpec<R, E, T>, key: TestAnnotation<V>, f: (v: V) => boolean): Maybe<PSpec<R, E, T>>;
+export declare function filterAnnotations<V>(key: TestAnnotation<V>, f: (v: V) => boolean): <R, E, T>(spec: PSpec<R, E, T>) => import("@fncts/base/data/Maybe.js").Maybe<PSpec<R, E, T>>;
 /**
- * @tsplus fluent fncts.test.PSpec filterLabels
+ * @tsplus pipeable fncts.test.PSpec filterLabels
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function filterLabels_<R, E, T>(spec: PSpec<R, E, T>, f: (label: string) => boolean): Maybe<PSpec<R, E, T>>;
+export declare function filterLabels(f: (label: string) => boolean): <R, E, T>(spec: PSpec<R, E, T>) => import("@fncts/base/data/Maybe.js").Maybe<PSpec<R, E, T>>;
 /**
- * @tsplus fluent fncts.test.PSpec filterTags
+ * @tsplus pipeable fncts.test.PSpec filterTags
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function filterTags_<R, E, T>(spec: PSpec<R, E, T>, f: (tag: string) => boolean): Maybe<PSpec<R, E, T>>;
+export declare function filterTags(f: (tag: string) => boolean): <R, E, T>(spec: PSpec<R, E, T>) => import("@fncts/base/data/Maybe.js").Maybe<PSpec<R, E, T>>;
 /**
- * @tsplus fluent fncts.test.PSpec filterByArgs
+ * @tsplus pipeable fncts.test.PSpec filterByArgs
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function filterByArgs<R, E>(spec: Spec<R, E>, args: TestArgs): Spec<R, E>;
+export declare function filterByArgs(args: TestArgs): <R, E>(spec: Spec<R, E>) => Spec<R, E>;
 /**
- * @tsplus fluent fncts.test.PSpec fold
+ * @tsplus pipeable fncts.test.PSpec fold
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function fold_<R, E, T, Z>(spec: PSpec<R, E, T>, f: (_: SpecCase<R, E, T, Z>) => Z): Z;
+export declare function fold<R, E, T, Z>(f: (_: SpecCase<R, E, T, Z>) => Z): (spec: PSpec<R, E, T>) => Z;
 /**
- * @tsplus fluent fncts.test.PSpec foldScoped
+ * @tsplus pipeable fncts.test.PSpec foldScoped
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function foldScoped_<R, E, T, R1, E1, Z>(spec: PSpec<R, E, T>, f: (_: SpecCase<R, E, T, Z>) => IO<R1 | Scope, E1, Z>, defExec: ExecutionStrategy): IO<R | R1 | Scope, E1, Z>;
+export declare function foldScoped<R, E, T, R1, E1, Z>(f: (_: SpecCase<R, E, T, Z>) => IO<R1 | Scope, E1, Z>, defExec: ExecutionStrategy): (spec: PSpec<R, E, T>) => IO<R | R1 | Scope, E1, Z>;
 /**
- * @tsplus fluent fncts.test.PSpec foreachExec
+ * @tsplus pipeable fncts.test.PSpec foreachExec
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function foreachExec_<R, E, T, R1, E1, A, R2, E2, B>(spec: PSpec<R, E, T>, failure: (c: Cause<E>) => IO<R1, E1, A>, success: (t: T) => IO<R2, E2, B>, defExec: ExecutionStrategy): IO<R | R1 | R2 | Scope, never, PSpec<R | R1 | R2, E1 | E2, A | B>>;
+export declare function foreachExec<E, T, R1, E1, A, R2, E2, B>(failure: (c: Cause<E>) => IO<R1, E1, A>, success: (t: T) => IO<R2, E2, B>, defExec: ExecutionStrategy): <R>(spec: PSpec<R, E, T>) => import("@fncts/io/IO.js").IO<import("@fncts/io/Scope.js").Scope | R1 | R2 | R, never, PSpec<R1 | R2 | R, E1 | E2, A | B>>;
 /**
  * @tsplus fluent fncts.test.PSpec labeled
  * @tsplus static fncts.test.PSpecOps labeled
@@ -95,63 +95,60 @@ export declare function foreachExec_<R, E, T, R1, E1, A, R2, E2, B>(spec: PSpec<
  */
 export declare function labeledCase<R, E, T>(spec: PSpec<R, E, T>, label: string): PSpec<R, E, T>;
 /**
- * @tsplus fluent fncts.test.PSpec scoped
  * @tsplus static fncts.test.PSpecOps scoped
  * @tsplus static fncts.test.PSpec.ScopedCaseOps __call
  * @tsplus location "@fncts/test/control/Spec/api"
  */
 export declare function scoped<R, E, T>(managed: IO<R | Scope, E, PSpec<R, E, T>>): PSpec<R, E, T>;
 /**
- * @tsplus fluent fncts.test.SpecCase mapError
+ * @tsplus pipeable fncts.test.SpecCase mapError
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function mapError<R, E, T, E1>(self: PSpec<R, E, T>, f: (e: E) => E1): PSpec<R, E1, T>;
+export declare function mapError<E, E1>(f: (e: E) => E1): <R, T>(self: PSpec<R, E, T>) => PSpec<R, E1, T>;
 /**
- * @tsplus fluent fncts.test.SpecCase map
+ * @tsplus pipeable fncts.test.SpecCase map
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function mapSpecCase_<R, E, T, A, B>(fa: SpecCase<R, E, T, A>, f: (a: A) => B): SpecCase<R, E, T, B>;
+export declare function mapSpecCase<A, B>(f: (a: A) => B): <R, E, T>(fa: SpecCase<R, E, T, A>) => SpecCase<R, E, T, B>;
 /**
- * @tsplus fluent fncts.test.PSpec multiple
  * @tsplus static fncts.test.PSpecOps multiple
  * @tsplus static fncts.test.PSpec.MultipleCaseOps __call
  * @tsplus location "@fncts/test/control/Spec/api"
  */
 export declare function multipleCase<R, E, T>(specs: Conc<PSpec<R, E, T>>): PSpec<R, E, T>;
 /**
- * @tsplus fluent fncts.test.PSpec provideEnvironment
+ * @tsplus pipeable fncts.test.PSpec provideEnvironment
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function provideEnvironment_<R, E, T>(self: PSpec<R, E, T>, r: Environment<R>): PSpec<never, E, T>;
+export declare function provideEnvironment<R>(r: Environment<R>): <E, T>(self: PSpec<R, E, T>) => PSpec<never, E, T>;
 /**
- * @tsplus fluent fncts.test.PSpec provideLayer
+ * @tsplus pipeable fncts.test.PSpec provideLayer
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function provideLayer_<RIn, E, ROut, E1, T>(self: PSpec<ROut, E1, T>, layer: Layer<RIn, E, ROut>): PSpec<RIn, E | E1, T>;
+export declare function provideLayer<RIn, E, ROut>(layer: Layer<RIn, E, ROut>): <E1, T>(self: PSpec<ROut, E1, T>) => PSpec<RIn, E | E1, T>;
 /**
- * @tsplus fluent fncts.test.PSpec test
  * @tsplus static fncts.test.PSpecOps test
  * @tsplus static fncts.test.PSpec.TestCaseOps __call
  * @tsplus location "@fncts/test/control/Spec/api"
  */
 export declare function testCase<R, E, T>(test: IO<R, E, T>, annotations: TestAnnotationMap): PSpec<R, E, T>;
 /**
- * @tsplus fluent fncts.test.PSpec transform
+ * @tsplus pipeable fncts.test.PSpec transform
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function transform_<R, E, T, R1, E1, T1>(spec: PSpec<R, E, T>, f: (_: SpecCase<R, E, T, PSpec<R1, E1, T1>>) => SpecCase<R1, E1, T1, PSpec<R1, E1, T1>>): PSpec<R1, E1, T1>;
+export declare function transform<R, E, T, R1, E1, T1>(f: (_: SpecCase<R, E, T, PSpec<R1, E1, T1>>) => SpecCase<R1, E1, T1, PSpec<R1, E1, T1>>): (spec: PSpec<R, E, T>) => PSpec<R1, E1, T1>;
 /**
- * @tsplus fluent fncts.test.PSpec annotate
+ * @tsplus pipeable fncts.test.PSpec annotate
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function annotate_<R, E, T, V>(self: PSpec<R, E, T>, key: TestAnnotation<V>, value: V): PSpec<R, E, T>;
+export declare function annotate<V>(key: TestAnnotation<V>, value: V): <R, E, T>(self: PSpec<R, E, T>) => PSpec<R, E, T>;
 /**
- * @tsplus fluent fncts.test.PSpec whenIO
+ * @tsplus pipeable fncts.test.PSpec whenIO
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function whenIO_<R, E, R1, E1>(self: PSpec<R, E, TestSuccess>, b: IO<R1, E1, boolean>): PSpec<R | R1 | Annotations, E | E1, TestSuccess>;
+export declare function whenIO<R1, E1>(b: IO<R1, E1, boolean>): <R, E>(self: PSpec<R, E, TestSuccess>) => PSpec<Annotations | R1 | R, E1 | E, TestSuccess>;
 /**
- * @tsplus fluent fncts.test.PSpec when
+ * @tsplus pipeable fncts.test.PSpec when
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function when_<R, E>(self: PSpec<R, E, TestSuccess>, b: Lazy<boolean>): PSpec<R | Annotations, E, TestSuccess>;
+export declare function when(b: Lazy<boolean>): <R, E>(self: PSpec<R, E, TestSuccess>) => PSpec<Annotations | R, E, TestSuccess>;

package/control/TestAnnotationRenderer/api.d.ts

@@ -1,10 +1,10 @@
 import type { TestAnnotationRenderer } from "./definition.js";
 /**
- * @tsplus fluent fncts.test.TestAnnotationRenderer combine
- * @tsplus operator fncts.test.TestAnnotationRenderer +
+ * @tsplus pipeable fncts.test.TestAnnotationRenderer combine
+ * @tsplus pipeable-operator fncts.test.TestAnnotationRenderer +
  * @tsplus location "@fncts/test/control/TestAnnotationRenderer/api"
  */
-export declare function combine_(self: TestAnnotationRenderer, that: TestAnnotationRenderer): TestAnnotationRenderer;
+export declare function combine(that: TestAnnotationRenderer): (self: TestAnnotationRenderer) => TestAnnotationRenderer;
 /**
  * @tsplus static fncts.test.TestAnnotationRendererOps Ignored
  * @tsplus location "@fncts/test/control/TestAnnotationRenderer/api"

package/control/TestConsole/definition.d.ts

@@ -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").IO<never, never, void>;
-    clearOutput: import("@fncts/io/IO").IO<never, never, void>;
+    clearInput: import("@fncts/io/IO").UIO<void>;
+    clearOutput: import("@fncts/io/IO").UIO<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>>;