@fncts/test 0.0.19 → 0.0.21

package/_src/control/Spec/api.ts

@@ -30,60 +30,60 @@ export function annotated<R, E, T>(spec: PSpec<R, E, T>): PSpec<R | Annotations,
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec combine
+ * @tsplus pipeable fncts.test.PSpec combine
  */
-export 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> {
-  if (self.caseValue.isMultiple() && that.caseValue.isMultiple()) {
-    return MultipleCase<R | R1, E | E1, T | T1>(self.caseValue.specs.concat(that.caseValue.specs));
-  }
-  if (self.caseValue.isMultiple()) {
-    return MultipleCase<R | R1, E | E1, T | T1>(self.caseValue.specs.append(that));
-  }
-  if (that.caseValue.isMultiple()) {
-    return MultipleCase<R | R1, E | E1, T | T1>(that.caseValue.specs.prepend(self));
-  }
-  return MultipleCase(Conc<PSpec<R | R1, E | E1, T | T1>>(self, that));
+export function combine<R1, E1, T1>(that: PSpec<R1, E1, T1>) {
+  return <R, E, T>(self: PSpec<R, E, T>): PSpec<R | R1, E | E1, T | T1> => {
+    if (self.caseValue.isMultiple() && that.caseValue.isMultiple()) {
+      return MultipleCase<R | R1, E | E1, T | T1>(self.caseValue.specs.concat(that.caseValue.specs));
+    }
+    if (self.caseValue.isMultiple()) {
+      return MultipleCase<R | R1, E | E1, T | T1>(self.caseValue.specs.append(that));
+    }
+    if (that.caseValue.isMultiple()) {
+      return MultipleCase<R | R1, E | E1, T | T1>(that.caseValue.specs.prepend(self));
+    }
+    return MultipleCase(Conc<PSpec<R | R1, E | E1, T | T1>>(self, that));
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec contramapEnvironment
+ * @tsplus pipeable fncts.test.PSpec contramapEnvironment
  */
-export function contramapEnvironment_<R, E, T, R0>(
-  self: PSpec<R, E, T>,
-  f: (r0: Environment<R0>) => Environment<R>,
-): PSpec<R0, E, T> {
-  return self.transform(
-    matchTag(
-      {
-        Scoped: ({ scoped }) =>
-          new ScopedCase(
-            scoped.contramapEnvironment((r: Environment<R0 | Scope>) =>
-              Environment.empty.add(r.get(Scope.Tag), Scope.Tag).union(f(r as Environment<R0>)),
+export function contramapEnvironment<R, R0>(f: (r0: Environment<R0>) => Environment<R>) {
+  return <E, T>(self: PSpec<R, E, T>): PSpec<R0, E, T> => {
+    return self.transform(
+      matchTag(
+        {
+          Scoped: ({ scoped }) =>
+            new ScopedCase(
+              scoped.contramapEnvironment((r: Environment<R0 | Scope>) =>
+                Environment.empty.add(r.get(Scope.Tag), Scope.Tag).union(f(r as Environment<R0>)),
+              ),
             ),
-          ),
-        Test: ({ test, annotations }) => new TestCase(test.contramapEnvironment(f), annotations),
-      },
-      identity,
-    ),
-  );
+          Test: ({ test, annotations }) => new TestCase(test.contramapEnvironment(f), annotations),
+        },
+        identity,
+      ),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec countTests
+ * @tsplus pipeable fncts.test.PSpec countTests
  */
-export function countTests_<R, E, T>(spec: PSpec<R, E, T>, f: (t: T) => boolean): IO<R | Scope, E, number> {
-  return spec.fold(
-    matchTag({
-      Exec: ({ spec }) => spec,
-      Labeled: ({ spec }) => spec,
-      Scoped: ({ scoped }) => scoped.flatten,
-      Multiple: ({ specs }) => IO.sequenceIterable(specs).map((specs) => specs.foldLeft(0, (b, a) => b + a)),
-      Test: ({ test }) => test.map((t) => (f(t) ? 1 : 0)),
-    }),
-  );
+export function countTests<T>(f: (t: T) => boolean) {
+  return <R, E>(spec: PSpec<R, E, T>): IO<R | Scope, E, number> => {
+    return spec.fold(
+      matchTag({
+        Exec: ({ spec }) => spec,
+        Labeled: ({ spec }) => spec,
+        Scoped: ({ scoped }) => scoped.flatten,
+        Multiple: ({ specs }) => IO.sequenceIterable(specs).map((specs) => specs.foldLeft(0, (b, a) => b + a)),
+        Test: ({ test }) => test.map((t) => (f(t) ? 1 : 0)),
+      }),
+    );
+  };
 }
 
 /**
@@ -100,138 +100,145 @@ export function exec<R, E, T>(spec: PSpec<R, E, T>, exec: ExecutionStrategy): PS
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec execute
+ * @tsplus pipeable fncts.test.PSpec execute
  */
-export function execute<R, E, T>(
-  self: PSpec<R, E, T>,
-  defExec: ExecutionStrategy,
-): IO<R | Scope, never, PSpec<never, E, T>> {
-  return IO.environmentWithIO((r: Environment<R | Scope>) =>
-    self.provideEnvironment(r).foreachExec(IO.failCauseNow, IO.succeedNow, defExec),
-  );
+export function execute(defExec: ExecutionStrategy) {
+  return <R, E, T>(self: PSpec<R, E, T>): IO<R | Scope, never, PSpec<never, E, T>> => {
+    return IO.environmentWithIO((r: Environment<R | Scope>) =>
+      self.provideEnvironment(r).foreachExec(IO.failCauseNow, IO.succeedNow, defExec),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec filterAnnotations
+ * @tsplus pipeable fncts.test.PSpec filterAnnotations
  */
-export function filterAnnotations_<R, E, T, V>(
-  spec: PSpec<R, E, T>,
-  key: TestAnnotation<V>,
-  f: (v: V) => boolean,
-): Maybe<PSpec<R, E, T>> {
-  return matchTag_(spec.caseValue, {
-    Exec: ({ spec, exec }) => spec.filterAnnotations(key, f).map((spec) => ExecCase(spec, exec)),
-    Labeled: ({ label, spec }) => spec.filterAnnotations(key, f).map((spec) => LabeledCase(spec, label)),
-    Scoped: ({ scoped }) =>
-      Just(ScopedCase(scoped.map((spec) => spec.filterAnnotations(key, f).getOrElse(Spec.empty)))),
-    Multiple: ({ specs }) => {
-      const filtered = specs.filterMap((spec) => spec.filterAnnotations(key, f));
-      return filtered.isEmpty ? Nothing() : Just(MultipleCase(filtered));
-    },
-    Test: ({ test, annotations }) => (f(annotations.get(key)) ? Just(TestCase(test, annotations)) : Nothing()),
-  });
+export function filterAnnotations<V>(key: TestAnnotation<V>, f: (v: V) => boolean) {
+  return <R, E, T>(spec: PSpec<R, E, T>): Maybe<PSpec<R, E, T>> => {
+    return matchTag_(spec.caseValue, {
+      Exec: ({ spec, exec }) => spec.filterAnnotations(key, f).map((spec) => ExecCase(spec, exec)),
+      Labeled: ({ label, spec }) => spec.filterAnnotations(key, f).map((spec) => LabeledCase(spec, label)),
+      Scoped: ({ scoped }) =>
+        Just(ScopedCase(scoped.map((spec) => spec.filterAnnotations(key, f).getOrElse(Spec.empty)))),
+      Multiple: ({ specs }) => {
+        const filtered = specs.filterMap((spec) => spec.filterAnnotations(key, f));
+        return filtered.isEmpty ? Nothing() : Just(MultipleCase(filtered));
+      },
+      Test: ({ test, annotations }) => (f(annotations.get(key)) ? Just(TestCase(test, annotations)) : Nothing()),
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec filterLabels
+ * @tsplus pipeable fncts.test.PSpec filterLabels
  */
-export function filterLabels_<R, E, T>(spec: PSpec<R, E, T>, f: (label: string) => boolean): Maybe<PSpec<R, E, T>> {
-  return matchTag_(spec.caseValue, {
-    Exec: ({ spec, exec }) => spec.filterLabels(f).map((spec) => ExecCase(spec, exec)),
-    Labeled: ({ label, spec }) =>
-      f(label) ? Just(LabeledCase(spec, label)) : spec.filterLabels(f).map((spec) => LabeledCase(spec, label)),
-    Scoped: ({ scoped }) => Just(ScopedCase(scoped.map((spec) => spec.filterLabels(f).getOrElse(Spec.empty)))),
-    Multiple: ({ specs }) => {
-      const filtered = specs.filterMap((spec) => spec.filterLabels(f));
-      return filtered.isEmpty ? Nothing() : Just(MultipleCase(filtered));
-    },
-    Test: () => Nothing(),
-  });
+export function filterLabels(f: (label: string) => boolean) {
+  return <R, E, T>(spec: PSpec<R, E, T>): Maybe<PSpec<R, E, T>> => {
+    return matchTag_(spec.caseValue, {
+      Exec: ({ spec, exec }) => spec.filterLabels(f).map((spec) => ExecCase(spec, exec)),
+      Labeled: ({ label, spec }) =>
+        f(label) ? Just(LabeledCase(spec, label)) : spec.filterLabels(f).map((spec) => LabeledCase(spec, label)),
+      Scoped: ({ scoped }) => Just(ScopedCase(scoped.map((spec) => spec.filterLabels(f).getOrElse(Spec.empty)))),
+      Multiple: ({ specs }) => {
+        const filtered = specs.filterMap((spec) => spec.filterLabels(f));
+        return filtered.isEmpty ? Nothing() : Just(MultipleCase(filtered));
+      },
+      Test: () => Nothing(),
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec filterTags
+ * @tsplus pipeable fncts.test.PSpec filterTags
  */
-export function filterTags_<R, E, T>(spec: PSpec<R, E, T>, f: (tag: string) => boolean): Maybe<PSpec<R, E, T>> {
-  return spec.filterAnnotations(TestAnnotation.Tagged, (v) => v.exists(f));
+export function filterTags(f: (tag: string) => boolean) {
+  return <R, E, T>(spec: PSpec<R, E, T>): Maybe<PSpec<R, E, T>> => {
+    return spec.filterAnnotations(TestAnnotation.Tagged, (v) => v.exists(f));
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec filterByArgs
+ * @tsplus pipeable fncts.test.PSpec filterByArgs
  */
-export function filterByArgs<R, E>(spec: Spec<R, E>, args: TestArgs): Spec<R, E> {
-  return spec
-    .filterTags(args.tagSearchTerms.elem(String.Eq))
-    .flatMap((spec) =>
-      spec.filterLabels((label) => args.testSearchTerms.findIndex((term) => term.includes(label)) === -1),
-    )
-    .getOrElse(() => spec);
+export function filterByArgs(args: TestArgs) {
+  return <R, E>(spec: Spec<R, E>): Spec<R, E> => {
+    return spec
+      .filterTags(args.tagSearchTerms.elem(String.Eq))
+      .flatMap((spec) =>
+        spec.filterLabels((label) => args.testSearchTerms.findIndex((term) => term.includes(label)) === -1),
+      )
+      .getOrElse(() => spec);
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec fold
+ * @tsplus pipeable fncts.test.PSpec fold
  */
-export function fold_<R, E, T, Z>(spec: PSpec<R, E, T>, f: (_: SpecCase<R, E, T, Z>) => Z): Z {
-  return matchTag_(spec.caseValue, {
-    Exec: ({ exec, spec }) => f(new ExecCase(exec, spec.fold(f))),
-    Labeled: ({ label, spec }) => f(new LabeledCase(label, spec.fold(f))),
-    Scoped: ({ scoped }) => f(new ScopedCase(scoped.map((spec) => spec.fold(f)))),
-    Multiple: ({ specs }) => f(new MultipleCase(specs.map((spec) => spec.fold(f)))),
-    Test: (t) => f(t),
-  });
+export function fold<R, E, T, Z>(f: (_: SpecCase<R, E, T, Z>) => Z) {
+  return (spec: PSpec<R, E, T>): Z => {
+    return matchTag_(spec.caseValue, {
+      Exec: ({ exec, spec }) => f(new ExecCase(exec, spec.fold(f))),
+      Labeled: ({ label, spec }) => f(new LabeledCase(label, spec.fold(f))),
+      Scoped: ({ scoped }) => f(new ScopedCase(scoped.map((spec) => spec.fold(f)))),
+      Multiple: ({ specs }) => f(new MultipleCase(specs.map((spec) => spec.fold(f)))),
+      Test: (t) => f(t),
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec foldScoped
+ * @tsplus pipeable fncts.test.PSpec foldScoped
  */
-export function foldScoped_<R, E, T, R1, E1, Z>(
-  spec: PSpec<R, E, T>,
+export function foldScoped<R, E, T, R1, E1, Z>(
   f: (_: SpecCase<R, E, T, Z>) => IO<R1 | Scope, E1, Z>,
   defExec: ExecutionStrategy,
-): IO<R | R1 | Scope, E1, Z> {
-  return matchTag_(spec.caseValue, {
-    Exec: ({ exec, spec }) => spec.foldScoped(f, exec).flatMap((z) => f(new ExecCase(exec, z))),
-    Labeled: ({ label, spec }) => spec.foldScoped(f, defExec).flatMap((z) => f(new LabeledCase(label, z))),
-    Scoped: ({ scoped }) =>
-      scoped.matchCauseIO(
-        (cause) => f(new ScopedCase(IO.haltNow(cause))),
-        (spec) => spec.foldScoped(f, defExec).flatMap((z) => f(new ScopedCase(IO.succeedNow(z)))),
-      ),
-    Multiple: ({ specs }) =>
-      IO.foreachExec(specs, defExec, (spec) => spec.foldScoped(f, defExec).scoped).flatMap((zs) =>
-        f(new MultipleCase(zs)),
-      ),
-    Test: f,
-  });
+) {
+  return (spec: PSpec<R, E, T>): IO<R | R1 | Scope, E1, Z> => {
+    return matchTag_(spec.caseValue, {
+      Exec: ({ exec, spec }) => spec.foldScoped(f, exec).flatMap((z) => f(new ExecCase(exec, z))),
+      Labeled: ({ label, spec }) => spec.foldScoped(f, defExec).flatMap((z) => f(new LabeledCase(label, z))),
+      Scoped: ({ scoped }) =>
+        scoped.matchCauseIO(
+          (cause) => f(new ScopedCase(IO.haltNow(cause))),
+          (spec) => spec.foldScoped(f, defExec).flatMap((z) => f(new ScopedCase(IO.succeedNow(z)))),
+        ),
+      Multiple: ({ specs }) =>
+        IO.foreachExec(specs, defExec, (spec) => spec.foldScoped(f, defExec).scoped).flatMap((zs) =>
+          f(new MultipleCase(zs)),
+        ),
+      Test: f,
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec foreachExec
+ * @tsplus pipeable fncts.test.PSpec foreachExec
  */
-export function foreachExec_<R, E, T, R1, E1, A, R2, E2, B>(
-  spec: PSpec<R, E, T>,
+export 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,
-): IO<R | R1 | R2 | Scope, never, PSpec<R | R1 | R2, E1 | E2, A | B>> {
-  return spec.foldScoped(
-    matchTag({
-      Exec: ({ exec, spec }) => IO.succeedNow(ExecCase(spec, exec)),
-      Labeled: ({ label, spec }) => IO.succeedNow(LabeledCase(spec, label)),
-      Scoped: ({ scoped }) =>
-        scoped.matchCause(
-          (cause) => TestCase(failure(cause), TestAnnotationMap.empty),
-          (t) => ScopedCase(IO.succeedNow(t)),
-        ),
-      Multiple: ({ specs }) => IO.succeedNow(MultipleCase(specs)),
-      Test: ({ test, annotations }) =>
-        test.matchCause(
-          (cause) => TestCase(failure(cause), annotations),
-          (t) => TestCase(success(t), annotations),
-        ),
-    }),
-    defExec,
-  );
+) {
+  return <R>(spec: PSpec<R, E, T>): IO<R | R1 | R2 | Scope, never, PSpec<R | R1 | R2, E1 | E2, A | B>> => {
+    return spec.foldScoped(
+      matchTag({
+        Exec: ({ exec, spec }) => IO.succeedNow(ExecCase(spec, exec)),
+        Labeled: ({ label, spec }) => IO.succeedNow(LabeledCase(spec, label)),
+        Scoped: ({ scoped }) =>
+          scoped.matchCause(
+            (cause) => TestCase(failure(cause), TestAnnotationMap.empty),
+            (t) => ScopedCase(IO.succeedNow(t)),
+          ),
+        Multiple: ({ specs }) => IO.succeedNow(MultipleCase(specs)),
+        Test: ({ test, annotations }) =>
+          test.matchCause(
+            (cause) => TestCase(failure(cause), annotations),
+            (t) => TestCase(success(t), annotations),
+          ),
+      }),
+      defExec,
+    );
+  };
 }
 
 /**
@@ -244,7 +251,6 @@ export function labeledCase<R, E, T>(spec: PSpec<R, E, T>, label: string): PSpec
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec scoped
  * @tsplus static fncts.test.PSpecOps scoped
  * @tsplus static fncts.test.PSpec.ScopedCaseOps __call
  */
@@ -253,35 +259,38 @@ export function scoped<R, E, T>(managed: IO<R | Scope, E, PSpec<R, E, T>>): PSpe
 }
 
 /**
- * @tsplus fluent fncts.test.SpecCase mapError
+ * @tsplus pipeable fncts.test.SpecCase mapError
  */
-export function mapError<R, E, T, E1>(self: PSpec<R, E, T>, f: (e: E) => E1): PSpec<R, E1, T> {
-  return self.transform(
-    matchTag(
-      {
-        Scoped: ({ scoped }) => new ScopedCase(scoped.mapError(f)),
-        Test: ({ test, annotations }) => new TestCase(test.mapError(f), annotations),
-      },
-      identity,
-    ),
-  );
+export function mapError<E, E1>(f: (e: E) => E1) {
+  return <R, T>(self: PSpec<R, E, T>): PSpec<R, E1, T> => {
+    return self.transform(
+      matchTag(
+        {
+          Scoped: ({ scoped }) => new ScopedCase(scoped.mapError(f)),
+          Test: ({ test, annotations }) => new TestCase(test.mapError(f), annotations),
+        },
+        identity,
+      ),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.SpecCase map
+ * @tsplus pipeable fncts.test.SpecCase map
  */
-export function mapSpecCase_<R, E, T, A, B>(fa: SpecCase<R, E, T, A>, f: (a: A) => B): SpecCase<R, E, T, B> {
-  return matchTag_(fa, {
-    Exec: ({ exec, spec }) => new ExecCase(exec, f(spec)),
-    Labeled: ({ label, spec }) => new LabeledCase(label, f(spec)),
-    Scoped: ({ scoped }) => new ScopedCase(scoped.map(f)),
-    Multiple: ({ specs }) => new MultipleCase(specs.map(f)),
-    Test: ({ test, annotations }) => new TestCase(test, annotations),
-  });
+export function mapSpecCase<A, B>(f: (a: A) => B) {
+  return <R, E, T>(fa: SpecCase<R, E, T, A>): SpecCase<R, E, T, B> => {
+    return matchTag_(fa, {
+      Exec: ({ exec, spec }) => new ExecCase(exec, f(spec)),
+      Labeled: ({ label, spec }) => new LabeledCase(label, f(spec)),
+      Scoped: ({ scoped }) => new ScopedCase(scoped.map(f)),
+      Multiple: ({ specs }) => new MultipleCase(specs.map(f)),
+      Test: ({ test, annotations }) => new TestCase(test, annotations),
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec multiple
  * @tsplus static fncts.test.PSpecOps multiple
  * @tsplus static fncts.test.PSpec.MultipleCaseOps __call
  */
@@ -290,32 +299,32 @@ export function multipleCase<R, E, T>(specs: Conc<PSpec<R, E, T>>): PSpec<R, E,
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec provideEnvironment
+ * @tsplus pipeable fncts.test.PSpec provideEnvironment
  */
-export function provideEnvironment_<R, E, T>(self: PSpec<R, E, T>, r: Environment<R>): PSpec<never, E, T> {
-  return self.contramapEnvironment(() => r);
+export function provideEnvironment<R>(r: Environment<R>) {
+  return <E, T>(self: PSpec<R, E, T>): PSpec<never, E, T> => {
+    return self.contramapEnvironment(() => r);
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec provideLayer
+ * @tsplus pipeable fncts.test.PSpec provideLayer
  */
-export function provideLayer_<RIn, E, ROut, E1, T>(
-  self: PSpec<ROut, E1, T>,
-  layer: Layer<RIn, E, ROut>,
-): PSpec<RIn, E | E1, T> {
-  return self.transform(
-    matchTag(
-      {
-        Scoped: ({ scoped }) => new ScopedCase(scoped.provideLayer(Layer.environment<Scope>().and(layer))),
-        Test: ({ test, annotations }) => new TestCase(test.provideLayer(layer), annotations),
-      },
-      identity,
-    ),
-  );
+export function provideLayer<RIn, E, ROut>(layer: Layer<RIn, E, ROut>) {
+  return <E1, T>(self: PSpec<ROut, E1, T>): PSpec<RIn, E | E1, T> => {
+    return self.transform(
+      matchTag(
+        {
+          Scoped: ({ scoped }) => new ScopedCase(scoped.provideLayer(Layer.environment<Scope>().and(layer))),
+          Test: ({ test, annotations }) => new TestCase(test.provideLayer(layer), annotations),
+        },
+        identity,
+      ),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec test
  * @tsplus static fncts.test.PSpecOps test
  * @tsplus static fncts.test.PSpec.TestCaseOps __call
  */
@@ -324,58 +333,62 @@ export function testCase<R, E, T>(test: IO<R, E, T>, annotations: TestAnnotation
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec transform
+ * @tsplus pipeable fncts.test.PSpec transform
  */
-export function transform_<R, E, T, R1, E1, T1>(
-  spec: PSpec<R, E, T>,
+export 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>>,
-): PSpec<R1, E1, T1> {
-  return matchTag_(spec.caseValue, {
-    Exec: ({ exec, spec }) => new PSpec(f(new ExecCase(exec, spec.transform(f)))),
-    Labeled: ({ label, spec }) => new PSpec(f(new LabeledCase(label, spec.transform(f)))),
-    Scoped: ({ scoped }) => new PSpec(f(new ScopedCase(scoped.map((spec) => spec.transform(f))))),
-    Multiple: ({ specs }) => new PSpec(f(new MultipleCase(specs.map((spec) => spec.transform(f))))),
-    Test: (t) => new PSpec(f(t)),
-  });
+) {
+  return (spec: PSpec<R, E, T>): PSpec<R1, E1, T1> => {
+    return matchTag_(spec.caseValue, {
+      Exec: ({ exec, spec }) => new PSpec(f(new ExecCase(exec, spec.transform(f)))),
+      Labeled: ({ label, spec }) => new PSpec(f(new LabeledCase(label, spec.transform(f)))),
+      Scoped: ({ scoped }) => new PSpec(f(new ScopedCase(scoped.map((spec) => spec.transform(f))))),
+      Multiple: ({ specs }) => new PSpec(f(new MultipleCase(specs.map((spec) => spec.transform(f))))),
+      Test: (t) => new PSpec(f(t)),
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec annotate
+ * @tsplus pipeable fncts.test.PSpec annotate
  */
-export function annotate_<R, E, T, V>(self: PSpec<R, E, T>, key: TestAnnotation<V>, value: V): PSpec<R, E, T> {
-  return self.transform(
-    matchTag(
-      {
-        Test: ({ test, annotations }) => new TestCase(test, annotations.annotate(key, value)),
-      },
-      identity,
-    ),
-  );
+export function annotate<V>(key: TestAnnotation<V>, value: V) {
+  return <R, E, T>(self: PSpec<R, E, T>): PSpec<R, E, T> => {
+    return self.transform(
+      matchTag(
+        {
+          Test: ({ test, annotations }) => new TestCase(test, annotations.annotate(key, value)),
+        },
+        identity,
+      ),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec whenIO
+ * @tsplus pipeable fncts.test.PSpec whenIO
  */
-export function whenIO_<R, E, R1, E1>(
-  self: PSpec<R, E, TestSuccess>,
-  b: IO<R1, E1, boolean>,
-): PSpec<R | R1 | Annotations, E | E1, TestSuccess> {
-  return matchTag_(self.caseValue, {
-    Exec: (c) => exec(c.spec.whenIO(b), c.exec),
-    Labeled: ({ label, spec }) => Spec.labeled(spec.whenIO(b), label),
-    Scoped: (c) => Spec.scoped(b.flatMap((b) => (b ? c.scoped : IO.succeedNow(Spec.empty)))),
-    Multiple: ({ specs }) => Spec.multiple(specs.map((_) => _.whenIO(b))),
-    Test: (c) =>
-      Spec.test(
-        b.flatMap((b) => IO.if(b, c.test, Annotations.annotate(TestAnnotation.Ignored, 1)).as(TestSuccess.Ignored)),
-        c.annotations,
-      ),
-  });
+export function whenIO<R1, E1>(b: IO<R1, E1, boolean>) {
+  return <R, E>(self: PSpec<R, E, TestSuccess>): PSpec<R | R1 | Annotations, E | E1, TestSuccess> => {
+    return matchTag_(self.caseValue, {
+      Exec: (c) => exec(c.spec.whenIO(b), c.exec),
+      Labeled: ({ label, spec }) => Spec.labeled(spec.whenIO(b), label),
+      Scoped: (c) => Spec.scoped(b.flatMap((b) => (b ? c.scoped : IO.succeedNow(Spec.empty)))),
+      Multiple: ({ specs }) => Spec.multiple(specs.map((_) => _.whenIO(b))),
+      Test: (c) =>
+        Spec.test(
+          b.flatMap((b) => IO.if(b, c.test, Annotations.annotate(TestAnnotation.Ignored, 1)).as(TestSuccess.Ignored)),
+          c.annotations,
+        ),
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.PSpec when
+ * @tsplus pipeable fncts.test.PSpec when
  */
-export function when_<R, E>(self: PSpec<R, E, TestSuccess>, b: Lazy<boolean>): PSpec<R | Annotations, E, TestSuccess> {
-  return self.whenIO(IO.succeed(b));
+export function when(b: Lazy<boolean>) {
+  return <R, E>(self: PSpec<R, E, TestSuccess>): PSpec<R | Annotations, E, TestSuccess> => {
+    return self.whenIO(IO.succeed(b));
+  };
 }

package/_src/control/Spec/definition.ts

@@ -11,7 +11,6 @@ export class PSpec<R, E, T> {
   readonly _R!: () => R;
   readonly _E!: () => E;
   readonly _A!: () => T;
-
   constructor(readonly caseValue: SpecCase<R, E, T, PSpec<R, E, T>>) {}
 }
 
@@ -26,7 +25,6 @@ export const Spec: SpecOps = {};
  * @tsplus type fncts.test.PSpec
  */
 export type Spec<R, E> = PSpec<R, TestFailure<E>, TestSuccess>;
-
 export const enum SpecCaseTag {
   Exec = "Exec",
   Labeled = "Labeled",

package/_src/control/SummaryBuilder.ts

@@ -34,7 +34,6 @@ export function buildSummary<E>(executedSpec: ExecutedSpec<E>): Summary {
   );
   const failures = extractFailures(executedSpec);
   const rendered = ConsoleRenderer.render(failures.flatMap(render), silent).join("\n");
-
   return new Summary(success, fail, ignore, rendered);
 }
 

package/_src/control/TestAnnotationRenderer/api.ts

@@ -5,22 +5,24 @@ import { LeafRenderer } from "./definition.js";
 import { CompositeRenderer, TestAnnotationRendererTag } 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 +
  */
-export function combine_(self: TestAnnotationRenderer, that: TestAnnotationRenderer): TestAnnotationRenderer {
-  if (
-    self._tag === TestAnnotationRendererTag.CompositeRenderer &&
-    that._tag === TestAnnotationRendererTag.CompositeRenderer
-  ) {
-    return new CompositeRenderer(self.renderers.concat(that.renderers));
-  } else if (self._tag === TestAnnotationRendererTag.CompositeRenderer) {
-    return new CompositeRenderer(self.renderers.append(that));
-  } else if (that._tag === TestAnnotationRendererTag.CompositeRenderer) {
-    return new CompositeRenderer(that.renderers.prepend(self));
-  } else {
-    return new CompositeRenderer(Vector(self, that));
-  }
+export function combine(that: TestAnnotationRenderer) {
+  return (self: TestAnnotationRenderer): TestAnnotationRenderer => {
+    if (
+      self._tag === TestAnnotationRendererTag.CompositeRenderer &&
+      that._tag === TestAnnotationRendererTag.CompositeRenderer
+    ) {
+      return new CompositeRenderer(self.renderers.concat(that.renderers));
+    } else if (self._tag === TestAnnotationRendererTag.CompositeRenderer) {
+      return new CompositeRenderer(self.renderers.append(that));
+    } else if (that._tag === TestAnnotationRendererTag.CompositeRenderer) {
+      return new CompositeRenderer(that.renderers.prepend(self));
+    } else {
+      return new CompositeRenderer(Vector(self, that));
+    }
+  };
 }
 
 /**