@fncts/io 0.0.47 → 0.0.49

package/_src/IO/api.ts

@@ -3,6 +3,7 @@ import type { ShowOptions } from "@fncts/base/data/Showable.js";
 import type * as P from "@fncts/base/typeclass";
 import type { _E, _R } from "@fncts/base/types";
 import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
+import type { WhileLoop } from "@fncts/io/IO/definition";
 import type { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 
 import { IOError } from "@fncts/base/data/exceptions";
@@ -11,23 +12,6 @@ import { showWithOptions } from "@fncts/base/data/Showable";
 import { IOPrimitive, IOTag } from "@fncts/io/IO/definition";
 import { IO } from "@fncts/io/IO/definition";
 
-/**
- * Imports an asynchronous side-effect into a `IO`
- *
- * @tsplus static fncts.io.IOOps async
- */
-export function async<R, E, A>(
-  register: (resolve: (_: IO<R, E, A>) => void) => void,
-  blockingOn: FiberId = FiberId.none,
-  __tsplusTrace?: string,
-): IO<R, E, A> {
-  const io = new IOPrimitive(IOTag.Async) as any;
-  io.i0    = register;
-  io.i1    = () => blockingOn;
-  io.trace = __tsplusTrace;
-  return io;
-}
-
 /**
  * Attempts to convert defects into a failure, throwing away all information
  * about the cause of the failure.
@@ -39,28 +23,6 @@ export function absorbWith<R, E, A>(f: (e: E) => unknown, __tsplusTrace?: string
     ma.sandbox.matchIO((cause) => IO.failNow(cause.squashWith(f)), IO.succeedNow);
 }
 
-/**
- * @tsplus pipeable fncts.io.IO zipLeft
- * @tsplus pipeable-operator fncts.io.IO <
- */
-export function zipLeft<R1, E1, B>(fb: IO<R1, E1, B>, __tsplusTrace?: string) {
-  return <R, E, A>(self: IO<R, E, A>): IO<R1 | R, E1 | E, A> => {
-    return self.flatMap((a) => fb.map(() => a));
-  };
-}
-
-/**
- * Combine two effectful actions, keeping only the result of the second
- *
- * @tsplus pipeable fncts.io.IO zipRight
- * @tsplus pipeable-operator fncts.io.IO >
- */
-export function zipRight<R1, E1, B>(fb: IO<R1, E1, B>, __tsplusTrace?: string) {
-  return <R, E, A>(self: IO<R, E, A>): IO<R1 | R, E1 | E, B> => {
-    return self.flatMap(() => fb);
-  };
-}
-
 /**
  * @tsplus pipeable fncts.io.IO as
  */
@@ -75,8 +37,8 @@ export function as<B>(b: Lazy<B>, __tsplusTrace?: string) {
  *
  * @tsplus getter fncts.io.IO asJust
  */
-export function asJust<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, Maybe<A>> {
-  return ma.map(Maybe.just);
+export function asJust<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, Maybe<A>> {
+  return self.map(Maybe.just);
 }
 
 /**
@@ -84,8 +46,8 @@ export function asJust<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R,
  *
  * @tsplus getter fncts.io.IO asJustError
  */
-export function asJustError<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, Maybe<E>, A> {
-  return ma.mapError(Maybe.just);
+export function asJustError<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, Maybe<E>, A> {
+  return self.mapError(Maybe.just);
 }
 
 /**
@@ -95,17 +57,34 @@ export function asUnit<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R
   return self.as(undefined);
 }
 
+/**
+ * Imports an asynchronous side-effect into a `IO`
+ *
+ * @tsplus static fncts.io.IOOps async
+ */
+export function async<R, E, A>(
+  register: (resolve: (_: IO<R, E, A>) => void) => void,
+  blockingOn: FiberId = FiberId.none,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
+  const io = new IOPrimitive(IOTag.Async) as any;
+  io.i0    = register;
+  io.i1    = () => blockingOn;
+  io.trace = __tsplusTrace;
+  return io;
+}
+
 /**
  * Returns an IO whose failure and success channels have been mapped by
  * the specified pair of functions, `f` and `g`.
  *
  * @tsplus pipeable fncts.io.IO bimap
  */
-export function bimap<E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B, __tsplusTrace?: string) {
+export function bimap<E, A, E1, B>(onFailure: (e: E) => E1, onSuccess: (a: A) => B, __tsplusTrace?: string) {
   return <R>(self: IO<R, E, A>): IO<R, E1, B> => {
     return self.matchIO(
-      (e) => IO.failNow(f(e)),
-      (a) => IO.succeedNow(g(a)),
+      (e) => IO.failNow(onFailure(e)),
+      (a) => IO.succeedNow(onSuccess(a)),
     );
   };
 }
@@ -133,54 +112,14 @@ export function bitap<E, A, R1, E1, R2, E2>(
   };
 }
 
-/**
- * Recovers from the specified error
- *
- * @tsplus pipeable fncts.io.IO catch
- */
-export function catchTagWith<N extends keyof E, K extends E[N] & string, E, R1, E1, A1>(
-  tag: N,
-  k: K,
-  f: (
-    e: Extract<
-      E,
-      {
-        [n in N]: K;
-      }
-    >,
-  ) => IO<R1, E1, A1>,
-  __tsplusTrace?: string,
-) {
-  return <R, A>(
-    ma: IO<R, E, A>,
-  ): IO<
-    R | R1,
-    | Exclude<
-        E,
-        {
-          [n in N]: K;
-        }
-      >
-    | E1,
-    A | A1
-  > => {
-    return ma.catchAll((e) => {
-      if (isObject(e) && tag in e && e[tag] === k) {
-        return f(e as any);
-      }
-      return IO.failNow(e as any);
-    });
-  };
-}
-
 /**
  * Recovers from all errors
  *
  * @tsplus pipeable fncts.io.IO catchAll
  */
-export function catchAll<E, R1, E1, A1>(f: (e: E) => IO<R1, E1, A1>, __tsplusTrace?: string) {
-  return <R, A>(ma: IO<R, E, A>): IO<R | R1, E1, A | A1> => {
-    return ma.matchIO(f, IO.succeedNow);
+export function catchAll<E, R1, E1, A1>(onFailure: (e: E) => IO<R1, E1, A1>, __tsplusTrace?: string) {
+  return <R, A>(self: IO<R, E, A>): IO<R | R1, E1, A | A1> => {
+    return self.matchIO(onFailure, IO.succeedNow);
   };
 }
 
@@ -190,8 +129,8 @@ export function catchAll<E, R1, E1, A1>(f: (e: E) => IO<R1, E1, A1>, __tsplusTra
  *
  * @tsplus pipeable fncts.io.IO catchAllCause
  */
-export function catchAllCause<R, E, A, R1, E1, A1>(f: (_: Cause<E>) => IO<R1, E1, A1>, __tsplusTrace?: string) {
-  return (ma: IO<R, E, A>): IO<R | R1, E1, A | A1> => ma.matchCauseIO(f, IO.succeedNow);
+export function catchAllCause<R, E, A, R1, E1, A1>(onFailure: (_: Cause<E>) => IO<R1, E1, A1>, __tsplusTrace?: string) {
+  return (self: IO<R, E, A>): IO<R | R1, E1, A | A1> => self.matchCauseIO(onFailure, IO.succeedNow);
 }
 
 /**
@@ -199,10 +138,10 @@ export function catchAllCause<R, E, A, R1, E1, A1>(f: (_: Cause<E>) => IO<R1, E1
  *
  * @tsplus pipeable fncts.io.IO catchJust
  */
-export function catchJust<E, R1, E1, A1>(f: (e: E) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string) {
-  return <R, A>(ma: IO<R, E, A>): IO<R | R1, E | E1, A | A1> => {
-    return ma.matchCauseIO(
-      (cause) => cause.failureOrCause.match((e) => f(e).getOrElse(IO.failCauseNow(cause)), IO.failCauseNow),
+export function catchJust<E, R1, E1, A1>(onFailure: (e: E) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string) {
+  return <R, A>(self: IO<R, E, A>): IO<R | R1, E | E1, A | A1> => {
+    return self.matchCauseIO(
+      (cause) => cause.failureOrCause.match((e) => onFailure(e).getOrElse(IO.failCauseNow(cause)), IO.failCauseNow),
       IO.succeedNow,
     );
   };
@@ -213,9 +152,12 @@ export function catchJust<E, R1, E1, A1>(f: (e: E) => Maybe<IO<R1, E1, A1>>, __t
  *
  * @tsplus pipeable fncts.io.IO catchJustCause
  */
-export function catchJustCause<E, R1, E1, A1>(f: (_: Cause<E>) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string) {
-  return <R, A>(ma: IO<R, E, A>): IO<R | R1, E | E1, A | A1> => {
-    return ma.matchCauseIO((cause) => f(cause).getOrElse(IO.failCauseNow(cause)), IO.succeedNow);
+export function catchJustCause<E, R1, E1, A1>(
+  onFailure: (_: Cause<E>) => Maybe<IO<R1, E1, A1>>,
+  __tsplusTrace?: string,
+) {
+  return <R, A>(self: IO<R, E, A>): IO<R | R1, E | E1, A | A1> => {
+    return self.matchCauseIO((cause) => onFailure(cause).getOrElse(IO.failCauseNow(cause)), IO.succeedNow);
   };
 }
 
@@ -229,9 +171,9 @@ export function catchJustCause<E, R1, E1, A1>(f: (_: Cause<E>) => Maybe<IO<R1, E
  *
  * @tsplus pipeable fncts.io.IO catchJustDefect
  */
-export function catchJustDefect<R1, E1, A1>(f: (_: unknown) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string) {
-  return <R, E, A>(ma: IO<R, E, A>): IO<R | R1, E | E1, A | A1> => {
-    return ma.unrefineWith(f, IO.failNow).catchAll((a) => a as IO<R | R1, E | E1, A | A1>);
+export function catchJustDefect<R1, E1, A1>(onFailure: (_: unknown) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E | E1, A | A1> => {
+    return self.unrefineWith(onFailure, IO.failNow).catchAll((a) => a as IO<R | R1, E | E1, A | A1>);
   };
 }
 
@@ -240,56 +182,50 @@ export function catchJustDefect<R1, E1, A1>(f: (_: unknown) => Maybe<IO<R1, E1,
  *
  * @tsplus pipeable IO catchTag
  */
-export function catchTag<
-  K extends E["_tag"] & string,
-  E extends {
-    _tag: string;
-  },
-  R1,
-  E1,
-  A1,
->(
-  k: K,
-  f: (
-    e: Extract<
-      E,
-      {
-        _tag: K;
-      }
-    >,
-  ) => IO<R1, E1, A1>,
+export function catchTag<T extends E["_tag"] & string, E extends { _tag: string }, R1, E1, A1>(
+  tag: T,
+  onFailure: (e: Extract<E, { _tag: T }>) => IO<R1, E1, A1>,
   __tsplusTrace?: string,
 ) {
-  return <R, A>(
-    ma: IO<R, E, A>,
-  ): IO<
-    R | R1,
-    | Exclude<
-        E,
-        {
-          _tag: K;
-        }
-      >
-    | E1,
-    A | A1
-  > => {
-    return ma.catch("_tag", k, f);
+  return <R, A>(self: IO<R, E, A>): IO<R | R1, Exclude<E, { _tag: T }> | E1, A | A1> => {
+    return self.catch("_tag", tag, onFailure);
+  };
+}
+
+/**
+ * Recovers from the specified error
+ *
+ * @tsplus pipeable fncts.io.IO catch
+ */
+export function catchTagWith<K extends keyof E, T extends E[K] & string, E, R1, E1, A1>(
+  tagKey: K,
+  tag: T,
+  onFailure: (e: Extract<E, { [n in K]: T }>) => IO<R1, E1, A1>,
+  __tsplusTrace?: string,
+) {
+  return <R, A>(self: IO<R, E, A>): IO<R | R1, Exclude<E, { [n in K]: T }> | E1, A | A1> => {
+    return self.catchAll((e) => {
+      if (isObject(e) && tagKey in e && e[tagKey] === tag) {
+        return onFailure(e as any);
+      }
+      return IO.failNow(e as any);
+    });
   };
 }
 
 /**
  * @tsplus getter fncts.io.IO cause
  */
-export function cause<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, Cause<E>> {
-  return ma.matchCauseIO(IO.succeedNow, () => IO.succeedNow(Cause.empty()));
+export function cause<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, Cause<E>> {
+  return self.matchCauseIO(IO.succeedNow, () => IO.succeedNow(Cause.empty()));
 }
 
 /**
  * @tsplus pipeable fncts.io.IO causeAsError
  */
 export function causeAsError(__tsplusTrace?: string) {
-  return <R, E, A>(ma: IO<R, E, A>): IO<R, Cause<E>, A> => {
-    return ma.matchCauseIO(IO.failNow, IO.succeedNow);
+  return <R, E, A>(self: IO<R, E, A>): IO<R, Cause<E>, A> => {
+    return self.matchCauseIO(IO.failNow, IO.succeedNow);
   };
 }
 
@@ -307,48 +243,37 @@ export function checkInterruptible<R, E, A>(
 }
 
 /**
- * Returns an IO that models the execution of this effect, followed by
- * the passing of its value to the specified continuation function `f`,
- * followed by the effect that it returns.
- *
- * @tsplus pipeable fncts.io.IO flatMap
- */
-export function flatMap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string) {
-  return <R, E>(ma: IO<R, E, A>): IO<R | R1, E | E1, B> => {
-    const io = new IOPrimitive(IOTag.OnSuccess) as any;
-    io.i0    = ma;
-    io.i1    = f;
-    io.trace = __tsplusTrace;
-
-    return io;
-  };
-}
-
-/**
- * @tsplus pipeable fncts.io.IO flatMapError
+ * @tsplus pipeable fncts.io.IO collect
  */
-export function flatMapError<R1, E, E1>(f: (e: E) => IO<R1, never, E1>, __tsplusTrace?: string) {
-  return <R, A>(ma: IO<R, E, A>): IO<R | R1, E1, A> => {
-    return ma.swapWith((effect) => effect.flatMap(f));
+export function collect<A, E1, A1>(f: Lazy<E1>, pf: (a: A) => Maybe<A1>, __tsplusTrace?: string) {
+  return <R, E>(self: IO<R, E, A>): IO<R, E | E1, A1> => {
+    return self.collectIO(f, (a) => pf(a).map(IO.succeedNow));
   };
 }
 
 /**
- * @tsplus pipeable fncts.io.IO collect
+ * @tsplus pipeable fncts.io.IO collectIO
  */
-export function collect<A, E1, A1>(f: Lazy<E1>, pf: (a: A) => Maybe<A1>, __tsplusTrace?: string) {
-  return <R, E>(ma: IO<R, E, A>): IO<R, E | E1, A1> => {
-    return ma.collectIO(f, (a) => pf(a).map(IO.succeedNow));
+export function collectIO<A, R1, E1, A1, E2>(
+  onNothing: Lazy<E2>,
+  pf: (a: A) => Maybe<IO<R1, E1, A1>>,
+  __tsplusTrace?: string,
+) {
+  return <R, E>(self: IO<R, E, A>): IO<R | R1, E | E1 | E2, A1> => {
+    return self.flatMap((a) => pf(a).getOrElse(IO.fail(onNothing)));
   };
 }
 
 /**
- * @tsplus pipeable fncts.io.IO collectIO
+ * @tsplus static fncts.io.IOOps if
  */
-export function collectIO<A, R1, E1, A1, E2>(f: Lazy<E2>, pf: (a: A) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string) {
-  return <R, E>(ma: IO<R, E, A>): IO<R | R1, E | E1 | E2, A1> => {
-    return ma.flatMap((a) => pf(a).getOrElse(IO.fail(f)));
-  };
+export function cond<R, E, A, R1, E1, A1>(
+  b: boolean,
+  onTrue: Lazy<IO<R, E, A>>,
+  onFalse: Lazy<IO<R1, E1, A1>>,
+  __tsplusTrace?: string,
+): IO<R | R1, E | E1, A | A1> {
+  return IO.succeedNow(b).ifIO(onTrue, onFalse);
 }
 
 /**
@@ -372,7 +297,12 @@ export function condIO<R, R1, E, A>(
  * @tsplus static fncts.io.IOOps defer
  */
 export function defer<R = never, E = never, A = never>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, A> {
-  return IO.succeed(io).flatMap(identity);
+  const out = new IOPrimitive(IOTag.OnSuccess) as any;
+  out.i0    = IO.unit;
+  out.i1    = io;
+  out.trace = __tsplusTrace;
+
+  return out;
 }
 
 /**
@@ -382,7 +312,7 @@ export function defer<R = never, E = never, A = never>(io: Lazy<IO<R, E, A>>, __
  * @tsplus static fncts.io.IOOps deferTry
  */
 export function deferTry<R = never, E = never, A = never>(
-  io: () => IO<R, E, A>,
+  io: Lazy<IO<R, E, A>>,
   __tsplusTrace?: string,
 ): IO<R, unknown, A> {
   return IO.defer(() => {
@@ -403,7 +333,7 @@ export function deferTry<R = never, E = never, A = never>(
  * @tsplus static IOOps deferTryCatch
  */
 export function deferTryCatch<R, E, A, E1>(
-  io: () => IO<R, E, A>,
+  io: Lazy<IO<R, E, A>>,
   onThrow: (error: unknown) => E1,
   __tsplusTrace?: string,
 ): IO<R, E | E1, A> {
@@ -421,57 +351,61 @@ export function deferTryCatch<R, E, A, E1>(
  *
  * @tsplus getter fncts.io.IO either
  */
-export function either<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R, Either<E, A>> {
-  return ma.match(Either.left, Either.right);
+export function either<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): URIO<R, Either<E, A>> {
+  return self.match(Either.left, Either.right);
 }
 
 /**
  * @tsplus pipeable fncts.io.IO errorAsCause
  */
 export function errorAsCause(__tsplusTrace?: string) {
-  return <R, E, A>(ma: IO<R, Cause<E>, A>): IO<R, E, A> => {
-    return ma.matchIO(IO.failCauseNow, IO.succeedNow);
+  return <R, E, A>(self: IO<R, Cause<E>, A>): IO<R, E, A> => {
+    return self.matchIO(IO.failCauseNow, IO.succeedNow);
   };
 }
 
 /**
  * @tsplus getter fncts.io.IO eventually
  */
-export function eventually<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, A> {
-  return ma.orElse(ma.eventually);
+export function eventually<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, A> {
+  return self.orElse(self.eventually);
 }
 
 /**
- * @tsplus pipeable fncts.io.IO extend
+ * @tsplus pipeable fncts.io.IO exitWith
  */
-export function extend<R, E, A, B>(f: (wa: IO<R, E, A>) => B, __tsplusTrace?: string) {
-  return (wa: IO<R, E, A>): IO<R, E, B> => {
-    return wa.matchIO(IO.failNow, (_) => IO.succeed(f(wa)));
+export function exitWith<E, A, R1, E1, B>(f: (exit: Exit<E, A>) => IO<R1, E1, B>, __tsplusTrace?: string) {
+  return <R>(self: IO<R, E, A>): IO<R | R1, E1, B> => {
+    return self.matchCauseIO(
+      (cause) => f(Exit.failCause(cause)),
+      (a) => f(Exit.succeed(a)),
+    );
   };
 }
 
 /**
- * @tsplus static fncts.io.IOOps fail
+ * @tsplus pipeable fncts.io.IO extend
  */
-export function fail<E>(e: Lazy<E>, __tsplusTrace?: string): FIO<E, never> {
-  return IO.failCause(Cause.fail(e()));
+export function extend<R, E, A, B>(f: (io: IO<R, E, A>) => B, __tsplusTrace?: string) {
+  return (self: IO<R, E, A>): IO<R, E, B> => {
+    return self.matchIO(IO.failNow, (_) => IO.succeed(f(self)));
+  };
 }
 
 /**
- * @tsplus static fncts.io.IOOps failNow
+ * @tsplus static fncts.io.IOOps fail
  */
-export function failNow<E>(e: E, __tsplusTrace?: string): FIO<E, never> {
-  return IO.failCause(Cause.fail(e));
+export function fail<E>(e: Lazy<E>, __tsplusTrace?: string): FIO<E, never> {
+  return IO.failCause(Cause.fail(e()));
 }
 
 /**
- * @tsplus static fncts.io.IOOps refailCause
+ * Returns an effect that models failure with the specified lazily-evaluated `Cause`.
+ *
+ * @tsplus static fncts.io.IOOps failCause
  */
-export function refailCause<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E, never> {
-  const io = new IOPrimitive(IOTag.Fail) as any;
-  io.i0    = () => cause;
-  io.trace = __tsplusTrace;
-  return io;
+export function failCause<E = never, A = never>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): FIO<E, A> {
+  return IO.stackTrace(__tsplusTrace).flatMap((trace) => IO.refailCause(Cause.traced(cause(), trace)));
 }
 
 /**
@@ -487,12 +421,10 @@ export function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E,
 }
 
 /**
- * Returns an effect that models failure with the specified lazily-evaluated `Cause`.
- *
- * @tsplus static fncts.io.IOOps failCause
+ * @tsplus static fncts.io.IOOps failNow
  */
-export function failCause<E = never, A = never>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): FIO<E, A> {
-  return IO.stackTrace(__tsplusTrace).flatMap((trace) => IO.refailCause(Cause.traced(cause(), trace)));
+export function failNow<E>(e: E, __tsplusTrace?: string): FIO<E, never> {
+  return IO.failCause(Cause.fail(e));
 }
 
 /**
@@ -586,11 +518,13 @@ export function filterOrElse<A, B extends A, R1, E1, A1>(
   or: (a: Exclude<A, B>) => IO<R1, E1, A1>,
   __tsplusTrace?: string,
 ): <R, E>(fa: IO<R, E, A>) => IO<R | R1, E | E1, B | A1>;
+
 export function filterOrElse<A, R1, E1, A1>(
   predicate: Predicate<A>,
   or: (a: A) => IO<R1, E1, A1>,
   __tsplusTrace?: string,
 ): <R, E>(fa: IO<R, E, A>) => IO<R | R1, E | E1, A | A1>;
+
 export function filterOrElse<A>(predicate: Predicate<A>, or: unknown, __tsplusTrace?: string) {
   return <R, E, R1, E1, A1>(fa: IO<R, E, A>): IO<R | R1, E | E1, A | A1> => {
     return fa.flatMap(
@@ -608,26 +542,17 @@ export function filterOrFail<A, B extends A, E1>(
   refinement: Refinement<A, B>,
   failWith: (a: Exclude<A, B>) => E1,
 ): <R, E>(fa: IO<R, E, A>) => IO<R, E | E1, B>;
+
 export function filterOrFail<A, E1>(
   predicate: Predicate<A>,
   failWith: (a: A) => E1,
 ): <R, E>(fa: IO<R, E, A>) => IO<R, E | E1, A>;
+
 export function filterOrFail<A>(predicate: Predicate<A>, failWith: unknown, __tsplusTrace?: string) {
   return <R, E, E1>(fa: IO<R, E, A>): IO<R, E | E1, A> => {
     return fa.filterOrElse(predicate, (a) => IO.failNow((failWith as (a: A) => E1)(a)));
   };
 }
-
-/**
- * Returns an `IO` that yields the value of the first
- * `IO` to succeed.
- *
- * @tsplus static fncts.io.IOOps firstSuccess
- */
-export function firstSuccess<R, E, A>(mas: NonEmptyArray<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, A> {
-  return mas.reduce((b, a) => b.orElse(a));
-}
-
 /**
  * Halts with specified `unknown` if the predicate fails.
  *
@@ -643,11 +568,47 @@ export function filterOrHalt<A>(
   haltWith: (a: A) => unknown,
   __tsplusTrace?: string,
 ): <R, E>(fa: IO<R, E, A>) => IO<R, E, A>;
+
 export function filterOrHalt<A>(predicate: Predicate<A>, haltWith: unknown, __tsplusTrace?: string) {
   return <R, E>(fa: IO<R, E, A>): IO<R, E, A> => {
     return fa.filterOrElse(predicate, (a) => IO.haltNow((haltWith as (a: A) => unknown)(a)));
   };
 }
+/**
+ * Returns an `IO` that yields the value of the first
+ * `IO` to succeed.
+ *
+ * @tsplus static fncts.io.IOOps firstSuccess
+ */
+export function firstSuccess<R, E, A>(ios: ReadonlyNonEmptyArray<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, A> {
+  return ios.reduce((b, a) => b.orElse(a));
+}
+/**
+ * Returns an IO that models the execution of this effect, followed by
+ * the passing of its value to the specified continuation function `f`,
+ * followed by the effect that it returns.
+ *
+ * @tsplus pipeable fncts.io.IO flatMap
+ */
+export function flatMap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E>(self: IO<R, E, A>): IO<R | R1, E | E1, B> => {
+    const io = new IOPrimitive(IOTag.OnSuccess) as any;
+    io.i0    = self;
+    io.i1    = f;
+    io.trace = __tsplusTrace;
+
+    return io;
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.io.IO flatMapError
+ */
+export function flatMapError<R1, E, E1>(f: (e: E) => IO<R1, never, E1>, __tsplusTrace?: string) {
+  return <R, A>(self: IO<R, E, A>): IO<R | R1, E1, A> => {
+    return self.swapWith((effect) => effect.flatMap(f));
+  };
+}
 
 /**
  * @tsplus getter fncts.io.IO flatten
@@ -655,11 +616,11 @@ export function filterOrHalt<A>(predicate: Predicate<A>, haltWith: unknown, __ts
 export function flatten<R, E, R1, E1, A>(self: IO<R, E, IO<R1, E1, A>>, __tsplusTrace?: string): IO<R | R1, E | E1, A> {
   return self.flatMap(identity);
 }
-
 /**
  * Folds an `Iterable<A>` using an effectful function f, working sequentially from left to right.
  *
  * @tsplus static fncts.io.IOOps foldLeft
+ * @tsplus fluent fncts.Iterable foldLeftIO
  */
 export function foldLeft<A, B, R, E>(
   as: Iterable<A>,
@@ -674,29 +635,21 @@ export function foldLeft<A, B, R, E>(
  * Combines an array of `IO`s using a `Monoid`
  *
  * @tsplus static fncts.io.IOOps foldMap
+ * @tsplus fluent fncts.Iterable foldMapIO
  */
 export function foldMap<R, E, A, M>(
-  as: Iterable<IO<R, E, A>>,
+  ios: Iterable<IO<R, E, A>>,
   f: (a: A) => M,
   /** @tsplus auto */ M: P.Monoid<M>,
 ): IO<R, E, M> {
-  return IO.foldLeft(as, M.nat, (m, a) => a.map((a) => M.combine(f(a))(m)));
-}
-
-function foldRightLoop<A, B, R, E>(
-  iterator: Iterator<A>,
-  b: UIO<B>,
-  f: (a: A, b: IO<R, E, B>) => IO<R, E, B>,
-  __tsplusTrace?: string,
-): IO<R, E, B> {
-  const next = iterator.next();
-  return next.done ? b : f(next.value, foldRightLoop(iterator, b, f));
+  return IO.foldLeft(ios, M.nat, (m, a) => a.map((a) => M.combine(f(a))(m)));
 }
 
 /**
  * Performs a right-associative fold of an `Iterable<A>`
  *
  * @tsplus static fncts.io.IOOps foldRight
+ * @tsplus fluent fncts.Iterable foldRightIO
  */
 export function foldRight<A, B, R, E>(
   as: Iterable<A>,
@@ -707,14 +660,14 @@ export function foldRight<A, B, R, E>(
   return foldRightLoop(as[Symbol.iterator](), b, f);
 }
 
-function foreachWithIndexDiscardLoop<A, R, E, B>(
+function foldRightLoop<A, B, R, E>(
   iterator: Iterator<A>,
-  f: (i: number, a: A) => IO<R, E, B>,
-  i = 0,
+  b: UIO<B>,
+  f: (a: A, b: IO<R, E, B>) => IO<R, E, B>,
   __tsplusTrace?: string,
-): IO<R, E, void> {
+): IO<R, E, B> {
   const next = iterator.next();
-  return next.done ? IO.unit : f(i, next.value).flatMap(() => foreachWithIndexDiscardLoop(iterator, f, i + 1));
+  return next.done ? b : f(next.value, foldRightLoop(iterator, b, f));
 }
 
 /**
@@ -725,6 +678,7 @@ function foreachWithIndexDiscardLoop<A, R, E, B>(
  * If you do not need the results, see `foreachUnit` for a more efficient implementation.
  *
  * @tsplus static fncts.io.IOOps foreach
+ * @tsplus fluent fncts.Iterable foreachIO
  */
 export function foreach<A, R, E, B>(
   as: Iterable<A>,
@@ -742,6 +696,21 @@ export function foreach<A, R, E, B>(
   });
 }
 
+/**
+ * Applies the function `f` to each element of the `Iterable<A>` and runs
+ * produced IOs sequentially.
+ *
+ * @tsplus static fncts.io.IOOps foreachDiscard
+ * @tsplus fluent fncts.Iterable foreachDiscardIO
+ */
+export function foreachDiscard<A, R, E, B>(
+  as: Iterable<A>,
+  f: (a: A) => IO<R, E, B>,
+  __tsplusTrace?: string,
+): IO<R, E, void> {
+  return IO.defer(foreachWithIndexDiscardLoop(as[Symbol.iterator](), (_, a) => f(a)));
+}
+
 /**
  * Applies the function `f` to each element of the `Iterable<A>` and
  * returns the results in a new `Conc<B>`.
@@ -750,6 +719,7 @@ export function foreach<A, R, E, B>(
  * If you do not need the results, see `foreachUnit` for a more efficient implementation.
  *
  * @tsplus static fncts.io.IOOps foreachWithIndex
+ * @tsplus fluent fncts.Iterable foreachWithIndexIO
  */
 export function foreachWithIndex<A, R, E, B>(
   as: Iterable<A>,
@@ -769,6 +739,7 @@ export function foreachWithIndex<A, R, E, B>(
 
 /**
  * @tsplus static fncts.io.IOOps foreachWithIndexDiscard
+ * @tsplus fluent fncts.Iterable foreachWithIndexDiscardIO
  */
 export function foreachWithIndexDiscard<A, R, E, B>(
   as: Iterable<A>,
@@ -778,18 +749,14 @@ export function foreachWithIndexDiscard<A, R, E, B>(
   return IO.defer(foreachWithIndexDiscardLoop(as[Symbol.iterator](), f));
 }
 
-/**
- * Applies the function `f` to each element of the `Iterable<A>` and runs
- * produced IOs sequentially.
- *
- * @tsplus static fncts.io.IOOps foreachDiscard
- */
-export function foreachDiscard<A, R, E, B>(
-  as: Iterable<A>,
-  f: (a: A) => IO<R, E, B>,
+function foreachWithIndexDiscardLoop<A, R, E, B>(
+  iterator: Iterator<A>,
+  f: (i: number, a: A) => IO<R, E, B>,
+  i = 0,
   __tsplusTrace?: string,
 ): IO<R, E, void> {
-  return IO.defer(foreachWithIndexDiscardLoop(as[Symbol.iterator](), (_, a) => f(a)));
+  const next = iterator.next();
+  return next.done ? IO.unit : f(i, next.value).flatMap(() => foreachWithIndexDiscardLoop(iterator, f, i + 1));
 }
 
 /**
@@ -869,9 +836,19 @@ export function fromMaybeNow<A = never>(maybe: Maybe<A>, __tsplusTrace?: string)
 
 /**
  * Create an IO that when executed will construct `promise` and wait for its result,
- * errors will be handled using `onReject`
+ * errors will produce failure as `unknown`
  *
- * @tsplus static fncts.io.IOOps fromPromiseCatch
+ * @tsplus static fncts.io.IOOps fromPromise
+ */
+export function fromPromise<A>(promise: Lazy<Promise<A>>, __tsplusTrace?: string): FIO<unknown, A> {
+  return IO.fromPromiseCatch(promise, identity);
+}
+
+/**
+ * Create an IO that when executed will construct `promise` and wait for its result,
+ * errors will be handled using `onReject`
+ *
+ * @tsplus static fncts.io.IOOps fromPromiseCatch
  */
 export function fromPromiseCatch<E, A>(
   promise: Lazy<Promise<A>>,
@@ -885,16 +862,6 @@ export function fromPromiseCatch<E, A>(
   });
 }
 
-/**
- * Create an IO that when executed will construct `promise` and wait for its result,
- * errors will produce failure as `unknown`
- *
- * @tsplus static fncts.io.IOOps fromPromise
- */
-export function fromPromise<A>(promise: Lazy<Promise<A>>, __tsplusTrace?: string): FIO<unknown, A> {
-  return IO.fromPromiseCatch(promise, identity);
-}
-
 /**
  * Like fromPromise but produces a defect in case of errors
  *
@@ -920,6 +887,13 @@ export function get<R, E, A>(ma: IO<R, E, Maybe<A>>, __tsplusTrace?: string): IO
   );
 }
 
+/**
+ * @tsplus static fncts.io.IOOps getFiberRefs
+ */
+export function getFiberRefs(__tsplusTrace?: string): UIO<FiberRefs> {
+  return IO.withFiberRuntime((fiberState) => IO.succeed(fiberState.getFiberRefs()));
+}
+
 /**
  * Extracts the optional value, or returns the given 'orElse'.
  *
@@ -942,15 +916,6 @@ export function getOrElseIO<R1, E1, B>(orElse: Lazy<IO<R1, E1, B>>, __tsplusTrac
   };
 }
 
-/**
- * Lifts a Maybe into an IO. If the option is `Nothing`, fail with `onNothing`.
- *
- * @tsplus static fncts.io.IOOps getOrFailWith
- */
-export function getOrFailWith<E, A>(maybe: Maybe<A>, onNothing: Lazy<E>, __tsplusTrace?: string): FIO<E, A> {
-  return IO.defer(maybe.match(() => IO.fail(onNothing), IO.succeedNow));
-}
-
 /**
  * Lifts a Maybe into a IO, if the Maybe is `Nothing` it fails with Unit.
  *
@@ -961,10 +926,12 @@ export function getOrFailUnit<A>(option: Maybe<A>, __tsplusTrace?: string): FIO<
 }
 
 /**
- * @tsplus static fncts.io.IOOps getFiberRefs
+ * Lifts a Maybe into an IO. If the option is `Nothing`, fail with `onNothing`.
+ *
+ * @tsplus static fncts.io.IOOps getOrFailWith
  */
-export function getFiberRefs(__tsplusTrace?: string): UIO<FiberRefs> {
-  return IO.withFiberRuntime((fiberState) => IO.succeed(fiberState.getFiberRefs()));
+export function getOrFailWith<E, A>(maybe: Maybe<A>, onNothing: Lazy<E>, __tsplusTrace?: string): FIO<E, A> {
+  return IO.defer(maybe.match(() => IO.fail(onNothing), IO.succeedNow));
 }
 
 /**
@@ -988,6 +955,7 @@ export function halt(e: Lazy<unknown>, __tsplusTrace?: string): UIO<never> {
 export function haltNow(e: unknown, __tsplusTrace?: string): UIO<never> {
   return IO.failCauseNow(Cause.halt(e, Trace.none), __tsplusTrace);
 }
+
 /**
  * @tsplus pipeable fncts.io.IO ifIO
  */
@@ -1001,23 +969,11 @@ export function ifIO<R1, E1, B, R2, E2, C>(
   };
 }
 
-/**
- * @tsplus static fncts.io.IOOps if
- */
-export function cond<R, E, A, R1, E1, A1>(
-  b: boolean,
-  onTrue: Lazy<IO<R, E, A>>,
-  onFalse: Lazy<IO<R1, E1, A1>>,
-  __tsplusTrace?: string,
-): IO<R | R1, E | E1, A | A1> {
-  return IO.succeedNow(b).ifIO(onTrue, onFalse);
-}
-
 /**
  * @tsplus getter fncts.io.IO ignore
  */
-export function ignore<R, E, A>(fa: IO<R, E, A>, __tsplusTrace?: string): URIO<R, void> {
-  return fa.match(
+export function ignore<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): URIO<R, void> {
+  return self.match(
     () => undefined,
     () => undefined,
   );
@@ -1028,20 +984,19 @@ export function ignore<R, E, A>(fa: IO<R, E, A>, __tsplusTrace?: string): URIO<R
  *
  * @tsplus getter fncts.io.IO isFailure
  */
-export function isFailure<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, boolean> {
-  return ma.match(
+export function isFailure<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, boolean> {
+  return self.match(
     () => true,
     () => false,
   );
 }
-
 /**
  * Folds a `IO` to a boolean describing whether or not it is a success
  *
  * @tsplus getter fncts.io.IO isSuccess
  */
-export function isSuccess<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, boolean> {
-  return ma.match(
+export function isSuccess<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, boolean> {
+  return self.match(
     () => false,
     () => true,
   );
@@ -1071,15 +1026,6 @@ export function iterate<R, E, A>(
   return cont(initial) ? body(initial).flatMap((a) => IO.iterate(a, cont, body)) : IO.succeedNow(initial);
 }
 
-/**
- *  Returns an IO with the value on the left part.
- *
- * @tsplus static fncts.io.IOOps left
- */
-export function left<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<Either<A, never>> {
-  return IO.succeed(a).flatMap((a) => IO.succeedNow(Either.left(a)));
-}
-
 /**
  * @tsplus getter fncts.io.IO just
  */
@@ -1090,6 +1036,15 @@ export function just<R, E, A>(self: IO<R, E, Maybe<A>>): IO<R, Maybe<E>, A> {
   );
 }
 
+/**
+ *  Returns an IO with the value on the left part.
+ *
+ * @tsplus static fncts.io.IOOps left
+ */
+export function left<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<Either<A, never>> {
+  return IO.succeed(a).flatMap((a) => IO.succeedNow(Either.left(a)));
+}
+
 /**
  * @tsplus static fncts.io.IOOps log
  */
@@ -1100,13 +1055,6 @@ export function log(message: Lazy<string>, __tsplusTrace?: string): UIO<void> {
   });
 }
 
-/**
- * @tsplus static fncts.io.IOOps show
- */
-export function show(message: Lazy<unknown>, options?: Partial<ShowOptions>, __tsplusTrace?: string): UIO<void> {
-  return IO.log(showWithOptions(message, options));
-}
-
 /**
  * Loops with the specified effectual function, collecting the results into a
  * list. The moral equivalent of:
@@ -1174,8 +1122,8 @@ export function loopUnit<A, R, E>(
  * @tsplus pipeable fncts.io.IO map
  */
 export function map<A, B>(f: (a: A) => B, __tsplusTrace?: string) {
-  return <R, E>(fa: IO<R, E, A>): IO<R, E, B> => {
-    return fa.flatMap((a) => IO.succeedNow(f(a)));
+  return <R, E>(self: IO<R, E, A>): IO<R, E, B> => {
+    return self.flatMap((a) => IO.succeedNow(f(a)));
   };
 }
 
@@ -1189,23 +1137,11 @@ export function map<A, B>(f: (a: A) => B, __tsplusTrace?: string) {
  * @tsplus pipeable fncts.io.IO mapError
  */
 export function mapError<E, E1>(f: (e: E) => E1, __tsplusTrace?: string) {
-  return <R, A>(fea: IO<R, E, A>): IO<R, E1, A> => {
-    return fea.matchCauseIO((cause) => IO.failCauseNow(cause.map(f)), IO.succeedNow);
+  return <R, A>(self: IO<R, E, A>): IO<R, E1, A> => {
+    return self.matchCauseIO((cause) => IO.failCauseNow(cause.map(f)), IO.succeedNow);
   };
 }
 
-/**
- * @tsplus static fncts.io.IOOps mapTryCatch
- */
-export function mapTryCatch<R, E, A, E1, B>(
-  io: IO<R, E, A>,
-  f: (a: A) => B,
-  onThrow: (u: unknown) => E1,
-  __tsplusTrace?: string,
-): IO<R, E | E1, B> {
-  return io.flatMap((a) => IO.tryCatch(() => f(a), onThrow));
-}
-
 /**
  * Returns an IO with its full cause of failure mapped using
  * the specified function. This can be used to transform errors
@@ -1214,8 +1150,34 @@ export function mapTryCatch<R, E, A, E1, B>(
  * @tsplus pipeable fncts.io.IO mapErrorCause
  */
 export function mapErrorCause<E, E1>(f: (cause: Cause<E>) => Cause<E1>, __tsplusTrace?: string) {
-  return <R, A>(ma: IO<R, E, A>): IO<R, E1, A> => {
-    return ma.matchCauseIO((cause) => IO.failCauseNow(f(cause)), IO.succeedNow);
+  return <R, A>(self: IO<R, E, A>): IO<R, E1, A> => {
+    return self.matchCauseIO((cause) => IO.failCauseNow(f(cause)), IO.succeedNow);
+  };
+}
+
+/**
+ * @tsplus static fncts.io.IOOps mapTryCatch
+ * @tsplus pipeable fncts.io.IO mapTryCatch
+ */
+export function mapTryCatch<A, E1, B>(f: (a: A) => B, onThrow: (u: unknown) => E1, __tsplusTrace?: string) {
+  return <R, E>(self: IO<R, E, A>): IO<R, E | E1, B> => {
+    return self.flatMap((a) => IO.tryCatch(() => f(a), onThrow));
+  };
+}
+
+/**
+ * Folds over the failure value or the success value to yield an IO that
+ * does not fail, but succeeds with the value returned by the left or right
+ * function passed to `match_`.
+ *
+ * @tsplus pipeable fncts.io.IO match
+ */
+export function match<E, A, B, C>(onFailure: (e: E) => B, onSuccess: (a: A) => C, __tsplusTrace?: string) {
+  return <R>(self: IO<R, E, A>): IO<R, never, B | C> => {
+    return self.matchIO(
+      (e) => IO.succeedNow(onFailure(e)),
+      (a) => IO.succeedNow(onSuccess(a)),
+    );
   };
 }
 
@@ -1270,22 +1232,6 @@ export function matchIO<R1, R2, E, E1, E2, A, A1, A2>(
   };
 }
 
-/**
- * Folds over the failure value or the success value to yield an IO that
- * does not fail, but succeeds with the value returned by the left or right
- * function passed to `match_`.
- *
- * @tsplus pipeable fncts.io.IO match
- */
-export function match<E, A, B, C>(onFailure: (e: E) => B, onSuccess: (a: A) => C, __tsplusTrace?: string) {
-  return <R>(self: IO<R, E, A>): IO<R, never, B | C> => {
-    return self.matchIO(
-      (e) => IO.succeedNow(onFailure(e)),
-      (a) => IO.succeedNow(onSuccess(a)),
-    );
-  };
-}
-
 /**
  * A version of `matchIO` that gives you the (optional) trace of the error.
  *
@@ -1296,8 +1242,8 @@ export function matchTraceIO<E, A, R1, E1, A1, R2, E2, A2>(
   onSuccess: (a: A) => IO<R2, E2, A2>,
   __tsplusTrace?: string,
 ) {
-  return <R>(ma: IO<R, E, A>): IO<R | R1 | R2, E1 | E2, A1 | A2> => {
-    return ma.matchCauseIO(
+  return <R>(self: IO<R, E, A>): IO<R | R1 | R2, E1 | E2, A1 | A2> => {
+    return self.matchCauseIO(
       (cause) => cause.failureTraceOrCause.match(([e, trace]) => onFailure(e, trace), IO.failCauseNow),
       onSuccess,
     );
@@ -1307,15 +1253,15 @@ export function matchTraceIO<E, A, R1, E1, A1, R2, E2, A2>(
 /**
  * @tsplus getter fncts.io.IO maybe
  */
-export function maybe<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): URIO<R, Maybe<A>> {
-  return io.match(() => Nothing(), Maybe.just);
+export function maybe<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): URIO<R, Maybe<A>> {
+  return self.match(() => Nothing(), Maybe.just);
 }
 
 /**
  * @tsplus getter fncts.io.IO merge
  */
-export function merge<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, A | E> {
-  return io.matchIO(IO.succeedNow, IO.succeedNow);
+export function merge<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, A | E> {
+  return self.matchIO(IO.succeedNow, IO.succeedNow);
 }
 
 /**
@@ -1324,12 +1270,39 @@ export function merge<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, n
  * @tsplus static fncts.io.IOOps mergeAll
  */
 export function mergeAll<R, E, A, B>(
-  fas: Iterable<IO<R, E, A>>,
+  ios: Iterable<IO<R, E, A>>,
   b: B,
   f: (b: B, a: A) => B,
   __tsplusTrace?: string,
 ): IO<R, E, B> {
-  return fas.foldLeft(IO.succeed(b) as IO<R, E, B>, (b, a) => b.zipWith(a, f));
+  return ios.foldLeft(IO.succeed(b) as IO<R, E, B>, (b, a) => b.zipWith(a, f));
+}
+
+/**
+ * @tsplus static fncts.io.IOOps refailCause
+ */
+export function refailCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): FIO<E, never> {
+  const io = new IOPrimitive(IOTag.Fail) as any;
+  io.i0    = cause;
+  io.trace = __tsplusTrace;
+  return io;
+}
+
+/**
+ * @tsplus static fncts.io.IOOps refailCauseNow
+ */
+export function refailCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E, never> {
+  const io = new IOPrimitive(IOTag.Fail) as any;
+  io.i0    = () => cause;
+  io.trace = __tsplusTrace;
+  return io;
+}
+
+/**
+ * @tsplus static fncts.io.IOOps show
+ */
+export function show(message: Lazy<unknown>, options?: Partial<ShowOptions>, __tsplusTrace?: string): UIO<void> {
+  return IO.log(showWithOptions(message, options));
 }
 
 /**
@@ -1337,13 +1310,59 @@ export function mergeAll<R, E, A, B>(
  */
 export const nothing = IO.succeedNow(Nothing());
 
+/**
+ * Returns an `IO` that submerges an `Either` into the `IO`.
+ *
+ * @tsplus getter fncts.io.IO absolve
+ */
+export function absolve<R, E, E1, A>(self: IO<R, E, Either<E1, A>>, __tsplusTrace?: string): IO<R, E | E1, A> {
+  return self.flatMap((ea) => ea.match(IO.failNow, IO.succeedNow));
+}
+
+/**
+ * @tsplus static fncts.io.IOOps attempt
+ */
+export function attempt<A>(effect: Lazy<A>, __tsplusTrace?: string): FIO<unknown, A> {
+  return IO.defer(() => {
+    try {
+      return Exit.succeed(effect());
+    } catch (u) {
+      return IO.withFiberRuntime((fiberState) => {
+        if (!fiberState.isFatal(u)) {
+          throw new IOError(Cause.fail(u));
+        } else {
+          throw u;
+        }
+      });
+    }
+  });
+}
+
+/**
+ * Exposes all parallel errors in a single call
+ *
+ * @tsplus pipeable fncts.io.IO concurrentErrors
+ */
+export function concurrentErrors(__tsplusTrace?: string) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R, List<E>, A> => {
+    return self.matchCauseIO((cause) => {
+      const f = cause.failures;
+      if (f.length === 0) {
+        return IO.failCauseNow(cause as Cause<never>);
+      } else {
+        return IO.failNow(f);
+      }
+    }, IO.succeedNow);
+  };
+}
+
 /**
  * Converts an option on errors into an option on values.
  *
  * @tsplus getter fncts.io.IO optional
  */
-export function optional<R, E, A>(ma: IO<R, Maybe<E>, A>, __tsplusTrace?: string): IO<R, E, Maybe<A>> {
-  return ma.matchIO(
+export function optional<R, E, A>(self: IO<R, Maybe<E>, A>, __tsplusTrace?: string): IO<R, E, Maybe<A>> {
+  return self.matchIO(
     (me) => me.match(() => IO.succeedNow(Nothing()), IO.failNow),
     (a) => IO.succeedNow(Just(a)),
   );
@@ -1358,9 +1377,9 @@ export function optional<R, E, A>(ma: IO<R, Maybe<E>, A>, __tsplusTrace?: string
  * @tsplus pipeable fncts.io.IO or
  * @tsplus pipeable-operator fncts.io.IO ||
  */
-export function or<R1, E1>(mb: IO<R1, E1, boolean>, __tsplusTrace?: string) {
-  return <R, E>(ma: IO<R, E, boolean>): IO<R | R1, E | E1, boolean> => {
-    return ma.flatMap((b) => (b ? IO.succeedNow(true) : mb));
+export function or<R1, E1>(or: IO<R1, E1, boolean>, __tsplusTrace?: string) {
+  return <R, E>(self: IO<R, E, boolean>): IO<R | R1, E | E1, boolean> => {
+    return self.flatMap((b) => (b ? IO.succeedNow(true) : or));
   };
 }
 
@@ -1368,8 +1387,8 @@ export function or<R1, E1>(mb: IO<R1, E1, boolean>, __tsplusTrace?: string) {
  * @tsplus pipeable fncts.io.IO orElse
  */
 export function orElse<R1, E1, A1>(that: Lazy<IO<R1, E1, A1>>, __tsplusTrace?: string) {
-  return <R, E, A>(ma: IO<R, E, A>): IO<R | R1, E1, A | A1> => {
-    return ma.tryOrElse(that, IO.succeedNow);
+  return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E1, A | A1> => {
+    return self.tryOrElse(that, IO.succeedNow);
   };
 }
 
@@ -1386,8 +1405,8 @@ export function orElseEither<R1, E1, A1>(that: Lazy<IO<R1, E1, A1>>, __tsplusTra
  * @tsplus pipeable fncts.io.IO orElseFail
  */
 export function orElseFail<E1>(e: Lazy<E1>, __tsplusTrace?: string) {
-  return <R, E, A>(ma: IO<R, E, A>): IO<R, E1, A> => {
-    return ma.orElse(IO.fail(e));
+  return <R, E, A>(self: IO<R, E, A>): IO<R, E1, A> => {
+    return self.orElse(IO.fail(e));
   };
 }
 
@@ -1395,8 +1414,8 @@ export function orElseFail<E1>(e: Lazy<E1>, __tsplusTrace?: string) {
  * @tsplus pipeable fncts.io.IO orElseMaybe
  */
 export function orElseMaybe<R1, E1, A1>(that: Lazy<IO<R1, Maybe<E1>, A1>>, __tsplusTrace?: string) {
-  return <R, E, A>(ma: IO<R, Maybe<E>, A>): IO<R | R1, Maybe<E | E1>, A | A1> => {
-    return ma.catchAll((me) => me.match(that, (e) => IO.fail(Just(e))));
+  return <R, E, A>(self: IO<R, Maybe<E>, A>): IO<R | R1, Maybe<E | E1>, A | A1> => {
+    return self.catchAll((me) => me.match(that, (e) => IO.fail(Just(e))));
   };
 }
 
@@ -1404,49 +1423,31 @@ export function orElseMaybe<R1, E1, A1>(that: Lazy<IO<R1, Maybe<E1>, A1>>, __tsp
  * @tsplus pipeable fncts.io.IO orElseSucceed
  */
 export function orElseSucceed<A1>(a: Lazy<A1>, __tsplusTrace?: string) {
-  return <R, E, A>(ma: IO<R, E, A>): IO<R, E, A | A1> => {
-    return ma.orElse(IO.succeed(a));
+  return <R, E, A>(self: IO<R, E, A>): IO<R, E, A | A1> => {
+    return self.orElse(IO.succeed(a));
   };
 }
 
 /**
  * @tsplus getter fncts.io.IO orHalt
  */
-export function orHalt<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, A> {
-  return ma.orHaltWith(identity);
+export function orHalt<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, A> {
+  return self.orHaltWith(identity);
 }
 
 /**
  * @tsplus getter fncts.io.IO orHaltKeep
  */
-export function orHaltKeep<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, A> {
-  return ma.matchCauseIO((cause) => IO.failCauseNow(cause.flatMap(Cause.halt)), IO.succeedNow);
+export function orHaltKeep<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, A> {
+  return self.matchCauseIO((cause) => IO.failCauseNow(cause.flatMap(Cause.halt)), IO.succeedNow);
 }
 
 /**
  * @tsplus pipeable fncts.io.IO orHaltWith
  */
 export function orHaltWith<E>(f: (e: E) => unknown, __tsplusTrace?: string) {
-  return <R, A>(ma: IO<R, E, A>): IO<R, never, A> => {
-    return ma.matchIO((e) => IO.haltNow(f(e)), IO.succeedNow);
-  };
-}
-
-/**
- * Exposes all parallel errors in a single call
- *
- * @tsplus pipeable fncts.io.IO concurrentErrors
- */
-export function concurrentErrors(__tsplusTrace?: string) {
-  return <R, E, A>(io: IO<R, E, A>): IO<R, List<E>, A> => {
-    return io.matchCauseIO((cause) => {
-      const f = cause.failures;
-      if (f.length === 0) {
-        return IO.failCauseNow(cause as Cause<never>);
-      } else {
-        return IO.failNow(f);
-      }
-    }, IO.succeedNow);
+  return <R, A>(self: IO<R, E, A>): IO<R, never, A> => {
+    return self.matchIO((e) => IO.haltNow(f(e)), IO.succeedNow);
   };
 }
 
@@ -1470,8 +1471,8 @@ export function partition<R, E, A, B>(
  * @tsplus pipeable fncts.io.IO refineOrHalt
  */
 export function refineOrHalt<E, E1>(pf: (e: E) => Maybe<E1>, __tsplusTrace?: string) {
-  return <R, A>(fa: IO<R, E, A>): IO<R, E1, A> => {
-    return fa.refineOrHaltWith(pf, identity);
+  return <R, A>(self: IO<R, E, A>): IO<R, E1, A> => {
+    return self.refineOrHaltWith(pf, identity);
   };
 }
 
@@ -1482,8 +1483,8 @@ export function refineOrHalt<E, E1>(pf: (e: E) => Maybe<E1>, __tsplusTrace?: str
  * @tsplus pipeable fncts.io.IO refineOrHaltWith
  */
 export function refineOrHaltWith<E, E1>(pf: (e: E) => Maybe<E1>, f: (e: E) => unknown, __tsplusTrace?: string) {
-  return <R, A>(fa: IO<R, E, A>): IO<R, E1, A> => {
-    return fa.catchAll((e) => pf(e).match(() => IO.haltNow(f(e)), IO.failNow));
+  return <R, A>(self: IO<R, E, A>): IO<R, E1, A> => {
+    return self.catchAll((e) => pf(e).match(() => IO.haltNow(f(e)), IO.failNow));
   };
 }
 
@@ -1494,8 +1495,8 @@ export function refineOrHaltWith<E, E1>(pf: (e: E) => Maybe<E1>, f: (e: E) => un
  * @tsplus pipeable fncts.io.IO reject
  */
 export function reject<A, E1>(pf: (a: A) => Maybe<E1>, __tsplusTrace?: string) {
-  return <R, E>(fa: IO<R, E, A>): IO<R, E | E1, A> => {
-    return fa.rejectIO((a) => pf(a).map(IO.failNow));
+  return <R, E>(self: IO<R, E, A>): IO<R, E | E1, A> => {
+    return self.rejectIO((a) => pf(a).map(IO.failNow));
   };
 }
 
@@ -1507,8 +1508,8 @@ export function reject<A, E1>(pf: (a: A) => Maybe<E1>, __tsplusTrace?: string) {
  * @tsplus pipeable fncts.io.IO rejectIO
  */
 export function rejectIO<A, R1, E1>(pf: (a: A) => Maybe<IO<R1, E1, E1>>, __tsplusTrace?: string) {
-  return <R, E>(fa: IO<R, E, A>): IO<R | R1, E | E1, A> => {
-    return fa.flatMap((a) =>
+  return <R, E>(self: IO<R, E, A>): IO<R | R1, E | E1, A> => {
+    return self.flatMap((a) =>
       pf(a).match(
         () => IO.succeedNow(a),
         (io) => io.flatMap(IO.failNow),
@@ -1523,8 +1524,21 @@ export function rejectIO<A, R1, E1>(pf: (a: A) => Maybe<IO<R1, E1, E1>>, __tsplu
  * @tsplus pipeable fncts.io.IO repeatN
  */
 export function repeatN_(n: number, __tsplusTrace?: string) {
-  return <R, E, A>(ma: IO<R, E, A>): IO<R, E, A> => {
-    return ma.flatMap((a) => (n <= 0 ? IO.succeed(a) : ma.repeatN(n - 1)));
+  return <R, E, A>(self: IO<R, E, A>): IO<R, E, A> => {
+    return self.flatMap((a) => {
+      let i = n;
+      let s = a;
+      return IO.whileLoop(
+        i > 0,
+        () => {
+          i -= 1;
+          return self;
+        },
+        (a) => {
+          s = a;
+        },
+      ).as(s);
+    });
   };
 }
 
@@ -1534,8 +1548,8 @@ export function repeatN_(n: number, __tsplusTrace?: string) {
  * @tsplus pipeable fncts.io.IO repeatUntil
  */
 export function repeatUntil<A>(f: (a: A) => boolean, __tsplusTrace?: string) {
-  return <R, E>(ma: IO<R, E, A>): IO<R, E, A> => {
-    return ma.repeatUntilIO((a) => IO.succeedNow(f(a)));
+  return <R, E>(self: IO<R, E, A>): IO<R, E, A> => {
+    return self.repeatUntilIO((a) => IO.succeedNow(f(a)));
   };
 }
 
@@ -1545,8 +1559,8 @@ export function repeatUntil<A>(f: (a: A) => boolean, __tsplusTrace?: string) {
  * @tsplus pipeable fncts.io.IO repeatUntilIO
  */
 export function repeatUntilIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string) {
-  return <R, E>(ma: IO<R, E, A>): IO<R | R1, E | E1, A> => {
-    return ma.flatMap((a) => f(a).flatMap((b) => (b ? IO.succeed(a) : ma.repeatUntilIO(f))));
+  return <R, E>(self: IO<R, E, A>): IO<R | R1, E | E1, A> => {
+    return self.flatMap((a) => f(a).flatMap((b) => (b ? IO.succeed(a) : self.repeatUntilIO(f))));
   };
 }
 
@@ -1556,8 +1570,8 @@ export function repeatUntilIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsp
  * @tsplus pipeable fncts.io.IO repeatWhile
  */
 export function repeatWhile<A>(f: (a: A) => boolean, __tsplusTrace?: string) {
-  return <R, E>(ma: IO<R, E, A>): IO<R, E, A> => {
-    return ma.repeatWhileIO((a) => IO.succeedNow(f(a)));
+  return <R, E>(self: IO<R, E, A>): IO<R, E, A> => {
+    return self.repeatWhileIO((a) => IO.succeedNow(f(a)));
   };
 }
 
@@ -1567,8 +1581,8 @@ export function repeatWhile<A>(f: (a: A) => boolean, __tsplusTrace?: string) {
  * @tsplus pipeable fncts.io.IO repeatWhileIO
  */
 export function repeatWhileIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string) {
-  return <R, E>(ma: IO<R, E, A>): IO<R | R1, E | E1, A> => {
-    return ma.flatMap((a) => f(a).flatMap((b) => (b ? ma.repeatWhileIO(f) : IO.succeed(a))));
+  return <R, E>(self: IO<R, E, A>): IO<R | R1, E | E1, A> => {
+    return self.flatMap((a) => f(a).flatMap((b) => (b ? self.repeatWhileIO(f) : IO.succeed(a))));
   };
 }
 
@@ -1576,8 +1590,8 @@ export function repeatWhileIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsp
  * @tsplus pipeable fncts.io.IO replicate
  */
 export function replicate(n: number, __tsplusTrace?: string) {
-  return <R, E, A>(self: IO<R, E, A>): ImmutableArray<IO<R, E, A>> => {
-    return ImmutableArray.range(0, n).map(() => self);
+  return <R, E, A>(self: IO<R, E, A>): ReadonlyArray<IO<R, E, A>> => {
+    return Array.range(0, n).map(() => self);
   };
 }
 
@@ -1585,8 +1599,8 @@ export function replicate(n: number, __tsplusTrace?: string) {
  * @tsplus pipeable fncts.io.IO require
  */
 export function require<E>(error: Lazy<E>, __tsplusTrace?: string) {
-  return <R, A>(ma: IO<R, E, Maybe<A>>): IO<R, E, A> => {
-    return ma.flatMap((ma) => ma.match(() => IO.fail(error), IO.succeedNow));
+  return <R, A>(self: IO<R, E, Maybe<A>>): IO<R, E, A> => {
+    return self.flatMap((ma) => ma.match(() => IO.fail(error), IO.succeedNow));
   };
 }
 
@@ -1596,8 +1610,8 @@ export function require<E>(error: Lazy<E>, __tsplusTrace?: string) {
  *
  * @tsplus getter fncts.io.IO result
  */
-export function result<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, Exit<E, A>> {
-  return ma.matchCauseIO(
+export function result<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, Exit<E, A>> {
+  return self.matchCauseIO(
     (cause) => IO.succeedNow(Exit.failCause(cause)),
     (a) => IO.succeedNow(Exit.succeed(a)),
   );
@@ -1608,8 +1622,8 @@ export function result<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R,
  *
  * @tsplus getter fncts.io.IO resurrect
  */
-export function resurrect<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, unknown, A> {
-  return io.unrefineWith(Maybe.just, identity);
+export function resurrect<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, unknown, A> {
+  return self.unrefineWith(Maybe.just, identity);
 }
 
 /**
@@ -1618,8 +1632,8 @@ export function resurrect<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<
  * @tsplus pipeable fncts.io.IO retryUntil
  */
 export function retryUntil<E>(f: (e: E) => boolean, __tsplusTrace?: string) {
-  return <R, A>(fa: IO<R, E, A>): IO<R, E, A> => {
-    return fa.retryUntilIO((e) => IO.succeedNow(f(e)));
+  return <R, A>(self: IO<R, E, A>): IO<R, E, A> => {
+    return self.retryUntilIO((e) => IO.succeedNow(f(e)));
   };
 }
 
@@ -1629,8 +1643,8 @@ export function retryUntil<E>(f: (e: E) => boolean, __tsplusTrace?: string) {
  * @tsplus pipeable fncts.io.IO retryUntilIO
  */
 export function retryUntilIO<E, R1, E1>(f: (e: E) => IO<R1, E1, boolean>, __tsplusTrace?: string) {
-  return <R, A>(fa: IO<R, E, A>): IO<R | R1, E | E1, A> => {
-    return fa.catchAll((e) => f(e).flatMap((b) => (b ? IO.failNow(e) : fa.retryUntilIO(f))));
+  return <R, A>(self: IO<R, E, A>): IO<R | R1, E | E1, A> => {
+    return self.catchAll((e) => f(e).flatMap((b) => (b ? IO.failNow(e) : self.retryUntilIO(f))));
   };
 }
 
@@ -1640,8 +1654,8 @@ export function retryUntilIO<E, R1, E1>(f: (e: E) => IO<R1, E1, boolean>, __tspl
  * @tsplus pipeable fncts.io.IO retryWhile
  */
 export function retryWhile<E>(f: (e: E) => boolean, __tsplusTrace?: string) {
-  return <R, A>(fa: IO<R, E, A>): IO<R, E, A> => {
-    return fa.retryWhileIO((e) => IO.succeedNow(f(e)));
+  return <R, A>(self: IO<R, E, A>): IO<R, E, A> => {
+    return self.retryWhileIO((e) => IO.succeedNow(f(e)));
   };
 }
 
@@ -1651,8 +1665,8 @@ export function retryWhile<E>(f: (e: E) => boolean, __tsplusTrace?: string) {
  * @tsplus pipeable fncts.io.IO retryWhileIO
  */
 export function retryWhileIO<E, R1, E1>(f: (e: E) => IO<R1, E1, boolean>, __tsplusTrace?: string) {
-  return <R, A>(fa: IO<R, E, A>): IO<R | R1, E | E1, A> => {
-    return fa.catchAll((e) => f(e).flatMap((b) => (b ? fa.retryWhileIO(f) : IO.fail(e))));
+  return <R, A>(self: IO<R, E, A>): IO<R | R1, E | E1, A> => {
+    return self.catchAll((e) => f(e).flatMap((b) => (b ? self.retryWhileIO(f) : IO.fail(e))));
   };
 }
 
@@ -1661,16 +1675,16 @@ export function retryWhileIO<E, R1, E1>(f: (e: E) => IO<R1, E1, boolean>, __tspl
  *
  * @tsplus getter fncts.io.IO sandbox
  */
-export function sandbox<R, E, A>(fa: IO<R, E, A>, __tsplusTrace?: string): IO<R, Cause<E>, A> {
-  return fa.matchCauseIO(IO.failNow, IO.succeedNow);
+export function sandbox<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, Cause<E>, A> {
+  return self.matchCauseIO(IO.failNow, IO.succeedNow);
 }
 
 /**
  * @tsplus pipeable fncts.io.IO sandboxWith
  */
 export function sandboxWith<R, E, A, E1>(f: (_: IO<R, Cause<E>, A>) => IO<R, Cause<E1>, A>, __tsplusTrace?: string) {
-  return (ma: IO<R, E, A>): IO<R, E1, A> => {
-    return f(ma.sandbox).unsandbox;
+  return (self: IO<R, E, A>): IO<R, E1, A> => {
+    return f(self.sandbox).unsandbox;
   };
 }
 
@@ -1688,18 +1702,6 @@ export function sequenceIterableDiscard<R, E, A>(as: Iterable<IO<R, E, A>>, __ts
   return IO.foreachDiscard(as, identity);
 }
 
-/**
- * Creates a `IO` that has succeeded with a pure value
- *
- * @tsplus static fncts.io.IOOps succeedNow
- */
-export function succeedNow<A>(value: A, __tsplusTrace?: string): IO<never, never, A> {
-  const io = new IOPrimitive(IOTag.SucceedNow) as any;
-  io.i0    = value;
-  io.trace = __tsplusTrace;
-  return io;
-}
-
 /**
  * Imports a total synchronous effect into a pure `IO` value.
  * The effect must not throw any exceptions. If you wonder if the effect
@@ -1715,6 +1717,18 @@ export function succeed<A>(effect: Lazy<A>, __tsplusTrace?: string): UIO<A> {
   return io;
 }
 
+/**
+ * Creates a `IO` that has succeeded with a pure value
+ *
+ * @tsplus static fncts.io.IOOps succeedNow
+ */
+export function succeedNow<A>(value: A, __tsplusTrace?: string): IO<never, never, A> {
+  const io = new IOPrimitive(IOTag.SucceedNow) as any;
+  io.i0    = value;
+  io.trace = __tsplusTrace;
+  return io;
+}
+
 /**
  * @tsplus pipeable fncts.io.IO summarized
  */
@@ -1734,8 +1748,8 @@ export function summarized<R1, E1, B, C>(summary: IO<R1, E1, B>, f: (start: B, e
  *
  * @tsplus getter fncts.io.IO swap
  */
-export function swap<R, E, A>(pab: IO<R, E, A>, __tsplusTrace?: string): IO<R, A, E> {
-  return pab.matchIO(IO.succeedNow, IO.failNow);
+export function swap<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, A, E> {
+  return self.matchIO(IO.succeedNow, IO.failNow);
 }
 
 /**
@@ -1744,66 +1758,7 @@ export function swap<R, E, A>(pab: IO<R, E, A>, __tsplusTrace?: string): IO<R, A
  * @tsplus pipeable fncts.io.IO swapWith
  */
 export function swapWith<R, E, A, R1, E1, A1>(f: (ma: IO<R, A, E>) => IO<R1, A1, E1>, __tsplusTrace?: string) {
-  return (fa: IO<R, E, A>): IO<R1, E1, A1> => f(fa.swap).swap;
-}
-
-/**
- * A more powerful variation of `timed` that allows specifying the clock.
- *
- * @tsplus pipeable fncts.io.IO timedWith
- */
-export function timedWith<R1, E1>(msTime: IO<R1, E1, number>, __tsplusTrace?: string) {
-  return <R, E, A>(ma: IO<R, E, A>): IO<R1 | R, E1 | E, readonly [number, A]> =>
-    ma.summarized(msTime, (start, end) => end - start);
-}
-
-/**
- * @tsplus static fncts.io.IOOps attempt
- */
-export function attempt<A>(effect: Lazy<A>, __tsplusTrace?: string): FIO<unknown, A> {
-  return IO.defer(() => {
-    try {
-      return Exit.succeed(effect());
-    } catch (u) {
-      return IO.withFiberRuntime((fiberState) => {
-        if (!fiberState.isFatal(u)) {
-          throw new IOError(Cause.fail(u));
-        } else {
-          throw u;
-        }
-      });
-    }
-  });
-}
-
-/**
- * Creates a `IO` that has succeeded with a pure value
- *
- * @tsplus static fncts.io.IOOps tryCatch
- */
-export function tryCatch<E, A>(effect: Lazy<A>, onThrow: (error: unknown) => E, __tsplusTrace?: string): FIO<E, A> {
-  return IO.defer(() => {
-    try {
-      return Exit.succeed(effect());
-    } catch (u) {
-      return IO.withFiberRuntime((fiberState) => {
-        if (!fiberState.isFatal(u)) {
-          throw new IOError(Cause.fail(onThrow(u)));
-        } else {
-          throw u;
-        }
-      });
-    }
-  });
-}
-
-/**
- * Returns an `IO` that submerges an `Either` into the `IO`.
- *
- * @tsplus getter fncts.io.IO absolve
- */
-export function absolve<R, E, E1, A>(ma: IO<R, E, Either<E1, A>>, __tsplusTrace?: string): IO<R, E | E1, A> {
-  return ma.flatMap((ea) => ea.match(IO.failNow, IO.succeedNow));
+  return (self: IO<R, E, A>): IO<R1, E1, A1> => f(self.swap).swap;
 }
 
 /**
@@ -1827,8 +1782,8 @@ export function tap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: st
  * @tsplus pipeable fncts.io.IO tapCause
  */
 export function tapCause<R, E, E2>(f: (e: Cause<E2>) => IO<R, E, any>, __tsplusTrace?: string) {
-  return <R2, A2>(ma: IO<R2, E2, A2>): IO<R2 | R, E | E2, A2> => {
-    return ma.matchCauseIO((c) => f(c).flatMap(() => IO.failCauseNow(c)), IO.succeedNow);
+  return <R2, A2>(self: IO<R2, E2, A2>): IO<R2 | R, E | E2, A2> => {
+    return self.matchCauseIO((c) => f(c).flatMap(() => IO.failCauseNow(c)), IO.succeedNow);
   };
 }
 
@@ -1861,6 +1816,37 @@ export function tapErrorCause<E, R1, E1>(f: (e: Cause<E>) => IO<R1, E1, any>, __
   };
 }
 
+/**
+ * A more powerful variation of `timed` that allows specifying the clock.
+ *
+ * @tsplus pipeable fncts.io.IO timedWith
+ */
+export function timedWith<R1, E1>(msTime: IO<R1, E1, number>, __tsplusTrace?: string) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R1 | R, E1 | E, readonly [number, A]> =>
+    self.summarized(msTime, (start, end) => end - start);
+}
+
+/**
+ * Creates a `IO` that has succeeded with a pure value
+ *
+ * @tsplus static fncts.io.IOOps tryCatch
+ */
+export function tryCatch<E, A>(effect: Lazy<A>, onThrow: (error: unknown) => E, __tsplusTrace?: string): FIO<E, A> {
+  return IO.defer(() => {
+    try {
+      return Exit.succeed(effect());
+    } catch (u) {
+      return IO.withFiberRuntime((fiberState) => {
+        if (!fiberState.isFatal(u)) {
+          throw new IOError(Cause.fail(onThrow(u)));
+        } else {
+          throw u;
+        }
+      });
+    }
+  });
+}
+
 /**
  * @tsplus pipeable fncts.io.IO tryOrElse
  */
@@ -1869,8 +1855,8 @@ export function tryOrElse<A, R1, E1, A1, R2, E2, A2>(
   onSuccess: (a: A) => IO<R2, E2, A2>,
   __tsplusTrace?: string,
 ) {
-  return <R, E>(ma: IO<R, E, A>): IO<R | R1 | R2, E1 | E2, A1 | A2> => {
-    return ma.matchCauseIO((cause) => cause.keepDefects.match(that, IO.failCauseNow), onSuccess);
+  return <R, E>(self: IO<R, E, A>): IO<R | R1 | R2, E1 | E2, A1 | A2> => {
+    return self.matchCauseIO((cause) => cause.keepDefects.match(that, IO.failCauseNow), onSuccess);
   };
 }
 
@@ -1898,8 +1884,8 @@ export function unjust<R, E, A>(self: IO<R, Maybe<E>, A>, __tsplusTrace?: string
  * @tsplus pipeable fncts.io.IO unrefineWith
  */
 export function unrefineWith<E, E1, E2>(pf: (u: unknown) => Maybe<E1>, f: (e: E) => E2, __tsplusTrace?: string) {
-  return <R, A>(fa: IO<R, E, A>): IO<R, E1 | E2, A> => {
-    return fa.catchAllCause((cause) =>
+  return <R, A>(self: IO<R, E, A>): IO<R, E1 | E2, A> => {
+    return self.catchAllCause((cause) =>
       cause.find((c) => (c.isHalt() ? pf(c.value) : Nothing())).match(() => IO.failCauseNow(cause.map(f)), IO.failNow),
     );
   };
@@ -1910,8 +1896,8 @@ export function unrefineWith<E, E1, E2>(pf: (u: unknown) => Maybe<E1>, f: (e: E)
  *
  * @tsplus getter fncts.io.IO unsandbox
  */
-export function unsandbox<R, E, A>(ma: IO<R, Cause<E>, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return ma.mapErrorCause((cause) => cause.flatten);
+export function unsandbox<R, E, A>(self: IO<R, Cause<E>, A>, __tsplusTrace?: string): IO<R, E, A> {
+  return self.mapErrorCause((cause) => cause.flatten);
 }
 
 /**
@@ -1935,12 +1921,29 @@ export function updateFiberRefs(
  */
 export const via: typeof pipe = pipe;
 
+/**
+ * @tsplus static fncts.io.IOOps stackTrace
+ */
+export function stackTrace(__tsplusTrace?: string): UIO<Trace> {
+  return IO.withFiberRuntime((state) => IO.succeedNow(state.generateStackTrace()));
+}
+
+/**
+ * @tsplus static fncts.io.IOOps updateRuntimeFlags
+ */
+export function updateRuntimeFlags(patch: RuntimeFlags.Patch, __tsplusTrace?: string): IO<never, never, void> {
+  const io = new IOPrimitive(IOTag.UpdateRuntimeFlags) as any;
+  io.i0    = patch;
+  io.trace = __tsplusTrace;
+  return io;
+}
+
 /**
  * @tsplus pipeable fncts.io.IO when
  */
 export function when(b: Lazy<boolean>, __tsplusTrace?: string) {
-  return <R, E, A>(ma: IO<R, E, A>): IO<R, E, void> => {
-    return ma.whenIO(IO.succeed(b));
+  return <R, E, A>(self: IO<R, E, A>): IO<R, E, void> => {
+    return self.whenIO(IO.succeed(b));
   };
 }
 
@@ -1951,11 +1954,27 @@ export function when(b: Lazy<boolean>, __tsplusTrace?: string) {
  * @tsplus static fncts.io.IOOps whenIO
  */
 export function whenIO<R1, E1>(mb: IO<R1, E1, boolean>, __tsplusTrace?: string) {
-  return <R, E, A>(ma: IO<R, E, A>): IO<R1 | R, E | E1, Maybe<A>> => {
-    return mb.flatMap((b) => (b ? ma.asJust : IO.nothing));
+  return <R, E, A>(self: IO<R, E, A>): IO<R1 | R, E | E1, Maybe<A>> => {
+    return mb.flatMap((b) => (b ? self.asJust : IO.nothing));
   };
 }
 
+/**
+ * @tsplus static fncts.io.IOOps whileLoop
+ */
+export function whileLoop<R, E, A>(
+  check: Lazy<boolean>,
+  body: Lazy<IO<R, E, A>>,
+  process: (a: A) => any,
+  __tsPlusTrace?: string,
+): IO<R, E, void> {
+  const io = new IOPrimitive(IOTag.WhileLoop);
+  io.i0    = check;
+  io.i1    = body;
+  io.i2    = process;
+  return io as WhileLoop;
+}
+
 /**
  * @tsplus static fncts.io.IOOps withFiberRuntime
  */
@@ -1969,25 +1988,6 @@ export function withFiberRuntime<R, E, A>(
   return io;
 }
 
-/**
- * @tsplus static fncts.io.IOOps updateRuntimeFlags
- */
-export function updateRuntimeFlags(patch: RuntimeFlags.Patch, __tsplusTrace?: string): IO<never, never, void> {
-  const io = new IOPrimitive(IOTag.UpdateRuntimeFlags) as any;
-  io.i0    = patch;
-  io.trace = __tsplusTrace;
-  return io;
-}
-
-/**
- * @tsplus static fncts.io.IOOps stackTrace
- */
-export function stackTrace(__tsplusTrace?: string): UIO<Trace> {
-  const io = new IOPrimitive(IOTag.GenerateStackTrace) as any;
-  io.trace = __tsplusTrace;
-  return io;
-}
-
 /**
  * Returns an effect that yields to the runtime system, starting on a fresh
  * stack. Manual use of this method can improve fairness, at the cost of
@@ -2006,6 +2006,28 @@ export function zip<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: string) {
   };
 }
 
+/**
+ * @tsplus pipeable fncts.io.IO zipLeft
+ * @tsplus pipeable-operator fncts.io.IO <
+ */
+export function zipLeft<R1, E1, B>(fb: IO<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R1 | R, E1 | E, A> => {
+    return self.flatMap((a) => fb.map(() => a));
+  };
+}
+
+/**
+ * Combine two effectful actions, keeping only the result of the second
+ *
+ * @tsplus pipeable fncts.io.IO zipRight
+ * @tsplus pipeable-operator fncts.io.IO >
+ */
+export function zipRight<R1, E1, B>(fb: IO<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R1 | R, E1 | E, B> => {
+    return self.flatMap(() => fb);
+  };
+}
+
 /**
  * @tsplus pipeable fncts.io.IO zipWith
  */
@@ -2015,6 +2037,13 @@ export function zipWith<A, R1, E1, B, C>(that: IO<R1, E1, B>, f: (a: A, b: B) =>
   };
 }
 
+/**
+ * @internal
+ */
+export const __adapter = (_: any) => {
+  return _;
+};
+
 export class GenIO<R, E, A> {
   readonly _R!: () => R;
   readonly _E!: () => E;
@@ -2030,13 +2059,6 @@ export class GenIO<R, E, A> {
   }
 }
 
-/**
- * @internal
- */
-export const __adapter = (_: any) => {
-  return _;
-};
-
 const adapter = (_: any, __tsplusTrace?: string) => {
   return new GenIO(__adapter(_), __tsplusTrace);
 };