@fncts/test 0.0.20 → 0.0.21

package/_src/control/Assertion/api.ts

@@ -10,14 +10,16 @@ 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 &&
  */
-export function and_<A>(self: Assertion<A>, that: Assertion<A>): Assertion<A> {
-  return new Assertion(
-    Render.infix(RenderParam(self), "&&", RenderParam(that)),
-    (actual) => self.run(actual) && that.run(actual),
-  );
+export function and<A>(that: Assertion<A>) {
+  return (self: Assertion<A>): Assertion<A> => {
+    return new Assertion(
+      Render.infix(RenderParam(self), "&&", RenderParam(that)),
+      (actual) => self.run(actual) && that.run(actual),
+    );
+  };
 }
 
 /**
@@ -210,10 +212,12 @@ export function isLessThanOrEqualTo(n: number): Assertion<number> {
 }
 
 /**
- * @tsplus fluent fncts.test.Assertion label
+ * @tsplus pipeable fncts.test.Assertion label
  */
-export function label_<A>(self: Assertion<A>, label: string): Assertion<A> {
-  return new Assertion(Render.infix(RenderParam(self), ":", RenderParam(label)), self.run);
+export function label(label: string) {
+  return <A>(self: Assertion<A>): Assertion<A> => {
+    return new Assertion(Render.infix(RenderParam(self), ":", RenderParam(label)), self.run);
+  };
 }
 
 /**
@@ -224,16 +228,21 @@ export 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 ||
  */
-export function or_<A>(self: Assertion<A>, that: Assertion<A>): Assertion<A> {
-  return new Assertion(
-    Render.infix(RenderParam(self), "||", RenderParam(that)),
-    (actual) => self.run(actual) || that.run(actual),
-  );
+export function or<A>(that: Assertion<A>) {
+  return (self: Assertion<A>): Assertion<A> => {
+    return new Assertion(
+      Render.infix(RenderParam(self), "||", RenderParam(that)),
+      (actual) => self.run(actual) || that.run(actual),
+    );
+  };
 }
 
+/**
+ * @tsplus getter fncts.test.Assertion succeeds
+ */
 export function succeeds<A>(assertion: Assertion<A>): Assertion<Exit<any, A>> {
   return Assertion.rec("succeeds", [RenderParam(assertion)], assertion, (exit) =>
     exit.match(
@@ -244,10 +253,12 @@ export function succeeds<A>(assertion: Assertion<A>): Assertion<Exit<any, A>> {
 }
 
 /**
- * @tsplus fluent fncts.test.Assertion test
+ * @tsplus pipeable fncts.test.Assertion test
  */
-export function test_<A>(self: Assertion<A>, actual: A): boolean {
-  return self.run(actual).isSuccess;
+export function test<A>(actual: A) {
+  return (self: Assertion<A>): boolean => {
+    return self.run(actual).isSuccess;
+  };
 }
 
 export const completes = Assertion.make("completes", [], () => true);

package/_src/control/AssertionIO/api.ts

@@ -3,30 +3,36 @@ import { RenderParam } from "../../data/RenderParam.js";
 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 &&
  */
-export function and_<A>(self: AssertionIO<A>, that: AssertionIO<A>): AssertionIO<A> {
-  return new AssertionIO(
-    Render.infix(RenderParam(self), "&&", RenderParam(that)),
-    (actual) => self.runIO(actual) && that.runIO(actual),
-  );
+export function and<A>(that: AssertionIO<A>) {
+  return (self: AssertionIO<A>): AssertionIO<A> => {
+    return new AssertionIO(
+      Render.infix(RenderParam(self), "&&", RenderParam(that)),
+      (actual) => self.runIO(actual) && that.runIO(actual),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.AssertionIO or
- * @tsplus operator fncts.test.AssertionIO ||
+ * @tsplus pipeable fncts.test.AssertionIO or
+ * @tsplus pipeable-operator fncts.test.AssertionIO ||
  */
-export function or_<A>(self: AssertionIO<A>, that: AssertionIO<A>): AssertionIO<A> {
-  return new AssertionIO(
-    Render.infix(RenderParam(self), "||", RenderParam(that)),
-    (actual) => self.runIO(actual) || that.runIO(actual),
-  );
+export function or<A>(that: AssertionIO<A>) {
+  return (self: AssertionIO<A>): AssertionIO<A> => {
+    return new AssertionIO(
+      Render.infix(RenderParam(self), "||", RenderParam(that)),
+      (actual) => self.runIO(actual) || that.runIO(actual),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.AssertionIO label
+ * @tsplus pipeable fncts.test.AssertionIO label
  */
-export function label_<A>(self: AssertionIO<A>, label: string): AssertionIO<A> {
-  return new AssertionIO(Render.infix(RenderParam(self), ":", RenderParam(label)), self.runIO);
+export function label(label: string) {
+  return <A>(self: AssertionIO<A>): AssertionIO<A> => {
+    return new AssertionIO(Render.infix(RenderParam(self), ":", RenderParam(label)), self.runIO);
+  };
 }

package/_src/control/DefaultTestReporter/render.ts

@@ -51,15 +51,12 @@ export function renderStats<E>(duration: number, executedSpec: ExecutedSpec<E>)
         ],
     }),
   );
-
   const total = success + ignore + failure;
-
   const stats = detail(
     `Ran ${total} test${
       total === 1 ? "" : "s"
     } in ${duration}ms: ${success} succeeded, ${ignore} ignored, ${failure} failed`,
   );
-
   return rendered(Other, "", Passed, 0, List(stats.toLine));
 }
 
@@ -89,7 +86,6 @@ function renderLoop<E>(
           return false;
         }
       });
-
       const annotations = executedSpec.fold<E, TestAnnotationMap>(
         matchTag({
           Labeled: ({ spec }) => spec,
@@ -97,19 +93,15 @@ function renderLoop<E>(
           Test: ({ annotations }) => annotations,
         }),
       );
-
       const [status, renderedLabel] = specs.isEmpty
         ? [Ignored, Vector(renderSuiteIgnored(labels.reverse.join(" - "), depth))]
         : hasFailures
         ? [Failed, Vector(renderSuiteFailed(labels.reverse.join(" - "), depth))]
         : [Passed, Vector(renderSuiteSucceeded(labels.reverse.join(" - "), depth))];
-
       const allAnnotations = ancestors.prepend(annotations);
-
-      const rest = Vector.from(specs).flatMap((spec) =>
+      const rest           = Vector.from(specs).flatMap((spec) =>
         renderLoop(spec, depth + 1, ancestors.prepend(annotations), List.empty()),
       );
-
       return rest.prepend(
         rendered(
           Suite,
@@ -215,7 +207,6 @@ function renderGenFailureDetails(failureDetails: Maybe<GenFailureDetails>, offse
           `Test failed after ${details.iterations + 1} iteration${details.iterations > 0 ? "s" : ""} with input: `,
         ) + error(shrunken)
       ).withOffset(offset + 1);
-
       return initial === shrunken
         ? renderShrunken.toMessage
         : renderShrunken | (Fragment("Original input before shrinking was: ") + error(initial)).withOffset(offset + 1);
@@ -246,7 +237,6 @@ function renderValue<A>(av: AssertionValue<A>, offset: number) {
 
 function expressionRedundant(valueStr: string, expression: string) {
   const strip = (s: string) => s.replace('"', "").replace(" ", "").replace("\n", "").replace("\\n", "");
-
   return strip(valueStr) === strip(expression);
 }
 

package/_src/control/FreeBooleanAlgebraIO/api.ts

@@ -3,25 +3,23 @@ import type { FreeBooleanAlgebraIO } from "./definition.js";
 import { FreeBooleanAlgebra } from "../../data/FreeBooleanAlgebra.js";
 
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebraIO and
- * @tsplus operator fncts.test.FreeBooleanAlgebraIO &&
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebraIO and
+ * @tsplus pipeable-operator fncts.test.FreeBooleanAlgebraIO &&
  */
-export 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> {
-  return self.zipWith(that, (a, b) => a && b);
+export function and<R1, E1, A1>(that: FreeBooleanAlgebraIO<R1, E1, A1>) {
+  return <R, E, A extends A1>(self: FreeBooleanAlgebraIO<R, E, A>): FreeBooleanAlgebraIO<R | R1, E | E1, A | A1> => {
+    return self.zipWith(that, (a, b) => a && b);
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebraIO or
- * @tsplus operator fncts.test.FreeBooleanAlgebraIO ||
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebraIO or
+ * @tsplus pipeable-operator fncts.test.FreeBooleanAlgebraIO ||
  */
-export 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> {
-  return self.zipWith(that, (a, b) => a || b);
+export function or<R1, E1, A1>(that: FreeBooleanAlgebraIO<R1, E1, A1>) {
+  return <R, E, A extends A1>(self: FreeBooleanAlgebraIO<R, E, A>): FreeBooleanAlgebraIO<R | R1, E | E1, A | A1> => {
+    return self.zipWith(that, (a, b) => a || b);
+  };
 }
 
 /**

package/_src/control/Gen/api/array.ts

@@ -4,28 +4,31 @@ import type { EqConstraint, LengthConstraints } from "../constraints.js";
 import { Gen } from "../definition.js";
 
 /**
- * @tsplus fluent fncts.test.Gen array
+ * @tsplus pipeable fncts.test.Gen array
  */
-export function array<R, A>(g: Gen<R, A>, constraints: LengthConstraints = {}): Gen<R | Sized, ReadonlyArray<A>> {
-  const minLength = constraints.minLength || 0;
-  return constraints.maxLength
-    ? Gen.int({ min: minLength, max: constraints.maxLength }).flatMap((n) => g.arrayN(n))
-    : Gen.small((n) => g.arrayN(n), minLength);
+export function array(constraints: LengthConstraints = {}) {
+  return <R, A>(g: Gen<R, A>): Gen<R | Sized, ReadonlyArray<A>> => {
+    const minLength = constraints.minLength || 0;
+    return constraints.maxLength
+      ? Gen.int({ min: minLength, max: constraints.maxLength }).flatMap((n) => g.arrayN(n))
+      : Gen.small((n) => g.arrayN(n), minLength);
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.Gen arrayN
+ * @tsplus pipeable fncts.test.Gen arrayN
  */
-export function arrayN_<R, A>(self: Gen<R, A>, n: number): Gen<R, ReadonlyArray<A>> {
-  return self.concN(n).map((conc) => conc.toArray);
+export function arrayN(n: number) {
+  return <R, A>(self: Gen<R, A>): Gen<R, ReadonlyArray<A>> => {
+    return self.concN(n).map((conc) => conc.toArray);
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.Gen uniqueArray
+ * @tsplus pipeable fncts.test.Gen uniqueArray
  */
-export function uniqueArray_<R, A>(
-  gen: Gen<R, A>,
-  constraints: LengthConstraints & EqConstraint<A> = {},
-): Gen<Sized | R, ReadonlyArray<A>> {
-  return gen.uniqueConc(constraints).map((conc) => conc.toArray);
+export function uniqueArray<A>(constraints: LengthConstraints & EqConstraint<A> = {}) {
+  return <R>(gen: Gen<R, A>): Gen<Sized | R, ReadonlyArray<A>> => {
+    return gen.uniqueConc(constraints).map((conc) => conc.toArray);
+  };
 }

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

@@ -6,43 +6,48 @@ import { Eq, Equatable } from "@fncts/base/typeclass";
 import { Gen } from "../definition.js";
 
 /**
- * @tsplus fluent fncts.test.Gen conc
+ * @tsplus pipeable fncts.test.Gen conc
  */
-export function conc<R, A>(self: Gen<R, A>, constraints: LengthConstraints = {}): Gen<R | Sized, Conc<A>> {
-  const minLength = constraints.minLength ?? 0;
-  return constraints.maxLength
-    ? Gen.int({ min: minLength, max: constraints.maxLength }).flatMap((n) => self.concN(n))
-    : Gen.small((n) => self.concN(n), minLength);
+export function conc(constraints: LengthConstraints = {}) {
+  return <R, A>(self: Gen<R, A>): Gen<R | Sized, Conc<A>> => {
+    const minLength = constraints.minLength ?? 0;
+    return constraints.maxLength
+      ? Gen.int({ min: minLength, max: constraints.maxLength }).flatMap((n) => self.concN(n))
+      : Gen.small((n) => self.concN(n), minLength);
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.Gen concN
+ * @tsplus pipeable fncts.test.Gen concN
  */
-export function concN_<R, A>(g: Gen<R, A>, n: number): Gen<R, Conc<A>> {
-  return Conc.replicate(n, g).foldLeft(Gen.constant(Conc.empty()) as Gen<R, Conc<A>>, (gen, a) =>
-    gen.zipWith(a, (as, a) => as.append(a)),
-  );
+export function concN(n: number) {
+  return <R, A>(g: Gen<R, A>): Gen<R, Conc<A>> => {
+    return Conc.replicate(n, g).foldLeft(Gen.constant(Conc.empty()) as Gen<R, Conc<A>>, (gen, a) =>
+      gen.zipWith(a, (as, a) => as.append(a)),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.Gen uniqueConc
+ * @tsplus pipeable fncts.test.Gen uniqueConc
  */
-export function uniqueConc_<R, A>(
-  self: Gen<R, A>,
-  constraints: LengthConstraints & EqConstraint<A> = {},
-): Gen<Sized | R, Conc<A>> {
-  const minLength = constraints.minLength ?? 0;
-  const eq        = constraints.eq ?? Eq({ equals: Equatable.strictEquals });
-  return constraints.maxLength
-    ? Gen.bounded(minLength, constraints.maxLength, (n) => self.uniqueConcN(n, eq))
-    : Gen.small((n) => self.uniqueConcN(n, eq), minLength);
+export function uniqueConc<A>(constraints: LengthConstraints & EqConstraint<A> = {}) {
+  return <R>(self: Gen<R, A>): Gen<Sized | R, Conc<A>> => {
+    const minLength = constraints.minLength ?? 0;
+    const eq        = constraints.eq ?? Eq({ equals: Equatable.strictEquals });
+    return constraints.maxLength
+      ? Gen.bounded(minLength, constraints.maxLength, (n) => self.uniqueConcN(n, eq))
+      : Gen.small((n) => self.uniqueConcN(n, eq), minLength);
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.Gen uniqueConcN
+ * @tsplus pipeable fncts.test.Gen uniqueConcN
  */
-export function uniqueConcN_<R, A>(self: Gen<R, A>, n: number, /** @tsplus auto */ E: Eq<A>): Gen<R, Conc<A>> {
-  return Conc.replicate(n, self).foldLeft(Gen.constant(Conc.empty()) as Gen<R, Conc<A>>, (gen, a) =>
-    gen.zipWith(a, (as, a) => (as.elem(a, E) ? as : as.append(a))),
-  );
+export function uniqueConcN<A>(n: number, /** @tsplus auto */ E: Eq<A>) {
+  return <R>(self: Gen<R, A>): Gen<R, Conc<A>> => {
+    return Conc.replicate(n, self).foldLeft(Gen.constant(Conc.empty()) as Gen<R, Conc<A>>, (gen, a) =>
+      gen.zipWith(a, (as, a) => (as.elem(a, E) ? as : as.append(a))),
+    );
+  };
 }

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

@@ -47,20 +47,24 @@ export function string16(constraints: LengthConstraints = {}): Gen<Sized, string
 }
 
 /**
- * @tsplus fluent fncts.test.Gen string
+ * @tsplus pipeable fncts.test.Gen string
  */
-export function string<R>(char: Gen<R, string>, constraints: LengthConstraints = {}): Gen<R | Sized, string> {
-  const min = constraints.minLength || 0;
-  return constraints.maxLength
-    ? Gen.bounded(min, constraints.maxLength, (n) => char.stringN(n))
-    : Gen.small((n) => char.stringN(n), min);
+export function string(constraints: LengthConstraints = {}) {
+  return <R>(char: Gen<R, string>): Gen<R | Sized, string> => {
+    const min = constraints.minLength || 0;
+    return constraints.maxLength
+      ? Gen.bounded(min, constraints.maxLength, (n) => char.stringN(n))
+      : Gen.small((n) => char.stringN(n), min);
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.Gen stringN
+ * @tsplus pipeable fncts.test.Gen stringN
  */
-export function stringN<R>(char: Gen<R, string>, n: number): Gen<R, string> {
-  return char.arrayN(n).map((arr) => arr.join(""));
+export function stringN(n: number) {
+  return <R>(char: Gen<R, string>): Gen<R, string> => {
+    return char.arrayN(n).map((arr) => arr.join(""));
+  };
 }
 
 /**

package/_src/control/Gen/api/struct.ts

@@ -4,7 +4,12 @@ import { Gen } from "../definition.js";
 
 export function struct<P extends Record<string, Gen<any, any>>>(
   properties: P,
-): Gen<_R<P[keyof P]>, { readonly [K in keyof P]: _A<P[K]> }> {
+): Gen<
+  _R<P[keyof P]>,
+  {
+    readonly [K in keyof P]: _A<P[K]>;
+  }
+> {
   const entries = Object.entries(properties);
   return entries.foldLeft(Gen.constant({}) as Gen<any, any>, (b, [k, gen]) =>
     b.zipWith(gen, (out, a) => ({ ...out, [k]: a })),
@@ -13,7 +18,12 @@ export function struct<P extends Record<string, Gen<any, any>>>(
 
 export function partial<P extends Record<string, Gen<any, any>>>(
   properties: P,
-): Gen<unknown & _R<P[keyof P]>, Partial<{ readonly [K in keyof P]: _A<P[K]> }>> {
+): Gen<
+  unknown & _R<P[keyof P]>,
+  Partial<{
+    readonly [K in keyof P]: _A<P[K]>;
+  }>
+> {
   const entries = Object.entries(properties);
   return entries.foldLeft(Gen.constant({}) as Gen<any, any>, (b, [k, gen]) =>
     Gen.unwrap(Random.nextBoolean.ifIO(IO.succeed(b.zipWith(gen, (r, a) => ({ ...r, [k]: a }))), IO.succeed(b))),

package/_src/control/Gen/api.ts

@@ -45,16 +45,18 @@ export function constant<A>(a: A): Gen<never, A> {
 }
 
 /**
- * @tsplus fluent fncts.test.Gen flatMap
+ * @tsplus pipeable fncts.test.Gen flatMap
  */
-export function flatMap_<R, A, R1, B>(ma: Gen<R, A>, f: (a: A) => Gen<R1, B>): Gen<R | R1, B> {
-  return new Gen(
-    Sample.flatMapStream(ma.sample, (sample) => {
-      const values  = f(sample.value).sample;
-      const shrinks = new Gen(sample.shrink).flatMap((a) => f(a)).sample;
-      return values.map((maybeSample) => maybeSample.map((sample) => sample.flatMap((b) => new Sample(b, shrinks))));
-    }),
-  );
+export function flatMap<A, R1, B>(f: (a: A) => Gen<R1, B>) {
+  return <R>(ma: Gen<R, A>): Gen<R | R1, B> => {
+    return new Gen(
+      Sample.flatMapStream(ma.sample, (sample) => {
+        const values  = f(sample.value).sample;
+        const shrinks = new Gen(sample.shrink).flatMap((a) => f(a)).sample;
+        return values.map((maybeSample) => maybeSample.map((sample) => sample.flatMap((b) => new Sample(b, shrinks))));
+      }),
+    );
+  };
 }
 
 /**
@@ -70,19 +72,23 @@ export function defer<R, A>(gen: Lazy<Gen<R, A>>): Gen<R, A> {
 export const empty: Gen<never, never> = new Gen(Stream.empty);
 
 /**
- * @tsplus fluent fncts.test.Gen filter
+ * @tsplus pipeable fncts.test.Gen filter
  */
-export function filter_<R, A, B extends A>(fa: Gen<R, A>, p: Refinement<A, B>): Gen<R, B>;
-export function filter_<R, A>(fa: Gen<R, A>, p: Predicate<A>): Gen<R, A>;
-export function filter_<R, A>(fa: Gen<R, A>, p: Predicate<A>): Gen<R, A> {
-  return fa.flatMap((a) => (p(a) ? Gen.constant(a) : Gen.empty));
+export function filter<A, B extends A>(p: Refinement<A, B>): <R>(fa: Gen<R, A>) => Gen<R, B>;
+export function filter<A>(p: Predicate<A>): <R>(fa: Gen<R, A>) => Gen<R, A>;
+export function filter<A>(p: Predicate<A>) {
+  return <R>(fa: Gen<R, A>): Gen<R, A> => {
+    return fa.flatMap((a) => (p(a) ? Gen.constant(a) : Gen.empty));
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.Gen filterNot
+ * @tsplus pipeable fncts.test.Gen filterNot
  */
-export function filterNot_<R, A>(fa: Gen<R, A>, p: Predicate<A>): Gen<R, A> {
-  return fa.filter((a) => !p(a));
+export function filterNot<A>(p: Predicate<A>) {
+  return <R>(fa: Gen<R, A>): Gen<R, A> => {
+    return fa.filter((a) => !p(a));
+  };
 }
 
 /**
@@ -124,24 +130,28 @@ export function int(constraints: NumberConstraints = {}): Gen<never, number> {
 }
 
 /**
- * @tsplus fluent fncts.test.Gen map
+ * @tsplus pipeable fncts.test.Gen map
  */
-export function map_<R, A, B>(self: Gen<R, A>, f: (a: A) => B): Gen<R, B> {
-  return new Gen(self.sample.map((maybeSample) => maybeSample.map((sample) => sample.map(f))));
+export function map<A, B>(f: (a: A) => B) {
+  return <R>(self: Gen<R, A>): Gen<R, B> => {
+    return new Gen(self.sample.map((maybeSample) => maybeSample.map((sample) => sample.map(f))));
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.Gen mapIO
+ * @tsplus pipeable fncts.test.Gen mapIO
  */
-export function mapIO_<R, A, R1, B>(self: Gen<R, A>, f: (a: A) => IO<R1, never, B>): Gen<R | R1, B> {
-  return new Gen(
-    self.sample.mapIO((maybeSample) =>
-      maybeSample.match(
-        () => IO.succeedNow(Nothing()),
-        (sample) => sample.foreach(f).map(Maybe.just),
+export function mapIO<A, R1, B>(f: (a: A) => IO<R1, never, B>) {
+  return <R>(self: Gen<R, A>): Gen<R | R1, B> => {
+    return new Gen(
+      self.sample.mapIO((maybeSample) =>
+        maybeSample.match(
+          () => IO.succeedNow(Nothing()),
+          (sample) => sample.foreach(f).map(Maybe.just),
+        ),
       ),
-    ),
-  );
+    );
+  };
 }
 
 /**
@@ -168,7 +178,9 @@ export function medium<R, A>(f: (n: number) => Gen<R, A>, min = 0): Gen<R | Size
  * @tsplus static fncts.test.GenOps memo
  */
 export function memo<R, A>(builder: (maxDepth: number) => Gen<R, A>): (maxDepth?: number) => Gen<R, A> {
-  const previous: { [depth: number]: Gen<R, A> } = {};
+  const previous: {
+    [depth: number]: Gen<R, A>;
+  } = {};
   let remainingDepth = 10;
   return (maxDepth?: number): Gen<R, A> => {
     const n = maxDepth !== undefined ? maxDepth : remainingDepth;
@@ -198,14 +210,16 @@ export function oneOf<A extends ReadonlyArray<Gen<any, any>>>(...gens: A): Gen<_
 }
 
 /**
- * @tsplus fluent fncts.test.Gen reshrink
+ * @tsplus pipeable fncts.test.Gen reshrink
  */
-export function reshrink_<R, A, R1, B>(gen: Gen<R, A>, f: (a: A) => Sample<R1, B>): Gen<R | R1, B> {
-  return new Gen(
-    (gen.sample as Stream<R | R1, never, Maybe<Sample<R, A>>>).map((maybeSample) =>
-      maybeSample.map((sample) => f(sample.value)),
-    ),
-  );
+export function reshrink<A, R1, B>(f: (a: A) => Sample<R1, B>) {
+  return <R>(gen: Gen<R, A>): Gen<R | R1, B> => {
+    return new Gen(
+      (gen.sample as Stream<R | R1, never, Maybe<Sample<R, A>>>).map((maybeSample) =>
+        maybeSample.map((sample) => f(sample.value)),
+      ),
+    );
+  };
 }
 
 /**
@@ -269,8 +283,10 @@ export function weighted<R, A>(...gens: ReadonlyArray<readonly [Gen<R, A>, numbe
 }
 
 /**
- * @tsplus fluent fncts.test.Gen zipWith
+ * @tsplus pipeable fncts.test.Gen zipWith
  */
-export 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> {
-  return self.flatMap((a) => that.map((b) => f(a, b)));
+export function zipWith<A, R1, B, C>(that: Gen<R1, B>, f: (a: A, b: B) => C) {
+  return <R>(self: Gen<R, A>): Gen<R | R1, C> => {
+    return self.flatMap((a) => that.map((b) => f(a, b)));
+  };
 }

package/_src/control/Gen.ts

@@ -3,7 +3,6 @@ export * from "./Gen/api.js";
 export * from "./Gen/constraints.js";
 export * from "./Gen/definition.js";
 // codegen:end
-
 // codegen:start { preset: barrel, include: ./Gen/api/*.ts }
 export * from "./Gen/api/array.js";
 export * from "./Gen/api/char.js";

package/_src/control/Live/definition.ts

@@ -1,5 +1,3 @@
-import type { Erase } from "@fncts/typelevel/Intersection";
-
 import { IOEnv } from "@fncts/io/IOEnv";
 
 /**
@@ -12,7 +10,6 @@ export const LiveTag = Tag<Live>("fncts.test.Live");
  */
 export abstract class Live {
   abstract provide<R, E, A>(io: IO<R, E, A>): IO<R, E, A>;
-
   static Default: Layer<IOEnv, never, Live> = Layer.fromIO(
     IO.environmentWith(
       (env) =>
@@ -24,7 +21,6 @@ export abstract class Live {
     ),
     LiveTag,
   );
-
   static Live<R extends Live, E, A>(io: IO<R, E, A>): IO<R | Live, E, A> {
     return IO.serviceWithIO((live) => live.provide(io), LiveTag);
   }