@fncts/test 0.0.20 → 0.0.22

package/_src/control/Gen.ts

@@ -3,13 +3,3 @@ 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";
-export * from "./Gen/api/conc.js";
-export * from "./Gen/api/double.js";
-export * from "./Gen/api/float.js";
-export * from "./Gen/api/string.js";
-export * from "./Gen/api/struct.js";
-// codegen:end

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);
   }

package/_src/control/RunnableSpec.ts

@@ -13,7 +13,7 @@ export abstract class RunnableSpec<R, E> extends AbstractRunnableSpec<R, E> {
     const self = this;
     return Do((_) => {
       const results     = _(self.runSpec(spec));
-      const hasFailures = results.exists(
+      const hasFailures = results.some(
         matchTag(
           {
             Test: ({ test }) => test.isLeft(),

package/_src/control/Sample/api.ts

@@ -8,86 +8,93 @@ import { add64, halve64, isEqual64, substract64 } from "../../util/math.js";
 import { Sample } from "./definition.js";
 
 /**
- * @tsplus fluent fncts.test.Sample flatMap
+ * @tsplus pipeable fncts.test.Sample flatMap
  */
-export function flatMap_<R, A, R1, B>(ma: Sample<R, A>, f: (a: A) => Sample<R1, B>): Sample<R | R1, B> {
-  const sample = f(ma.value);
-  return new Sample(
-    sample.value,
-    mergeStream(
-      sample.shrink,
-      ma.shrink.map((maybeSample) => maybeSample.map((sample) => sample.flatMap(f))),
-    ),
-  );
+export function flatMap<A, R1, B>(f: (a: A) => Sample<R1, B>) {
+  return <R>(ma: Sample<R, A>): Sample<R | R1, B> => {
+    const sample = f(ma.value);
+    return new Sample(
+      sample.value,
+      mergeStream(
+        sample.shrink,
+        ma.shrink.map((maybeSample) => maybeSample.map((sample) => sample.flatMap(f))),
+      ),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.Sample filter
+ * @tsplus pipeable fncts.test.Sample filter
  */
-export function filter_<R, A>(ma: Sample<R, A>, f: Predicate<A>): Stream<R, never, Maybe<Sample<R, A>>> {
-  if (f(ma.value)) {
-    return Stream.succeedNow(
-      Just(
-        new Sample(
-          ma.value,
-          ma.shrink.flatMap((maybeSample) => maybeSample.map((sample) => sample.filter(f)).getOrElse(Stream.empty)),
+export function filter<A>(f: Predicate<A>) {
+  return <R>(ma: Sample<R, A>): Stream<R, never, Maybe<Sample<R, A>>> => {
+    if (f(ma.value)) {
+      return Stream.succeedNow(
+        Just(
+          new Sample(
+            ma.value,
+            ma.shrink.flatMap((maybeSample) => maybeSample.map((sample) => sample.filter(f)).getOrElse(Stream.empty)),
+          ),
         ),
-      ),
-    );
-  } else {
-    return ma.shrink.flatMap((maybeSample) => maybeSample.map((sample) => sample.filter(f)).getOrElse(Stream.empty));
-  }
+      );
+    } else {
+      return ma.shrink.flatMap((maybeSample) => maybeSample.map((sample) => sample.filter(f)).getOrElse(Stream.empty));
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.Sample foreach
+ * @tsplus pipeable fncts.test.Sample foreach
  */
-export function foreach_<R, A, R1, B>(
-  ma: Sample<R, A>,
-  f: (a: A) => IO<R1, never, B>,
-): IO<R | R1, never, Sample<R | R1, B>> {
-  return f(ma.value).map(
-    (b) =>
-      new Sample(
-        b,
-        ma.shrink.mapIO((maybeSample) =>
-          maybeSample.match(
-            () => IO.succeedNow(Nothing()),
-            (sample) => sample.foreach(f).map((value) => Just(value)),
+export function foreach<A, R1, B>(f: (a: A) => IO<R1, never, B>) {
+  return <R>(ma: Sample<R, A>): IO<R | R1, never, Sample<R | R1, B>> => {
+    return f(ma.value).map(
+      (b) =>
+        new Sample(
+          b,
+          ma.shrink.mapIO((maybeSample) =>
+            maybeSample.match(
+              () => IO.succeedNow(Nothing()),
+              (sample) => sample.foreach(f).map((value) => Just(value)),
+            ),
           ),
         ),
-      ),
-  );
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.Sample map
+ * @tsplus pipeable fncts.test.Sample map
  */
-export function map_<R, A, B>(ma: Sample<R, A>, f: (a: A) => B): Sample<R, B> {
-  return new Sample(
-    f(ma.value),
-    ma.shrink.map((v) => v.map((sample) => sample.map(f))),
-  );
+export function map<A, B>(f: (a: A) => B) {
+  return <R>(ma: Sample<R, A>): Sample<R, B> => {
+    return new Sample(
+      f(ma.value),
+      ma.shrink.map((v) => v.map((sample) => sample.map(f))),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.Sample shrinkSearch
+ * @tsplus pipeable fncts.test.Sample shrinkSearch
  */
-export function shrinkSearch_<R, A>(ma: Sample<R, A>, p: Predicate<A>): Stream<R, never, A> {
-  if (!p(ma.value)) {
-    return Stream.succeedNow(ma.value);
-  } else {
-    return Stream.succeedNow(ma.value).concat(
-      ma.shrink
-        .takeUntil((maybeSample) =>
-          maybeSample.match(
-            () => false,
-            (v) => p(v.value),
-          ),
-        )
-        .flatMap((maybeSample) => maybeSample.map((sample) => sample.shrinkSearch(p)).getOrElse(() => Stream.empty)),
-    );
-  }
+export function shrinkSearch<A>(p: Predicate<A>) {
+  return <R>(ma: Sample<R, A>): Stream<R, never, A> => {
+    if (!p(ma.value)) {
+      return Stream.succeedNow(ma.value);
+    } else {
+      return Stream.succeedNow(ma.value).concat(
+        ma.shrink
+          .takeUntil((maybeSample) =>
+            maybeSample.match(
+              () => false,
+              (v) => p(v.value),
+            ),
+          )
+          .flatMap((maybeSample) => maybeSample.map((sample) => sample.shrinkSearch(p)).getOrElse(() => Stream.empty)),
+      );
+    }
+  };
 }
 
 /**
@@ -102,17 +109,21 @@ export function unfold<R, A, S>(s: S, f: (s: S) => readonly [A, Stream<R, never,
 }
 
 /**
- * @tsplus fluent fncts.test.Sample zip
+ * @tsplus pipeable fncts.test.Sample zip
  */
-export function zip<R, A, R1, B>(ma: Sample<R, A>, mb: Sample<R1, B>): Sample<R | R1, readonly [A, B]> {
-  return ma.zipWith(mb, tuple);
+export function zip<R1, B>(mb: Sample<R1, B>) {
+  return <R, A>(ma: Sample<R, A>): Sample<R | R1, readonly [A, B]> => {
+    return ma.zipWith(mb, tuple);
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.Sample zipWith
+ * @tsplus pipeable fncts.test.Sample zipWith
  */
-export function zipWith_<R, A, R1, B, C>(ma: Sample<R, A>, mb: Sample<R1, B>, f: (a: A, b: B) => C): Sample<R | R1, C> {
-  return ma.flatMap((a) => map_(mb, (b) => f(a, b)));
+export function zipWith<A, R1, B, C>(mb: Sample<R1, B>, f: (a: A, b: B) => C) {
+  return <R>(ma: Sample<R, A>): Sample<R | R1, C> => {
+    return ma.flatMap((a) => mb.map((b) => f(a, b)));
+  };
 }
 
 /**
@@ -245,7 +256,7 @@ export function flatMapStream<R, A, R1, B>(
           )
           .foldLeft(
             Channel.unit as Channel<R1, unknown, unknown, unknown, never, Conc<Either<boolean, B>>, unknown>,
-            (a, b) => a.apSecond(b),
+            (a, b) => a.zipRight(b),
           ),
       constVoid,
       constVoid,