@fncts/test 0.0.20 → 0.0.22

package/_src/control/TestAnnotationRenderer/definition.ts

@@ -11,7 +11,6 @@ export class LeafRenderer {
   constructor(
     readonly use: <X>(f: <V>(annotation: TestAnnotation<V>, render: (_: List<V>) => Maybe<string>) => X) => X,
   ) {}
-
   run(ancestors: List<TestAnnotationMap>, child: TestAnnotationMap): List<string> {
     return this.use((annotation, render) =>
       render(
@@ -30,7 +29,6 @@ export class LeafRenderer {
 export class CompositeRenderer {
   readonly _tag = TestAnnotationRendererTag.CompositeRenderer;
   constructor(readonly renderers: Vector<TestAnnotationRenderer>) {}
-
   run(ancestors: List<TestAnnotationMap>, child: TestAnnotationMap): List<string> {
     return this.renderers.toList.flatMap((renderer) => renderer.run(ancestors, child));
   }

package/_src/control/TestAspect/api.ts

@@ -35,7 +35,7 @@ export function after<R, E, A>(effect: IO<R, E, A>): TestAspect<R, E> {
   return perTest<R, E>((test) =>
     test.result
       .zipWith(effect.catchAllCause((cause) => IO.fail(new RuntimeFailure(cause))).result, (ex0, ex1) =>
-        ex0.apFirst(ex1),
+        ex0.zipLeft(ex1),
       )
       .flatMap(IO.fromExitNow),
   );
@@ -60,7 +60,7 @@ export function aroundAll<R, E, A, R1>(
 }
 
 export function before<R0>(effect: IO<R0, never, any>): TestAspect<R0, never> {
-  return perTest<R0, never>((test) => effect.apSecond(test));
+  return perTest<R0, never>((test) => effect.zipRight(test));
 }
 
 export function beforeAll<R0, E0>(effect: IO<R0, E0, any>): TestAspect<R0, E0> {
@@ -96,7 +96,6 @@ export function timeoutWarning(duration: Duration): TestAspect<Live, any> {
         Multiple: ({ specs }) => Spec.multiple(specs.map((spec) => loop(labels, spec))),
         Test: ({ test, annotations }) => Spec.test(warn(labels, test, duration), annotations),
       });
-
     return loop(Vector(), spec);
   };
 }

package/_src/control/TestClock/definition.ts

@@ -4,6 +4,7 @@ import type { Live } from "@fncts/test/control/Live";
 
 import { matchTag } from "@fncts/base/util/pattern";
 import { Console } from "@fncts/io/Console";
+import { FiberStatusTag } from "@fncts/io/FiberStatus";
 import { TestAnnotation } from "@fncts/test/data/TestAnnotation";
 
 export class Data {
@@ -60,9 +61,9 @@ export class TestClock extends Clock {
   }
   sleep = (ms: Lazy<Duration>) => {
     const self = this;
-    return IO.gen(function* (_) {
-      const promise = yield* _(Future.make<never, void>());
-      const wait    = yield* _(
+    return Do((_) => {
+      const promise = _(Future.make<never, void>());
+      const wait    = _(
         self.clockState.modify((data) => {
           const end = data.duration + ms().milliseconds;
           if (end > data.duration) {
@@ -72,7 +73,7 @@ export class TestClock extends Clock {
           }
         }),
       );
-      yield* _(
+      _(
         IO.defer(() => {
           if (wait) {
             return self.warningStart > promise.await;
@@ -83,46 +84,39 @@ export class TestClock extends Clock {
       );
     });
   };
-
   currentTime = this.clockState.get.map((data) => data.duration);
-
   adjust(duration: number): UIO<void> {
     return this.warningDone > this.run((d) => d + duration);
   }
-
   setDate(date: Date): UIO<void> {
     return this.setTime(date.getTime());
   }
-
   setTime(time: number): UIO<void> {
     return this.warningDone > this.run((_) => time);
   }
-
   sleeps = this.clockState.get.map((data) => data.sleeps.map(([_]) => _));
-
   get supervizedFibers(): UIO<HashSet<Fiber.Runtime<any, any>>> {
-    return IO.descriptorWith((descriptor) =>
+    return IO.fiberId.flatMap((fiberId) =>
       this.annotations.get(TestAnnotation.Fibers).flatMap((_) =>
         _.match(
-          (_) => IO.succeed(HashSet.makeDefault()),
+          (_) => IO.succeed(HashSet.empty()),
           (fibers) =>
             IO.foreach(fibers, (ref) => ref.get)
-              .map((_) => _.foldLeft(HashSet.makeDefault<Fiber.Runtime<any, any>>(), (s0, s1) => s0.union(s1)))
-              .map((set) => set.filter((f) => !Equatable.strictEquals(f.id, descriptor.id))),
+              .map((_) => _.foldLeft(HashSet.empty<Fiber.Runtime<any, any>>(), (s0, s1) => s0.union(s1)))
+              .map((set) => set.filter((f) => !Equatable.strictEquals(f.id, fiberId))),
         ),
       ),
     );
   }
-
   private get freeze(): IO<never, void, HashMap<FiberId, FiberStatus>> {
     return this.supervizedFibers.flatMap((fibers) =>
-      IO.foldLeft(fibers, HashMap.makeDefault<FiberId, FiberStatus>(), (map, fiber) =>
+      IO.foldLeft(fibers, HashMap.empty<FiberId, FiberStatus>(), (map, fiber) =>
         fiber.status.flatMap((status) => {
           switch (status._tag) {
-            case "Done": {
+            case FiberStatusTag.Done: {
               return IO.succeed(map.set(fiber.id, status));
             }
-            case "Suspended": {
+            case FiberStatusTag.Suspended: {
               return IO.succeed(map.set(fiber.id, status));
             }
             default: {
@@ -133,23 +127,20 @@ export class TestClock extends Clock {
       ),
     );
   }
-
   private get delay(): UIO<void> {
     return this.live.provide(Clock.sleep((5).milliseconds));
   }
-
   private get awaitSuspended(): UIO<void> {
     return this.suspended
       .zipWith(this.live.provide(Clock.sleep((10).milliseconds)) > this.suspended, Equatable.strictEquals)
       .filterOrFail(Function.identity, (): void => undefined).eventually.asUnit;
   }
-
   private run(f: (duration: number) => number): UIO<void> {
     return (
       this.awaitSuspended >
       this.clockState.modify((data) => {
         const end    = f(data.duration);
-        const sorted = data.sleeps.sortWith(([x], [y]) => Number.Ord.compare(x, y));
+        const sorted = data.sleeps.sortWith(([x], [y]) => Number.Ord.compare(y)(x));
         return sorted.head
           .flatMap(([duration, promise]) =>
             duration <= end
@@ -165,7 +156,6 @@ export class TestClock extends Clock {
       ),
     );
   }
-
   private get suspended(): IO<never, void, HashMap<FiberId, FiberStatus>> {
     return this.freeze.zip(this.delay > this.freeze).flatMap(([first, last]) => {
       if (Equatable.strictEquals(first, last)) {
@@ -175,7 +165,6 @@ export class TestClock extends Clock {
       }
     });
   }
-
   warningDone: UIO<void> = this.warningState.updateJustIO(
     matchTag({
       Start: () => Just(IO(Done)),
@@ -183,7 +172,6 @@ export class TestClock extends Clock {
       Done: () => Nothing(),
     }),
   );
-
   private warningStart: UIO<void> = this.warningState.updateJustIO(
     matchTag(
       {

package/_src/control/TestConsole/definition.ts

@@ -1,7 +1,7 @@
 import type { Console } from "@fncts/io/Console";
 import type { Live } from "@fncts/test/control/Live";
 
-import { showWithOptions } from "@fncts/base/typeclass/Showable";
+import { showWithOptions } from "@fncts/base/data/Showable";
 
 export class ConsoleData extends CaseClass<{
   readonly input: Vector<string>;
@@ -54,7 +54,6 @@ export class TestConsole implements Console {
     return this.debugState.locally(true)(io);
   }
 }
-
 /**
  * @tsplus static fncts.test.TestConsoleOps Tag
  */

package/_src/control/TestLogger.ts

@@ -1,5 +1,3 @@
-import { Console } from "@fncts/io/Console";
-
 /**
  * @tsplus type fncts.test.TestLogger
  * @tsplus companion fncts.test.TestLoggerOps

package/_src/control/TestRandom/api.ts

@@ -7,30 +7,35 @@ import { Buffer, Data, TestRandom } from "@fncts/test/control/TestRandom";
 export function feedInts(...ints: ReadonlyArray<number>) {
   return IO.serviceWithIO((tr) => tr.feedInts(...ints), TestRandom.Tag);
 }
+
 /**
  * @tsplus static fncts.test.TestRandom feedBytes
  */
 export function feedBytes(...bytes: ReadonlyArray<ReadonlyArray<Byte>>) {
   return IO.serviceWithIO((tr) => tr.feedBytes(...bytes), TestRandom.Tag);
 }
+
 /**
  * @tsplus static fncts.test.TestRandom feedChars
  */
 export function feedChars(...chars: ReadonlyArray<string>) {
   return IO.serviceWithIO((tr) => tr.feedChars(...chars), TestRandom.Tag);
 }
+
 /**
  * @tsplus static fncts.test.TestRandom feedDoubles
  */
 export function feedDoubles(...doubles: ReadonlyArray<number>) {
   return IO.serviceWithIO((tr) => tr.feedDoubles(...doubles), TestRandom.Tag);
 }
+
 /**
  * @tsplus static fncts.test.TestRandom feedStrings
  */
 export function feedStrings(...strings: ReadonlyArray<string>) {
   return IO.serviceWithIO((tr) => tr.feedStrings(...strings), TestRandom.Tag);
 }
+
 /**
  * @tsplus static fncts.test.TestRandom feedBooleans
  */

package/_src/control/TestRandom/definition.ts

@@ -13,7 +13,6 @@ export const TestRandomTag = Tag<TestRandom>("fncts.test.TestRandom");
  */
 export class TestRandom implements Random {
   constructor(readonly randomState: Ref<Data>, readonly bufferState: Ref<Buffer>) {}
-
   clearBooleans: UIO<void> = this.bufferState.update((buff) => buff.copy({ booleans: Vector.empty() }));
   clearBytes: UIO<void>    = this.bufferState.update((buff) => buff.copy({ bytes: Vector.empty() }));
   clearChars: UIO<void>    = this.bufferState.update((buff) => buff.copy({ chars: Vector.empty() }));
@@ -39,7 +38,6 @@ export class TestRandom implements Random {
     return this.bufferState.update((data) => data.copy({ strings: Vector.from(strings).concat(data.strings) }));
   }
   getSeed: UIO<number> = this.randomState.get.map((data) => ((data.seed1 << 24) | data.seed2) ^ 0x5deece66d);
-
   setSeed(seed: number): UIO<void> {
     const mash    = Mash();
     const newSeed = mash(seed.toString());
@@ -47,7 +45,6 @@ export class TestRandom implements Random {
     const seed2   = Math.floor(newSeed) & ((1 << 24) - 1);
     return this.randomState.set(new Data(seed1, seed2, ImmutableQueue.empty()));
   }
-
   private bufferedBoolean = (buffer: Buffer): readonly [Maybe<boolean>, Buffer] => {
     return [buffer.booleans.head, buffer.copy({ booleans: buffer.booleans.drop(1) })];
   };
@@ -57,19 +54,15 @@ export class TestRandom implements Random {
   private bufferedInt = (buffer: Buffer): readonly [Maybe<number>, Buffer] => {
     return [buffer.integers.head, buffer.copy({ integers: buffer.integers.drop(1) })];
   };
-
   private getOrElse = <A>(buffer: (_: Buffer) => readonly [Maybe<A>, Buffer], random: UIO<A>): UIO<A> => {
     return this.bufferState.modify(buffer).flatMap((_) => _.match(() => random, IO.succeedNow));
   };
-
   private leastSignificantBits = (x: number): number => {
     return Math.floor(x) & ((1 << 24) - 1);
   };
-
   private mostSignificantBits = (x: number): number => {
     return Math.floor(x / (1 << 24));
   };
-
   private randomBits = (bits: number): UIO<number> => {
     return this.randomState.modify((data) => {
       const multiplier  = 0x5deece66d;
@@ -83,10 +76,8 @@ export class TestRandom implements Random {
       return [result >>> (32 - bits), new Data(newSeed1, newSeed2, data.nextNextGaussians)];
     });
   };
-
   private randomBoolean = this.randomBits(1).map((n) => n !== 0);
-
-  private randomBytes = (length: number): UIO<ReadonlyArray<Byte>> => {
+  private randomBytes   = (length: number): UIO<ReadonlyArray<Byte>> => {
     const loop = (i: number, rnd: UIO<number>, n: number, acc: UIO<List<Byte>>): UIO<List<Byte>> => {
       if (i === length) {
         return acc.map((l) => l.reverse);
@@ -103,10 +94,8 @@ export class TestRandom implements Random {
         return loop(i, this.nextInt, Math.min(length - i, 4), acc);
       }
     };
-
     return loop(0, this.randomInt, Math.min(length, 4), IO.succeedNow(List.empty())).map((list) => Array.from(list));
   };
-
   private randomIntBounded = (n: number) => {
     if (n <= 0) {
       return IO.haltNow(new IllegalArgumentError("n must be positive", "TestRandom.randomIntBounded"));
@@ -121,47 +110,35 @@ export class TestRandom implements Random {
       return loop;
     }
   };
-
   private randomLong: UIO<bigint> = this.randomBits(32).flatMap((i1) =>
     this.randomBits(32).flatMap((i2) => IO.succeedNow(BigInt(i1 << 32) + BigInt(i2))),
   );
-
-  private randomInt = this.randomBits(32);
-
+  private randomInt    = this.randomBits(32);
   private randomDouble = this.randomBits(26).flatMap((i1) =>
     this.randomBits(27).map((i2) => (i1 * (1 << 27) + i2) / (1 << 53)),
   );
-
   private random = this.randomBits(26);
-
   get nextInt(): UIO<number> {
     return this.getOrElse(this.bufferedInt, this.randomInt);
   }
-
   get nextBoolean(): UIO<boolean> {
     return this.getOrElse(this.bufferedBoolean, this.randomBoolean);
   }
-
   get nextDouble(): UIO<number> {
     return this.getOrElse(this.bufferedDouble, this.randomDouble);
   }
-
   get next(): UIO<number> {
     return this.getOrElse(this.bufferedDouble, this.random);
   }
-
   nextBigIntBetween(low: bigint, high: bigint): UIO<bigint> {
     return this.randomLong.repeatUntil((n) => low <= n && n < high);
   }
-
   nextIntBetween(low: number, high: number): UIO<number> {
     return nextIntBetweenWith(low, high, this.randomInt, this.randomIntBounded);
   }
-
   nextRange(low: number, high: number): UIO<number> {
     return this.next.map((n) => (high - low + 1) * n + low);
   }
-
   nextArrayIntBetween(low: ArrayInt, high: ArrayInt): UIO<ArrayInt> {
     const self = this;
     return IO.gen(function* (_) {
@@ -187,7 +164,6 @@ export class TestRandom implements Random {
     }).map((ns) => trimArrayIntInplace(addArrayIntToNew({ sign: 1, data: ns }, low)));
   }
 }
-
 /**
  * @internal
  */
@@ -205,7 +181,6 @@ function nextIntBetweenWith(
     else return nextInt.repeatUntil((n) => min <= n && n < max);
   }
 }
-
 export class Data {
   constructor(
     readonly seed1: number,
@@ -213,7 +188,6 @@ export class Data {
     readonly nextNextGaussians: ImmutableQueue<number> = ImmutableQueue.empty(),
   ) {}
 }
-
 export class Buffer {
   constructor(
     readonly booleans: Vector<boolean> = Vector.empty(),
@@ -223,7 +197,6 @@ export class Buffer {
     readonly integers: Vector<number> = Vector.empty(),
     readonly strings: Vector<string> = Vector.empty(),
   ) {}
-
   copy(_: Partial<Buffer>): Buffer {
     return new Buffer(
       _.booleans ?? this.booleans,
@@ -235,7 +208,6 @@ export class Buffer {
     );
   }
 }
-
 /** @internal */
 function isStrictlySmaller(dataA: number[], dataB: number[]): boolean {
   const maxLength = Math.max(dataA.length, dataB.length);
@@ -249,7 +221,6 @@ function isStrictlySmaller(dataA: number[], dataB: number[]): boolean {
   }
   return false;
 }
-
 export function substractArrayIntToNew(arrayIntA: ArrayInt, arrayIntB: ArrayInt): ArrayInt {
   if (arrayIntA.sign !== arrayIntB.sign) {
     return addArrayIntToNew(arrayIntA, { sign: -arrayIntB.sign as -1 | 1, data: arrayIntB.data });
@@ -272,7 +243,6 @@ export function substractArrayIntToNew(arrayIntA: ArrayInt, arrayIntB: ArrayInt)
   }
   return { sign: arrayIntA.sign, data: data.reverse() };
 }
-
 /**
  * Trim uneeded zeros in ArrayInt
  * and uniform notation for zero: {sign: 1, data: [0]}
@@ -292,7 +262,6 @@ export function trimArrayIntInplace(arrayInt: ArrayInt) {
   return arrayInt;
   /* eslint-enable */
 }
-
 /**
  * Add two ArrayInt
  * @internal
@@ -320,7 +289,6 @@ export function addArrayIntToNew(arrayIntA: ArrayInt, arrayIntB: ArrayInt): Arra
   }
   return { sign: arrayIntA.sign, data: data.reverse() };
 }
-
 /**
  * Add one to a given positive ArrayInt
  * @internal
@@ -342,8 +310,7 @@ export function addOneToPositiveArrayInt(arrayInt: ArrayInt): ArrayInt {
 }
 
 function Mash() {
-  let n = 0xefc8249d;
-
+  let n      = 0xefc8249d;
   const mash = function (data: string) {
     for (let i = 0; i < data.length; i++) {
       n    += data.charCodeAt(i);
@@ -357,6 +324,5 @@ function Mash() {
     }
     return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
   };
-
   return mash;
 }

package/_src/control/TestRenderer/ConsoleRenderer.ts

@@ -10,7 +10,6 @@ import { fr, info, sp, warn } from "../../data/LogLine.js";
 import { Line } from "../../data/LogLine/Line.js";
 import { Message } from "../../data/LogLine/Message.js";
 import { TestAnnotation } from "../../data/TestAnnotation.js";
-import { TestRenderer } from "./definition.js";
 
 const tabSize = 2;
 

package/_src/control/TestRunner.ts

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

package/_src/data/AssertionValue/api.ts

@@ -1,32 +1,38 @@
-import { showWithOptions } from "@fncts/base/typeclass/Showable";
+import { showWithOptions } from "@fncts/base/data/Showable";
 
 import { AssertionValue } from "./definition.js";
 
 /**
- * @tsplus fluent fncts.test.data.AssertionValue label
+ * @tsplus pipeable fncts.test.data.AssertionValue label
  */
-export function label<A>(self: AssertionValue<A>, string: string): AssertionValue<A> {
-  return new AssertionValue(
-    LazyValue(() => self.assertion.value.label(string)),
-    self.value,
-    self.result,
-    self.expression,
-    self.sourceLocation,
-  );
+export function label(string: string) {
+  return <A>(self: AssertionValue<A>): AssertionValue<A> => {
+    return new AssertionValue(
+      LazyValue(() => self.assertion.value.label(string)),
+      self.value,
+      self.result,
+      self.expression,
+      self.sourceLocation,
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.data.AssertionValue isSameAssertionAs
+ * @tsplus pipeable fncts.test.data.AssertionValue isSameAssertionAs
  */
-export function isSameAssertionAs<A>(self: AssertionValue<A>, that: AssertionValue<A>): boolean {
-  return self.assertion.value.rendered === that.assertion.value.rendered;
+export function isSameAssertionAs<A>(that: AssertionValue<A>) {
+  return (self: AssertionValue<A>): boolean => {
+    return self.assertion.value.rendered === that.assertion.value.rendered;
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.data.AssertionValue showValue
+ * @tsplus pipeable fncts.test.data.AssertionValue showValue
  */
-export function showValue<A>(self: AssertionValue<A>, offset = 0): string {
-  return showWithOptions(self.value, { indentationLevel: offset });
+export function showValue(offset = 0) {
+  return <A>(self: AssertionValue<A>): string => {
+    return showWithOptions(self.value, { indentationLevel: offset });
+  };
 }
 
 /**
@@ -37,12 +43,10 @@ export function printAssertion<A>(self: AssertionValue<A>): string {
 }
 
 /**
- * @tsplus fluent fncts.test.data.AssertionValue withContext
+ * @tsplus pipeable fncts.test.data.AssertionValue withContext
  */
-export function withContext<A>(
-  self: AssertionValue<A>,
-  expr: Maybe<string>,
-  sourceLocation: Maybe<string>,
-): AssertionValue<A> {
-  return new AssertionValue(self.assertion, self.value, self.result, expr, sourceLocation);
+export function withContext(expr: Maybe<string>, sourceLocation: Maybe<string>) {
+  return <A>(self: AssertionValue<A>): AssertionValue<A> => {
+    return new AssertionValue(self.assertion, self.value, self.result, expr, sourceLocation);
+  };
 }

package/_src/data/AssertionValue/definition.ts

@@ -1,6 +1,5 @@
 import type { AssertionIO } from "../../control/AssertionIO/definition.js";
 import type { FreeBooleanAlgebra } from "../FreeBooleanAlgebra.js";
-
 export const AssertionValueTypeId = Symbol.for("fncts.test.data.AssertionValue");
 export type AssertionValueTypeId = typeof AssertionValueTypeId;
 

package/_src/data/ExecutedSpec/api.ts

@@ -10,14 +10,16 @@ import { ExecutedSpec, TestCase } from "./definition.js";
 import { LabeledCase, MultipleCase } from "./definition.js";
 
 /**
- * @tsplus fluent fncts.test.data.ExecutedSpec fold
+ * @tsplus pipeable fncts.test.data.ExecutedSpec fold
  */
-export function fold_<E, Z>(self: ExecutedSpec<E>, f: (_: SpecCase<E, Z>) => Z): Z {
-  return matchTag_(self.caseValue, {
-    Labeled: ({ label, spec }) => f(new LabeledCase(label, spec.fold(f))),
-    Multiple: ({ specs }) => f(new MultipleCase(specs.map((spec) => spec.fold(f)))),
-    Test: f,
-  });
+export function fold<E, Z>(f: (_: SpecCase<E, Z>) => Z) {
+  return (self: ExecutedSpec<E>): Z => {
+    return matchTag_(self.caseValue, {
+      Labeled: ({ label, spec }) => f(new LabeledCase(label, spec.fold(f))),
+      Multiple: ({ specs }) => f(new MultipleCase(specs.map((spec) => spec.fold(f)))),
+      Test: f,
+    });
+  };
 }
 
 /**
@@ -28,17 +30,19 @@ export function labeled<E>(spec: ExecutedSpec<E>, label: string): ExecutedSpec<E
 }
 
 /**
- * @tsplus fluent fncts.test.data.ExecutedSpecCase map
+ * @tsplus pipeable fncts.test.data.ExecutedSpecCase map
  */
-export function mapSpecCase_<E, A, B>(self: SpecCase<E, A>, f: (a: A) => B): SpecCase<E, B> {
-  return matchTag_(
-    self,
-    {
-      Labeled: ({ label, spec }) => new LabeledCase(label, f(spec)),
-      Multiple: ({ specs }) => new MultipleCase(specs.map(f)),
-    },
-    identity,
-  );
+export function mapSpecCase<A, B>(f: (a: A) => B) {
+  return <E>(self: SpecCase<E, A>): SpecCase<E, B> => {
+    return matchTag_(
+      self,
+      {
+        Labeled: ({ label, spec }) => new LabeledCase(label, f(spec)),
+        Multiple: ({ specs }) => new MultipleCase(specs.map(f)),
+      },
+      identity,
+    );
+  };
 }
 
 /**
@@ -56,30 +60,31 @@ export function test<E>(test: Either<TestFailure<E>, TestSuccess>, annotations:
 }
 
 /**
- * @tsplus fluent fncts.test.data.ExecutedSpec transform
+ * @tsplus pipeable fncts.test.data.ExecutedSpec transform
  */
-export function transform_<E, E1>(
-  self: ExecutedSpec<E>,
-  f: (_: SpecCase<E, ExecutedSpec<E1>>) => SpecCase<E1, ExecutedSpec<E1>>,
-): ExecutedSpec<E1> {
-  return matchTag_(self.caseValue, {
-    Labeled: ({ label, spec }) => new ExecutedSpec(f(new LabeledCase(label, spec.transform(f)))),
-    Multiple: ({ specs }) => new ExecutedSpec(f(new MultipleCase(specs.map((spec) => spec.transform(f))))),
-    Test: (t) => new ExecutedSpec(f(t)),
-  });
+export function transform<E, E1>(f: (_: SpecCase<E, ExecutedSpec<E1>>) => SpecCase<E1, ExecutedSpec<E1>>) {
+  return (self: ExecutedSpec<E>): ExecutedSpec<E1> => {
+    return matchTag_(self.caseValue, {
+      Labeled: ({ label, spec }) => new ExecutedSpec(f(new LabeledCase(label, spec.transform(f)))),
+      Multiple: ({ specs }) => new ExecutedSpec(f(new MultipleCase(specs.map((spec) => spec.transform(f))))),
+      Test: (t) => new ExecutedSpec(f(t)),
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.data.ExecutedSpec exists
+ * @tsplus pipeable fncts.test.data.ExecutedSpec some
  */
-export function exists_<E>(self: ExecutedSpec<E>, f: (_: SpecCase<E, boolean>) => boolean): boolean {
-  return self.fold(
-    matchTag({
-      Labeled: (c) => c.spec || f(c),
-      Multiple: (c) => c.specs.exists(identity) || f(c),
-      Test: f,
-    }),
-  );
+export function some<E>(f: (_: SpecCase<E, boolean>) => boolean) {
+  return (self: ExecutedSpec<E>): boolean => {
+    return self.fold(
+      matchTag({
+        Labeled: (c) => c.spec || f(c),
+        Multiple: (c) => c.specs.some(identity) || f(c),
+        Test: f,
+      }),
+    );
+  };
 }
 
 /**