@fncts/test 0.0.20 → 0.0.22

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

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";

package/control/TestRunner.d.ts

@@ -2,7 +2,6 @@ import { Layer } from "@fncts/io/Layer";
 import { URIO } from "@fncts/io/IO/definition";
 import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
 import { Clock } from "@fncts/io/Clock/definition";
-import type { RuntimeConfig } from "@fncts/io/RuntimeConfig";
 import type { Annotations } from "@fncts/test/control/Annotations";
 import type { TestReporter } from "@fncts/test/control/DefaultTestReporter/render";
 import type { Spec } from "@fncts/test/control/Spec";
@@ -11,9 +10,8 @@ import type { ExecutedSpec } from "@fncts/test/data/ExecutedSpec";
 import { TestLogger } from "@fncts/test/control/TestLogger";
 export declare class TestRunner<R, E> {
     readonly executor: TestExecutor<R>;
-    readonly runtimeConfig: RuntimeConfig;
     readonly reporter: TestReporter<E>;
     readonly bootstrap: Layer<never, never, TestLogger>;
-    constructor(executor: TestExecutor<R>, runtimeConfig?: RuntimeConfig, reporter?: TestReporter<E>, bootstrap?: Layer<never, never, TestLogger>);
+    constructor(executor: TestExecutor<R>, reporter?: TestReporter<E>, bootstrap?: Layer<never, never, TestLogger>);
     run(spec: Spec<R | Annotations, E>): URIO<TestLogger, ExecutedSpec<E>>;
 }

package/data/AssertionValue/api.d.ts

@@ -1,27 +1,27 @@
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { AssertionValue } from "./definition.js";
 /**
- * @tsplus fluent fncts.test.data.AssertionValue label
+ * @tsplus pipeable fncts.test.data.AssertionValue label
  * @tsplus location "@fncts/test/data/AssertionValue/api"
  */
-export declare function label<A>(self: AssertionValue<A>, string: string): AssertionValue<A>;
+export declare function label(string: string): <A>(self: AssertionValue<A>) => AssertionValue<A>;
 /**
- * @tsplus fluent fncts.test.data.AssertionValue isSameAssertionAs
+ * @tsplus pipeable fncts.test.data.AssertionValue isSameAssertionAs
  * @tsplus location "@fncts/test/data/AssertionValue/api"
  */
-export declare function isSameAssertionAs<A>(self: AssertionValue<A>, that: AssertionValue<A>): boolean;
+export declare function isSameAssertionAs<A>(that: AssertionValue<A>): (self: AssertionValue<A>) => boolean;
 /**
- * @tsplus fluent fncts.test.data.AssertionValue showValue
+ * @tsplus pipeable fncts.test.data.AssertionValue showValue
  * @tsplus location "@fncts/test/data/AssertionValue/api"
  */
-export declare function showValue<A>(self: AssertionValue<A>, offset?: number): string;
+export declare function showValue(offset?: number): <A>(self: AssertionValue<A>) => string;
 /**
  * @tsplus getter fncts.test.data.AssertionValue printAssertion
  * @tsplus location "@fncts/test/data/AssertionValue/api"
  */
 export declare function printAssertion<A>(self: AssertionValue<A>): string;
 /**
- * @tsplus fluent fncts.test.data.AssertionValue withContext
+ * @tsplus pipeable fncts.test.data.AssertionValue withContext
  * @tsplus location "@fncts/test/data/AssertionValue/api"
  */
-export declare function withContext<A>(self: AssertionValue<A>, expr: Maybe<string>, sourceLocation: Maybe<string>): AssertionValue<A>;
+export declare function withContext(expr: Maybe<string>, sourceLocation: Maybe<string>): <A>(self: AssertionValue<A>) => AssertionValue<A>;

package/data/ExecutedSpec/api.d.ts

@@ -6,20 +6,20 @@ import type { TestSuccess } from "../TestSuccess.js";
 import type { SpecCase } from "./definition.js";
 import { ExecutedSpec } from "./definition.js";
 /**
- * @tsplus fluent fncts.test.data.ExecutedSpec fold
+ * @tsplus pipeable fncts.test.data.ExecutedSpec fold
  * @tsplus location "@fncts/test/data/ExecutedSpec/api"
  */
-export declare function fold_<E, Z>(self: ExecutedSpec<E>, f: (_: SpecCase<E, Z>) => Z): Z;
+export declare function fold<E, Z>(f: (_: SpecCase<E, Z>) => Z): (self: ExecutedSpec<E>) => Z;
 /**
  * @tsplus static fncts.test.data.ExecutedSpecOps labeled
  * @tsplus location "@fncts/test/data/ExecutedSpec/api"
  */
 export declare function labeled<E>(spec: ExecutedSpec<E>, label: string): ExecutedSpec<E>;
 /**
- * @tsplus fluent fncts.test.data.ExecutedSpecCase map
+ * @tsplus pipeable fncts.test.data.ExecutedSpecCase map
  * @tsplus location "@fncts/test/data/ExecutedSpec/api"
  */
-export declare function mapSpecCase_<E, A, B>(self: SpecCase<E, A>, f: (a: A) => B): SpecCase<E, B>;
+export declare function mapSpecCase<A, B>(f: (a: A) => B): <E>(self: SpecCase<E, A>) => SpecCase<E, B>;
 /**
  * @tsplus static fncts.test.data.ExecutedSpecOps multiple
  * @tsplus location "@fncts/test/data/ExecutedSpec/api"
@@ -31,15 +31,15 @@ export declare function multiple<E>(specs: Conc<ExecutedSpec<E>>): ExecutedSpec<
  */
 export declare function test<E>(test: Either<TestFailure<E>, TestSuccess>, annotations: TestAnnotationMap): ExecutedSpec<E>;
 /**
- * @tsplus fluent fncts.test.data.ExecutedSpec transform
+ * @tsplus pipeable fncts.test.data.ExecutedSpec transform
  * @tsplus location "@fncts/test/data/ExecutedSpec/api"
  */
-export declare function transform_<E, E1>(self: ExecutedSpec<E>, f: (_: SpecCase<E, ExecutedSpec<E1>>) => SpecCase<E1, ExecutedSpec<E1>>): ExecutedSpec<E1>;
+export declare function transform<E, E1>(f: (_: SpecCase<E, ExecutedSpec<E1>>) => SpecCase<E1, ExecutedSpec<E1>>): (self: ExecutedSpec<E>) => ExecutedSpec<E1>;
 /**
- * @tsplus fluent fncts.test.data.ExecutedSpec exists
+ * @tsplus pipeable fncts.test.data.ExecutedSpec some
  * @tsplus location "@fncts/test/data/ExecutedSpec/api"
  */
-export declare function exists_<E>(self: ExecutedSpec<E>, f: (_: SpecCase<E, boolean>) => boolean): boolean;
+export declare function some<E>(f: (_: SpecCase<E, boolean>) => boolean): (self: ExecutedSpec<E>) => boolean;
 /**
  * @tsplus getter fncts.test.data.ExecutedSpec size
  * @tsplus location "@fncts/test/data/ExecutedSpec/api"

package/data/ExecutionResult.d.ts

@@ -42,15 +42,15 @@ export declare class ExecutionResult {
 }
 export declare function rendered(caseType: ResultType, label: string, status: Status, offset: number, lines: List<Line>): ExecutionResult;
 /**
- * @tsplus operator fncts.test.ExecutionResult &&
+ * @tsplus pipeable-operator fncts.test.ExecutionResult &&
  * @tsplus location "@fncts/test/data/ExecutionResult"
  */
-export declare function and_(self: ExecutionResult, that: ExecutionResult): ExecutionResult;
+export declare function and(that: ExecutionResult): (self: ExecutionResult) => ExecutionResult;
 /**
- * @tsplus operator fncts.test.ExecutionResult ||
+ * @tsplus pipeable-operator fncts.test.ExecutionResult ||
  * @tsplus location "@fncts/test/data/ExecutionResult"
  */
-export declare function or_(self: ExecutionResult, that: ExecutionResult): ExecutionResult;
+export declare function or(that: ExecutionResult): (self: ExecutionResult) => ExecutionResult;
 /**
  * @tsplus getter fncts.test.ExecutionResult invert
  * @tsplus location "@fncts/test/data/ExecutionResult"

package/data/FreeBooleanAlgebra/api.d.ts

@@ -3,21 +3,21 @@ import { Either } from "@fncts/base/data/Either/definition";
 import { Eval } from "@fncts/base/control/Eval/definition";
 import { FreeBooleanAlgebra } 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 &&
  * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
  */
-export declare function and_<A>(left: FreeBooleanAlgebra<A>, right: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A>;
+export declare function and<A>(right: FreeBooleanAlgebra<A>): (left: FreeBooleanAlgebra<A>) => FreeBooleanAlgebra<A>;
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebra flatMap
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebra flatMap
  * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
  */
-export declare function flatMap_<A, B>(self: FreeBooleanAlgebra<A>, f: (a: A) => FreeBooleanAlgebra<B>): FreeBooleanAlgebra<B>;
+export declare function flatMap<A, B>(f: (a: A) => FreeBooleanAlgebra<B>): (self: FreeBooleanAlgebra<A>) => FreeBooleanAlgebra<B>;
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebra map
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebra map
  * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
  */
-export declare function map_<A, B>(self: FreeBooleanAlgebra<A>, f: (a: A) => B): FreeBooleanAlgebra<B>;
+export declare function map<A, B>(f: (a: A) => B): (self: FreeBooleanAlgebra<A>) => FreeBooleanAlgebra<B>;
 /**
  * @tsplus static fncts.test.FreeBooleanAlgebraOps failure
  * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
@@ -29,35 +29,35 @@ export declare function failure<A>(a: A): FreeBooleanAlgebra<A>;
  */
 export declare function failures<A>(self: FreeBooleanAlgebra<A>): Maybe<FreeBooleanAlgebra<A>>;
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebra foldEval
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebra foldEval
  * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
  */
-export declare function foldEval_<A, B>(self: FreeBooleanAlgebra<A>, cases: {
+export declare 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;
-}): Eval<B>;
+}): (self: FreeBooleanAlgebra<A>) => Eval<B>;
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebra fold
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebra fold
  * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
  */
-export declare function fold_<A, B>(self: FreeBooleanAlgebra<A>, cases: {
+export declare 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;
-}): B;
+}): (self: FreeBooleanAlgebra<A>) => B;
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebra iff
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebra iff
  * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
  */
-export declare function iff_<A>(left: FreeBooleanAlgebra<A>, right: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A>;
+export declare function iff<A>(right: FreeBooleanAlgebra<A>): (left: FreeBooleanAlgebra<A>) => FreeBooleanAlgebra<A>;
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebra implies
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebra implies
  * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
  */
-export declare function implies_<A>(left: FreeBooleanAlgebra<A>, right: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A>;
+export declare function implies<A>(right: FreeBooleanAlgebra<A>): (left: FreeBooleanAlgebra<A>) => FreeBooleanAlgebra<A>;
 /**
  * @tsplus getter fncts.test.FreeBooleanAlgebra isFailure
  * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
@@ -74,11 +74,11 @@ export declare function isSuccess<A>(self: FreeBooleanAlgebra<A>): boolean;
  */
 export declare 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 ||
  * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
  */
-export declare function or_<A>(left: FreeBooleanAlgebra<A>, right: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A>;
+export declare function or<A>(right: FreeBooleanAlgebra<A>): (left: FreeBooleanAlgebra<A>) => FreeBooleanAlgebra<A>;
 /**
  * @tsplus static fncts.test.FreeBooleanAlgebraOps success
  * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"

package/data/LogLine/Line.d.ts

@@ -46,10 +46,10 @@ export declare function appendTo(message: Message, self: Line): Message;
  */
 export declare function prependTo(self: Line, message: Message): Message;
 /**
- * @tsplus fluent fncts.test.data.Line withOffset
+ * @tsplus pipeable fncts.test.data.Line withOffset
  * @tsplus location "@fncts/test/data/LogLine/Line"
  */
-export declare function withOffset(self: Line, shift: number): Line;
+export declare function withOffset(shift: number): (self: Line) => Line;
 /**
  * @tsplus getter fncts.test.data.Line toMessage
  * @tsplus location "@fncts/test/data/LogLine/Line"

package/data/LogLine/Message.d.ts

@@ -33,29 +33,29 @@ export declare function prependFragment(fragment: Fragment, self: Message): Mess
  * @tsplus operator fncts.test.data.Message +
  * @tsplus location "@fncts/test/data/LogLine/Message"
  */
-export declare function concat_(self: Message, that: Message): Message;
+export declare function concat(self: Message, that: Message): Message;
 /**
  * @tsplus operator fncts.test.data.Message |
  * @tsplus location "@fncts/test/data/LogLine/Message"
  */
-export declare function combine_(self: Message, that: Message): Message;
+export declare function combine(self: Message, that: Message): Message;
 /**
- * @tsplus fluent fncts.test.data.Message drop
+ * @tsplus pipeable fncts.test.data.Message drop
  * @tsplus location "@fncts/test/data/LogLine/Message"
  */
-export declare function drop_(self: Message, n: number): Message;
+export declare function drop(n: number): (self: Message) => Message;
 /**
- * @tsplus fluent fncts.test.data.Message map
+ * @tsplus pipeable fncts.test.data.Message map
  * @tsplus location "@fncts/test/data/LogLine/Message"
  */
-export declare function map_(self: Message, f: (line: Line) => Line): Message;
+export declare function map(f: (line: Line) => Line): (self: Message) => Message;
 /**
- * @tsplus fluent fncts.test.data.Message withOffset
+ * @tsplus pipeable fncts.test.data.Message withOffset
  * @tsplus location "@fncts/test/data/LogLine/Message"
  */
-export declare function withOffset(self: Message, offset: number): Message;
+export declare function withOffset(offset: number): (self: Message) => Message;
 /**
- * @tsplus fluent fncts.test.data.Message intersperse
+ * @tsplus pipeable fncts.test.data.Message intersperse
  * @tsplus location "@fncts/test/data/LogLine/Message"
  */
-export declare function intersperse(self: Message, line: Line): Message;
+export declare function intersperse(line: Line): (self: Message) => Message;

package/data/TestAnnotation/api.d.ts

@@ -1,7 +1,7 @@
 import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 import { Fiber } from "@fncts/io/Fiber/definition";
 import { TestAnnotation } from "./definition.js";
 export declare const IgnoredTag: import("@fncts/base/data/Tag.js").Tag<number>;

package/data/TestAnnotation/definition.d.ts

@@ -1,5 +1,5 @@
-import { Hashable } from "@fncts/base/typeclass/Hashable";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
 import { Tag } from "@fncts/base/data/Tag/definition";
 export declare const TestAnnotationTypeId: unique symbol;
 export type TestAnnotationTypeId = typeof TestAnnotationTypeId;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@fncts/test",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "dependencies": {
-    "@fncts/base": "0.0.20",
-    "@fncts/io": "0.0.20",
-    "@fncts/typelevel": "0.0.14"
+    "@fncts/base": "0.0.22",
+    "@fncts/io": "0.0.22",
+    "@fncts/typelevel": "0.0.15"
   },
   "exports": {
     "./*": {

package/_cjs/control/Gen/api/array.cjs

@@ -1,50 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.array = array;
-exports.arrayN_ = void 0;
-exports.uniqueArray_ = uniqueArray_;
-
-var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/test/control/Gen/api"));
-
-var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Conc/definition"));
-
-var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/test/control/Gen/api/conc"));
-
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-const arrayN_ = arrayN_1;
-/**
- * @tsplus fluent fncts.test.Gen array
- */
-
-exports.arrayN_ = arrayN_;
-
-function array(g, constraints = {}) {
-  const minLength = constraints.minLength || 0;
-  return constraints.maxLength ? tsplus_module_1.flatMap_(tsplus_module_1.int({
-    min: minLength,
-    max: constraints.maxLength
-  }), n => arrayN_1(g, n)) : tsplus_module_1.small(n => arrayN_1(g, n), minLength);
-}
-/**
- * @tsplus fluent fncts.test.Gen arrayN
- */
-
-
-function arrayN_1(self, n) {
-  return tsplus_module_1.map_(tsplus_module_3.concN_(self, n), conc => tsplus_module_2.toArray(conc));
-}
-/**
- * @tsplus fluent fncts.test.Gen uniqueArray
- */
-
-
-function uniqueArray_(gen, constraints = {}) {
-  return tsplus_module_1.map_(tsplus_module_3.uniqueConc_(gen, constraints), conc => tsplus_module_2.toArray(conc));
-}
-//# sourceMappingURL=array.cjs.map

package/_cjs/control/Gen/api/array.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.cjs","mappings":";;;;;;;;;;;;;;;;;;;MAkBgBA,OAAO;AAbvB;;;;;;AAGM,SAAUC,KAAV,CAAsBC,CAAtB,EAAoCC,cAAiC,EAArE,EAAuE;EAC3E,MAAMC,SAAS,GAAGD,WAAW,CAACC,SAAZ,IAAyB,CAA3C;EACA,OAAOD,WAAW,CAACE,SAAZ,GACHC,6CAAQ;IAAEC,GAAG,EAAEH,SAAP;IAAkBI,GAAG,EAAEL,WAAW,CAACE;EAAnC,CAAR,GAAiEI,CAAD,IAAOC,YAASD,CAAT,CAAvE,CADG,GAEHH,sBAAWG,CAAD,IAAOC,YAASD,CAAT,CAAjB,EAA8BL,SAA9B,CAFJ;AAGD;AAED;;;;;AAGA,kBAA8BO,IAA9B,EAA+CF,CAA/C,EAAwD;EACtD,OAAOH,kDAAWG,CAAX,GAAmBG,IAAD,IAASC,wBAACD,IAAD,CAA3B,CAAP;AACD;AAED;;;;;AAGM,SAAUE,YAAV,CACJC,GADI,EAEJZ,cAAmD,EAF/C,EAEiD;EAErD,OAAOG,sDAAeH,WAAf,GAAiCS,IAAD,IAASC,wBAACD,IAAD,CAAzC,CAAP;AACD","names":["arrayN_","array","g","constraints","minLength","maxLength","tsplus_module_1","min","max","n","arrayN_1","self","conc","tsplus_module_2","uniqueArray_","gen"],"sourceRoot":"","sources":["../../../../_src/control/Gen/api/array.ts"],"sourcesContent":[null]}