@fncts/io 0.0.20 → 0.0.21

package/_src/IO/api/environment.ts

@@ -1,17 +1,13 @@
-import type * as Intersection from "@fncts/typelevel/Intersection";
-
 /**
  * Provides some of the environment required to run this `IO`,
  * leaving the remainder `R0`.
  *
- * @tsplus fluent fncts.io.IO contramapEnvironment
+ * @tsplus pipeable fncts.io.IO contramapEnvironment
  */
-export function contramapEnvironment_<R0, R, E, A>(
-  self: IO<R, E, A>,
-  f: (r0: Environment<R0>) => Environment<R>,
-  __tsplusTrace?: string,
-): IO<R0, E, A> {
-  return IO.environmentWithIO((r0: Environment<R0>) => self.provideEnvironment(f(r0)));
+export function contramapEnvironment<R0, R>(f: (r0: Environment<R0>) => Environment<R>, __tsplusTrace?: string) {
+  return <E, A>(self: IO<R, E, A>): IO<R0, E, A> => {
+    return IO.environmentWithIO((r0: Environment<R0>) => self.provideEnvironment(f(r0)));
+  };
 }
 
 /**
@@ -50,52 +46,40 @@ export function environmentWithIO<R0, R, E, A>(
  * Provides the `IO` with its required environment, which eliminates
  * its dependency on `R`.
  *
- * @tsplus fluent fncts.io.IO provideEnvironment
+ * @tsplus pipeable fncts.io.IO provideEnvironment
  */
-export function provideEnvironment_<R, E, A>(self: IO<R, E, A>, r: Environment<R>, __tsplusTrace?: string): FIO<E, A> {
-  return FiberRef.currentEnvironment.locallyWith((_) => _.union(r))(self as FIO<E, A>);
+export function provideEnvironment<R>(r: Environment<R>, __tsplusTrace?: string) {
+  return <E, A>(self: IO<R, E, A>): FIO<E, A> => {
+    return FiberRef.currentEnvironment.locallyWith((_) => _.union(r))(self as FIO<E, A>);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.IO provideSomeEnvironment
+ * @tsplus pipeable fncts.io.IO provideSomeEnvironment
  */
-export function provideSomeEnvironment_<R, E, A, R0>(
-  self: IO<R, E, A>,
-  environment: Environment<R0>,
-  __tsplusTrace?: string,
-): IO<Exclude<R, R0>, E, A> {
-  return self.contramapEnvironment((r0) => r0.union(environment));
+export function provideSomeEnvironment<R0>(environment: Environment<R0>, __tsplusTrace?: string) {
+  return <R, E, A>(self: IO<R, E, A>): IO<Exclude<R, R0>, E, A> => {
+    return self.contramapEnvironment((r0) => r0.union(environment));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.IO provideService
+ * @tsplus pipeable fncts.io.IO provideService
  */
-export function provideService_<E, A, T>(
-  self: IO<T, E, A>,
-  service: T,
-  tag: Tag<T>,
-  __tsplusTrace?: string,
-): FIO<E, A> {
-  return self.provideEnvironment(Environment().add(service, tag));
-}
-
-/**
- * @tsplus fluent fncts.io.IO provideSomeService
- */
-export function provideSomeService_<R, E, A, T>(
-  self: IO<R, E, A>,
-  service: T,
-  tag: Tag<T>,
-  __tsplusTrace?: string,
-): IO<Exclude<R, T>, E, A> {
-  return self.contramapEnvironment((r: Environment<Exclude<R, T>>) => r.add(service, tag) as Environment<R>);
+export function provideService<T>(service: T, tag: Tag<T>, __tsplusTrace?: string) {
+  return <E, A>(self: IO<T, E, A>): FIO<E, A> => {
+    return self.provideEnvironment(Environment().add(service, tag));
+  };
 }
 
 /**
+ * @tsplus pipeable fncts.io.IO provideSomeService
  * @tsplus static fncts.io.IOAspects provideSomeService
  */
 export function provideSomeService<T>(service: T, tag: Tag<T>, __tsplusTrace?: string) {
-  return <R, E, A>(io: IO<R | T, E, A>): IO<R, E, A> => io.provideSomeService(service, tag);
+  return <R, E, A>(self: IO<R, E, A>): IO<Exclude<R, T>, E, A> => {
+    return self.contramapEnvironment((r: Environment<Exclude<R, T>>) => r.add(service, tag) as Environment<R>);
+  };
 }
 
 /**
@@ -104,14 +88,12 @@ export function provideSomeService<T>(service: T, tag: Tag<T>, __tsplusTrace?: s
 export function service<T>(tag: Tag<T>, __tsplusTrace?: string): IO<T, never, T> {
   return IO.serviceWithIO(IO.succeedNow, tag);
 }
-
 /**
  * @tsplus static fncts.io.IOOps serviceWith
  */
 export function serviceWith<S, A>(f: (service: S) => A, tag: Tag<S>, __tsplusTrace?: string): IO<S, never, A> {
   return IO.serviceWithIO((s) => IO.succeedNow(f(s)), tag);
 }
-
 /**
  * @tsplus static fncts.io.IOOps serviceWithIO
  */

package/_src/IO/api/foreachC.ts

@@ -16,7 +16,7 @@ import { AtomicNumber } from "@fncts/base/internal/AtomicNumber";
  * @tsplus static fncts.io.IOOps foreachDiscardC
  * @tsplus fluent fncts.Iterable traverseIODiscardC
  */
-export function foreachDiscardC_<R, E, A>(
+export function foreachDiscardC<R, E, A>(
   as: Iterable<A>,
   f: (a: A) => IO<R, E, any>,
   __tsplusTrace?: string,
@@ -38,7 +38,7 @@ export function foreachDiscardC_<R, E, A>(
  * @tsplus static fncts.io.IOOps foreachC
  * @tsplus fluent fncts.Iterable traverseIOC
  */
-export function foreachC_<R, E, A, B>(
+export function foreachC<R, E, A, B>(
   as: Iterable<A>,
   f: (a: A) => IO<R, E, B>,
   __tsplusTrace?: string,
@@ -59,15 +59,12 @@ function foreachConcurrentUnboundedDiscard<R, E, A>(
   return IO.defer(() => {
     const arr  = Array.from(as);
     const size = arr.length;
-
     if (size === 0) {
       return IO.unit;
     }
-
     return IO.uninterruptibleMask(({ restore }) => {
       const future = Future.unsafeMake<void, void>(FiberId.none);
       const ref    = new AtomicNumber(0);
-
       return IO.transplant((graft) =>
         IO.foreach(
           as,
@@ -142,14 +139,21 @@ function foreachConcurrentBoundedDiscard<R, E, A>(
 ): IO<R, E, void> {
   return IO.defer(() => {
     const size =
-      "length" in as && typeof (as as Iterable<A> & { length: unknown })["length"] === "number"
-        ? (as as Iterable<A> & { length: number })["length"]
+      "length" in as &&
+      typeof (
+        as as Iterable<A> & {
+          length: unknown;
+        }
+      )["length"] === "number"
+        ? (
+            as as Iterable<A> & {
+              length: number;
+            }
+          )["length"]
         : as.size;
-
     if (size === 0) {
       return IO.unit;
     }
-
     return Do((Δ) => {
       const queue = Δ(Queue.makeBounded<A>(size));
       Δ(queue.offerAll(as));
@@ -187,10 +191,18 @@ function foreachConcurrentBounded<R, E, A, B>(
 ): IO<R, E, Conc<B>> {
   return IO.defer(() => {
     const size =
-      "length" in as && typeof (as as Iterable<A> & { length: unknown })["length"] === "number"
-        ? (as as Iterable<A> & { length: number })["length"]
+      "length" in as &&
+      typeof (
+        as as Iterable<A> & {
+          length: unknown;
+        }
+      )["length"] === "number"
+        ? (
+            as as Iterable<A> & {
+              length: number;
+            }
+          )["length"]
         : as.size;
-
     if (size === 0) {
       return IO.succeed(Conc.empty());
     }

package/_src/IO/api/foreachExec.ts

@@ -6,7 +6,7 @@
  *
  * @tsplus static fncts.io.IOOps foreachExec
  */
-export function foreachExec_<R, E, A, B>(
+export function foreachExec<R, E, A, B>(
   as: Iterable<A>,
   es: ExecutionStrategy,
   f: (a: A) => IO<R, E, B>,

package/_src/IO/api/forkIn.ts

@@ -2,14 +2,12 @@
  * Forks the workflow in the specified scope. The fiber will be interrupted
  * when the scope is closed.
  *
- * @tsplus fluent fncts.io.IO forkIn
+ * @tsplus pipeable fncts.io.IO forkIn
  */
-export function forkIn_<R, E, A>(
-  self: IO<R, E, A>,
-  scope: Scope,
-  __tsplusTrace?: string,
-): URIO<R, Fiber.Runtime<E, A>> {
-  return IO.uninterruptibleMask(({ restore }) =>
-    restore(self).forkDaemon.tap((fiber) => scope.addFinalizer(fiber.interrupt)),
-  );
+export function forkIn(scope: Scope, __tsplusTrace?: string) {
+  return <R, E, A>(self: IO<R, E, A>): URIO<R, Fiber.Runtime<E, A>> => {
+    return IO.uninterruptibleMask(({ restore }) =>
+      restore(self).forkDaemon.tap((fiber) => scope.addFinalizer(fiber.interrupt)),
+    );
+  };
 }

package/_src/IO/api/fulfill.ts

@@ -3,8 +3,10 @@
  * this effect. Synchronizes interruption, so if this effect is interrupted,
  * the specified promise will be interrupted, too.
  *
- * @tsplus fluent fncts.io.IO fulfill
+ * @tsplus pipeable fncts.io.IO fulfill
  */
-export function fulfill_<R, E, A>(effect: IO<R, E, A>, p: Future<E, A>, __tsplusTrace?: string): IO<R, never, boolean> {
-  return IO.uninterruptibleMask(({ restore }) => restore(effect).result.flatMap((exit) => p.done(exit)));
+export function fulfill<E, A>(p: Future<E, A>, __tsplusTrace?: string) {
+  return <R>(effect: IO<R, E, A>): IO<R, never, boolean> => {
+    return IO.uninterruptibleMask(({ restore }) => restore(effect).result.flatMap((exit) => p.done(exit)));
+  };
 }

package/_src/IO/api/interrupt.ts

@@ -21,21 +21,19 @@ export const interrupt: IO<never, never, never> = IO.fiberId.flatMap(IO.interrup
  * the effect becomes uninterruptible. These changes are compositional, so
  * they only affect regions of the effect.
  *
- * @tsplus fluent fncts.io.IO setInterruptStatus
+ * @tsplus pipeable fncts.io.IO setInterruptStatus
  */
-export function setInterruptStatus_<R, E, A>(
-  self: IO<R, E, A>,
-  flag: InterruptStatus,
-  __tsplusTrace?: string,
-): IO<R, E, A> {
-  return IO.withFiberContext((fiber) => {
-    const b = flag.toBoolean;
-    if (fiber.unsafeIsInterruptible !== b) {
-      fiber.interruptStatus.push(b);
-      fiber.unsafeRestoreInterruptStatus();
-    }
-    return self;
-  });
+export function setInterruptStatus(flag: InterruptStatus, __tsplusTrace?: string) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R, E, A> => {
+    return IO.withFiberContext((fiber) => {
+      const b = flag.toBoolean;
+      if (fiber.unsafeIsInterruptible !== b) {
+        fiber.interruptStatus.push(b);
+        fiber.unsafeRestoreInterruptStatus();
+      }
+      return self;
+    });
+  };
 }
 
 /**
@@ -103,42 +101,41 @@ export function interruptibleMask<R, E, A>(
  * Calls the specified function, and runs the effect it returns, if this
  * effect is interrupted.
  *
- * @tsplus fluent fncts.io.IO onInterrupt
+ * @tsplus pipeable fncts.io.IO onInterrupt
  */
-export function onInterrupt_<R, E, A, R1>(
-  ma: IO<R, E, A>,
+export function onInterrupt_<R1>(
   cleanup: (interruptors: HashSet<FiberId>) => IO<R1, never, any>,
   __tsplusTrace?: string,
-): IO<R | R1, E, A> {
-  return uninterruptibleMask(({ restore }) =>
-    restore(ma).matchCauseIO(
-      (cause) =>
-        cause.interrupted ? cleanup(cause.interruptors).apSecond(IO.failCauseNow(cause)) : IO.failCauseNow(cause),
-      IO.succeedNow,
-    ),
-  );
+) {
+  return <R, E, A>(ma: IO<R, E, A>): IO<R | R1, E, A> => {
+    return uninterruptibleMask(({ restore }) =>
+      restore(ma).matchCauseIO(
+        (cause) =>
+          cause.interrupted ? cleanup(cause.interruptors).apSecond(IO.failCauseNow(cause)) : IO.failCauseNow(cause),
+        IO.succeedNow,
+      ),
+    );
+  };
 }
 
 /**
  * Calls the specified function, and runs the effect it returns, if this
  * effect is interrupted (allows for expanding error).
  *
- * @tsplus fluent fncts.io.IO onInterruptExtended
+ * @tsplus pipeable fncts.io.IO onInterruptExtended
  */
-export function onInterruptExtended_<R, E, A, R2, E2>(
-  self: IO<R, E, A>,
-  cleanup: Lazy<IO<R2, E2, any>>,
-  __tsplusTrace?: string,
-): IO<R | R2, E | E2, A> {
-  return uninterruptibleMask(({ restore }) =>
-    restore(self).matchCauseIO(
-      (cause) =>
-        cause.interrupted
-          ? cleanup().matchCauseIO(IO.failCauseNow, () => IO.failCauseNow(cause))
-          : IO.failCauseNow(cause),
-      IO.succeedNow,
-    ),
-  );
+export function onInterruptExtended_<R2, E2>(cleanup: Lazy<IO<R2, E2, any>>, __tsplusTrace?: string) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R | R2, E | E2, A> => {
+    return uninterruptibleMask(({ restore }) =>
+      restore(self).matchCauseIO(
+        (cause) =>
+          cause.interrupted
+            ? cleanup().matchCauseIO(IO.failCauseNow, () => IO.failCauseNow(cause))
+            : IO.failCauseNow(cause),
+        IO.succeedNow,
+      ),
+    );
+  };
 }
 
 /**

package/_src/IO/api/onExit.ts

@@ -1,13 +1,11 @@
 /**
- * @tsplus fluent fncts.io.IO onExit
+ * @tsplus pipeable fncts.io.IO onExit
  */
-export function onExit_<R, E, A, R1, E1>(
-  self: IO<R, E, A>,
-  cleanup: (exit: Exit<E, A>) => IO<R1, E1, any>,
-  __tsplusTrace?: string,
-): IO<R | R1, E | E1, A> {
-  return IO.unit.bracketExit(
-    () => self,
-    (_, exit) => cleanup(exit),
-  );
+export function onExit<E, A, R1, E1>(cleanup: (exit: Exit<E, A>) => IO<R1, E1, any>, __tsplusTrace?: string) {
+  return <R>(self: IO<R, E, A>): IO<R | R1, E | E1, A> => {
+    return IO.unit.bracketExit(
+      () => self,
+      (_, exit) => cleanup(exit),
+    );
+  };
 }

package/_src/IO/api/onTermination.ts

@@ -1,17 +1,15 @@
 /**
- * @tsplus fluent fncts.io.IO onTermination
+ * @tsplus pipeable fncts.io.IO onTermination
  */
-export function onTermination<R, E, A, R1>(
-  self: Lazy<IO<R, E, A>>,
-  cleanup: (cause: Cause<never>) => URIO<R1, any>,
-  __tsplusTrace?: string,
-): IO<R | R1, E, A> {
-  return IO.unit.bracketExit(
-    () => self(),
-    (_, exit: Exit<E, A>) =>
-      exit.match(
-        (cause) => cause.failureOrCause.match(() => IO.unit, cleanup),
-        () => IO.unit,
-      ),
-  );
+export function onTermination<R1>(cleanup: (cause: Cause<never>) => URIO<R1, any>, __tsplusTrace?: string) {
+  return <R, E, A>(self: Lazy<IO<R, E, A>>): IO<R | R1, E, A> => {
+    return IO.unit.bracketExit(
+      () => self(),
+      (_, exit: Exit<E, A>) =>
+        exit.match(
+          (cause) => cause.failureOrCause.match(() => IO.unit, cleanup),
+          () => IO.unit,
+        ),
+    );
+  };
 }

package/_src/IO/api/provideLayer.ts

@@ -1,13 +1,11 @@
 /**
- * @tsplus fluent fncts.io.IO provideLayer
+ * @tsplus pipeable fncts.io.IO provideLayer
  */
-export function provideLayer_<RIn, E, ROut, E1, A>(
-  self: IO<ROut, E1, A>,
-  layer: Layer<RIn, E, ROut>,
-  __tsplusTrace?: string,
-): IO<RIn, E | E1, A> {
-  return Scope.make.bracketExit(
-    (scope) => layer.build(scope).flatMap((r) => self.provideEnvironment(r)),
-    (scope, exit) => scope.close(exit),
-  );
+export function provideLayer<RIn, E, ROut>(layer: Layer<RIn, E, ROut>, __tsplusTrace?: string) {
+  return <E1, A>(self: IO<ROut, E1, A>): IO<RIn, E | E1, A> => {
+    return Scope.make.bracketExit(
+      (scope) => layer.build(scope).flatMap((r) => self.provideEnvironment(r)),
+      (scope, exit) => scope.close(exit),
+    );
+  };
 }

package/_src/IO/api/provideSomeLayer.ts

@@ -1,21 +1,12 @@
 import type { Spreadable } from "@fncts/base/types";
 import type { Erase } from "@fncts/typelevel/Intersection";
-
-/**
- * @tsplus fluent fncts.io.IO provideSomeLayer
- */
-export function provideSomeLayer_<R, E, A, RIn, E1, ROut>(
-  self: IO<R, E, A>,
-  layer: Layer<RIn, E1, ROut>,
-  __tsplusTrace?: string,
-): IO<RIn & Erase<R, ROut>, E | E1, A> {
-  // @ts-expect-error
-  return self.provideLayer(Layer.environment<RIn>().and(layer));
-}
-
 /**
  * @tsplus static fncts.io.IOAspects provideSomeLayer
+ * @tsplus pipeable fncts.io.IO provideSomeLayer
  */
 export function provideSomeLayer<RIn, E1, ROut>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string) {
-  return <R, E, A>(self: IO<R | ROut, E, A>): IO<R | RIn, E | E1, A> => self.provideSomeLayer(layer);
+  return <R, E, A>(self: IO<R, E, A>): IO<RIn & Erase<R, ROut>, E | E1, A> => {
+    // @ts-expect-error
+    return self.provideLayer(Layer.environment<RIn>().and(layer));
+  };
 }

package/_src/IO/api/race.ts

@@ -11,26 +11,24 @@ function maybeDisconnect<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R
  * WARNING: The raced effect will safely interrupt the "loser", but will not
  * resume until the loser has been cleanly terminated.
  *
- * @tsplus fluent fncts.io.IO race
+ * @tsplus pipeable fncts.io.IO race
  */
-export function race_<R, E, A, R1, E1, A1>(
-  io: IO<R, E, A>,
-  that: IO<R1, E1, A1>,
-  __tsplusTrace?: string,
-): IO<R | R1, E | E1, A | A1> {
-  return IO.descriptorWith((descriptor) =>
-    maybeDisconnect(io).raceWith(
-      maybeDisconnect(that),
-      (exit, right) =>
-        exit.match(
-          (cause) => right.join.mapErrorCause((c) => Cause.both(cause, c)),
-          (a) => right.interruptAs(descriptor.id).as(a),
-        ),
-      (exit, left) =>
-        exit.match(
-          (cause) => left.join.mapErrorCause((c) => Cause.both(cause, c)),
-          (a1) => left.interruptAs(descriptor.id).as(a1),
-        ),
-    ),
-  );
+export function race<R1, E1, A1>(that: IO<R1, E1, A1>, __tsplusTrace?: string) {
+  return <R, E, A>(io: IO<R, E, A>): IO<R | R1, E | E1, A | A1> => {
+    return IO.descriptorWith((descriptor) =>
+      maybeDisconnect(io).raceWith(
+        maybeDisconnect(that),
+        (exit, right) =>
+          exit.match(
+            (cause) => right.join.mapErrorCause((c) => Cause.both(cause, c)),
+            (a) => right.interruptAs(descriptor.id).as(a),
+          ),
+        (exit, left) =>
+          exit.match(
+            (cause) => left.join.mapErrorCause((c) => Cause.both(cause, c)),
+            (a1) => left.interruptAs(descriptor.id).as(a1),
+          ),
+      ),
+    );
+  };
 }

package/_src/IO/api/raceFirst.ts

@@ -10,12 +10,10 @@
  * interrupt signal, allowing a fast return, with interruption performed
  * in the background.
  *
- * @tsplus fluent fncts.io.IO raceFirst
+ * @tsplus pipeable fncts.io.IO raceFirst
  */
-export function raceFirst_<R, E, A, R1, E1, A1>(
-  ma: IO<R, E, A>,
-  that: IO<R1, E1, A1>,
-  __tsplusTrace?: string,
-): IO<R | R1, E | E1, A | A1> {
-  return ma.result.race(that.result).flatMap((exit) => IO.fromExitNow<E | E1, A | A1>(exit));
+export function raceFirst<R1, E1, A1>(that: IO<R1, E1, A1>, __tsplusTrace?: string) {
+  return <R, E, A>(ma: IO<R, E, A>): IO<R | R1, E | E1, A | A1> => {
+    return ma.result.race(that.result).flatMap((exit) => IO.fromExitNow<E | E1, A | A1>(exit));
+  };
 }

package/_src/IO/api/repeat.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus getter fncts.io.IO repeat
  */
-export function repeat_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
+export function repeat<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
   return <R1, B>(schedule0: Lazy<Schedule<R1, A, B>>, __tsplusTrace?: string): IO<R | R1, E, B> =>
     self.repeatOrElse(schedule0, (e, _) => IO.fail(e));
 }
@@ -9,7 +9,7 @@ export function repeat_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
 /**
  * @tsplus getter fncts.io.IO repeatOrElse
  */
-export function repeatOrElse_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
+export function repeatOrElse<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
   return <R1, B, R2, E2>(
     schedule0: Lazy<Schedule<R1, A, B>>,
     orElse: (e: E, out: Maybe<B>) => IO<R2, E2, B>,
@@ -20,7 +20,7 @@ export function repeatOrElse_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string
 /**
  * @tsplus getter fncts.io.IO repeatOrElseEither
  */
-export function repeatOrElseEither_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
+export function repeatOrElseEither<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
   return <R1, B, R2, E2, C>(
     schedule0: Lazy<Schedule<R1, A, B>>,
     orElse: (e: E, out: Maybe<B>) => IO<R2, E2, C>,
@@ -28,7 +28,6 @@ export function repeatOrElseEither_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?:
   ): IO<R | R1 | R2, E2, Either<C, B>> =>
     IO.defer(() => {
       const schedule = schedule0();
-
       return schedule.driver.flatMap((driver) => {
         const loop = (a: A): IO<R | R1 | R2, E2, Either<C, B>> =>
           driver.next(a).matchIO(
@@ -39,7 +38,6 @@ export function repeatOrElseEither_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?:
                 (a) => loop(a),
               ),
           );
-
         return self.matchIO(
           (e) => orElse(e, Nothing()).map(Either.left),
           (a) => loop(a),

package/_src/IO/api/retry.ts

@@ -1,42 +1,40 @@
 /**
- * @tsplus getter fncts.io.IO retry
+ * @tsplus pipeable fncts.io.IO retry
  */
-export function retry<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
-  return <R1, O>(schedule0: Lazy<Schedule<R1, E, O>>, __tsplusTrace?: string): IO<R | R1, E, A> =>
-    self.retryOrElse(schedule0, (e, _) => IO.fail(e));
+export function retry<R1, E, O>(schedule0: Lazy<Schedule<R1, E, O>>, __tsplusTrace?: string) {
+  return <R, A>(self: IO<R, E, A>): IO<R | R1, E, A> => self.retryOrElse(schedule0, (e, _) => IO.fail(e));
 }
 
 /**
- * @tsplus getter fncts.io.IO retryOrElse
+ * @tsplus pipeable fncts.io.IO retryOrElse
  */
-export function retryOrElse<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
-  return <R1, O, R2, E2>(
-    schedule0: Lazy<Schedule<R1, E, O>>,
-    orElse: (e: E, out: O) => IO<R2, E2, A>,
-    __tsplusTrace?: string,
-  ): IO<R | R1 | R2, E2, A> => self.retryOrElseEither(schedule0, orElse).map((_) => _.value);
+export function retryOrElse<E, A, R1, O, R2, E2>(
+  schedule0: Lazy<Schedule<R1, E, O>>,
+  orElse: (e: E, out: O) => IO<R2, E2, A>,
+  __tsplusTrace?: string,
+) {
+  return <R>(self: IO<R, E, A>): IO<R | R1 | R2, E2, A> =>
+    self.retryOrElseEither(schedule0, orElse).map((_) => _.value);
 }
 
 /**
- * @tsplus getter fncts.io.IO retryOrElseEither
+ * @tsplus pipeable fncts.io.IO retryOrElseEither
  */
-export function retryOrElseEither_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
-  return <R1, O, R2, E2, B>(
-    schedule0: Lazy<Schedule<R1, E, O>>,
-    orElse: (e: E, out: O) => IO<R2, E2, B>,
-    __tsplusTrace?: string,
-  ): IO<R | R1 | R2, E2, Either<B, A>> =>
+export function retryOrElseEither<E, R1, O, R2, E2, B>(
+  schedule0: Lazy<Schedule<R1, E, O>>,
+  orElse: (e: E, out: O) => IO<R2, E2, B>,
+  __tsplusTrace?: string,
+) {
+  return <R, A>(self: IO<R, E, A>): IO<R | R1 | R2, E2, Either<B, A>> =>
     IO.defer(() => {
       const schedule = schedule0();
-
-      const loop = (driver: Schedule.Driver<unknown, R1, E, O>): IO<R | R1 | R2, E2, Either<B, A>> =>
+      const loop     = (driver: Schedule.Driver<unknown, R1, E, O>): IO<R | R1 | R2, E2, Either<B, A>> =>
         self.map(Either.right).catchAll((e) =>
           driver.next(e).matchIO(
             () => driver.last.orHalt.flatMap((out) => orElse(e, out).map(Either.left)),
             () => loop(driver),
           ),
         );
-
       return schedule.driver.flatMap(loop);
     });
 }