@fncts/io 0.0.20 → 0.0.22

package/_src/IO/api.ts

@@ -1,26 +1,21 @@
-import type { FiberStatus } from "../FiberStatus.js";
+import type { Running } from "../FiberStatus.js";
 import type * as P from "@fncts/base/typeclass";
 import type { _E, _R } from "@fncts/base/types";
-import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
-import type { Canceler } from "@fncts/io/IO/definition";
+import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
+import type { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 
 import { identity, pipe, tuple } from "@fncts/base/data/function";
-import { Stateful } from "@fncts/io/IO/definition";
 import {
   Async,
-  Chain,
-  Defer,
-  DeferWith,
-  Fail,
-  Fork,
-  IO,
-  IOError,
-  Logged,
-  Match,
-  Succeed,
-  SucceedNow,
-  Yield,
+  GenerateStackTrace,
+  OnSuccess,
+  OnSuccessAndFailure,
+  Sync,
+  UpdateRuntimeFlags,
+  YieldNow,
 } from "@fncts/io/IO/definition";
+import { Stateful } from "@fncts/io/IO/definition";
+import { Fail, IO, IOError, SucceedNow } from "@fncts/io/IO/definition";
 
 /**
  * Imports an asynchronous side-effect into a `IO`
@@ -32,103 +27,49 @@ export function async<R, E, A>(
   blockingOn: FiberId = FiberId.none,
   __tsplusTrace?: string,
 ): IO<R, E, A> {
-  return IO.asyncMaybe(
-    (cb) => {
-      register(cb);
-      return Nothing();
-    },
-    blockingOn,
-    __tsplusTrace,
-  );
-}
-
-/**
- * Imports an asynchronous effect into a pure `IO`, possibly returning the value synchronously.
- *
- * If the register function returns a value synchronously, then the callback
- * function must not be called. Otherwise the callback function must be called at most once.
- *
- * @tsplus static fncts.io.IOOps asyncMaybe
- */
-export function asyncMaybe<R, E, A>(
-  register: (resolve: (_: IO<R, E, A>) => void) => Maybe<IO<R, E, A>>,
-  blockingOn: FiberId = FiberId.none,
-  __tsplusTrace?: string,
-): IO<R, E, A> {
-  return asyncInterrupt(
-    (cb) => register(cb).match(() => Either.left(IO.unit), Either.right),
-    blockingOn,
-    __tsplusTrace,
-  );
-}
-
-/**
- * Imports an asynchronous side-effect into an IO. The side-effect
- * has the option of returning the value synchronously, which is useful in
- * cases where it cannot be determined if the effect is synchronous or
- * asynchronous until the side-effect is actually executed. The effect also
- * has the option of returning a canceler, which will be used by the runtime
- * to cancel the asynchronous effect if the fiber executing the effect is
- * interrupted.
- *
- * If the register function returns a value synchronously, then the callback
- * function must not be called. Otherwise the callback function must be called
- * at most once.
- *
- * The list of fibers, that may complete the async callback, is used to
- * provide better diagnostics.
- *
- * @tsplus static fncts.io.IOOps asyncInterrupt
- */
-export function asyncInterrupt<R, E, A>(
-  register: (cb: (resolve: IO<R, E, A>) => void) => Either<Canceler<R>, IO<R, E, A>>,
-  blockingOn: FiberId = FiberId.none,
-  __tsplusTrace?: string,
-): IO<R, E, A> {
-  return new Async(register, blockingOn, __tsplusTrace);
+  return new Async(register, () => blockingOn, __tsplusTrace);
 }
 
 /**
  * Attempts to convert defects into a failure, throwing away all information
  * about the cause of the failure.
  *
- * @tsplus fluent fncts.io.IO absorbWith
+ * @tsplus pipeable fncts.io.IO absorbWith
  */
-export function absorbWith_<R, E, A>(ma: IO<R, E, A>, f: (e: E) => unknown, __tsplusTrace?: string) {
-  return ma.sandbox.matchIO((cause) => IO.failNow(cause.squashWith(f)), IO.succeedNow);
+export function absorbWith<R, E, A>(f: (e: E) => unknown, __tsplusTrace?: string) {
+  return (ma: IO<R, E, A>): IO<R, unknown, A> =>
+    ma.sandbox.matchIO((cause) => IO.failNow(cause.squashWith(f)), IO.succeedNow);
 }
 
 /**
- * @tsplus fluent fncts.io.IO apFirst
- * @tsplus operator fncts.io.IO <
+ * @tsplus pipeable fncts.io.IO zipLeft
+ * @tsplus pipeable-operator fncts.io.IO <
  */
-export function apFirst_<R, E, A, R1, E1, B>(
-  self: IO<R, E, A>,
-  fb: IO<R1, E1, B>,
-  __tsplusTrace?: string,
-): IO<R1 | R, E1 | E, A> {
-  return self.flatMap((a) => fb.map(() => a));
+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 fluent fncts.io.IO apSecond
- * @tsplus operator fncts.io.IO >
+ * @tsplus pipeable fncts.io.IO zipRight
+ * @tsplus pipeable-operator fncts.io.IO >
  */
-export function apSecond_<R, E, A, R1, E1, B>(
-  self: IO<R, E, A>,
-  fb: IO<R1, E1, B>,
-  __tsplusTrace?: string,
-): IO<R1 | R, E1 | E, B> {
-  return self.flatMap(() => fb);
+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 fluent fncts.io.IO as
+ * @tsplus pipeable fncts.io.IO as
  */
-export function as_<R, E, A, B>(self: IO<R, E, A>, b: Lazy<B>, __tsplusTrace?: string): IO<R, E, B> {
-  return self.map(() => b());
+export function as<B>(b: Lazy<B>, __tsplusTrace?: string) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R, E, B> => {
+    return self.map(() => b());
+  };
 }
 
 /**
@@ -160,116 +101,124 @@ export function asUnit<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R
  * Returns an IO whose failure and success channels have been mapped by
  * the specified pair of functions, `f` and `g`.
  *
- * @tsplus fluent fncts.io.IO bimap
+ * @tsplus pipeable fncts.io.IO bimap
  */
-export function bimap_<R, E, A, E1, B>(
-  self: IO<R, E, A>,
-  f: (e: E) => E1,
-  g: (a: A) => B,
-  __tsplusTrace?: string,
-): IO<R, E1, B> {
-  return self.matchIO(
-    (e) => IO.failNow(f(e)),
-    (a) => IO.succeedNow(g(a)),
-  );
+export function bimap<E, A, E1, B>(f: (e: E) => E1, g: (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)),
+    );
+  };
 }
 
 /**
  * Returns an IO that effectfully "peeks" at the failure or success of
  * this effect.
  *
- * @tsplus fluent fncts.io.IO bitap
+ * @tsplus pipeable fncts.io.IO bitap
  */
-export function bitap_<R, E, A, R1, E1, R2, E2>(
-  self: IO<R, E, A>,
+export function bitap<E, A, R1, E1, R2, E2>(
   onFailure: (e: E) => IO<R1, E1, any>,
   onSuccess: (a: A) => IO<R2, E2, any>,
   __tsplusTrace?: string,
-): IO<R | R1 | R2, E | E1 | E2, A> {
-  return self.matchCauseIO(
-    (cause) =>
-      cause.failureOrCause.match(
-        (e) => onFailure(e).flatMap(() => IO.failCauseNow(cause)),
-        () => IO.failCauseNow(cause),
-      ),
-    (a) => onSuccess(a).apSecond(IO.succeedNow(a)),
-  );
+) {
+  return <R>(self: IO<R, E, A>): IO<R | R1 | R2, E | E1 | E2, A> => {
+    return self.matchCauseIO(
+      (cause) =>
+        cause.failureOrCause.match(
+          (e) => onFailure(e).flatMap(() => IO.failCauseNow(cause)),
+          () => IO.failCauseNow(cause),
+        ),
+      (a) => onSuccess(a).zipRight(IO.succeedNow(a)),
+    );
+  };
 }
 
 /**
  * Recovers from the specified error
  *
- * @tsplus fluent fncts.io.IO catch
+ * @tsplus pipeable fncts.io.IO catch
  */
-export function catch_<N extends keyof E, K extends E[N] & string, R, E, A, R1, E1, A1>(
-  ma: IO<R, E, A>,
+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>,
+  f: (
+    e: Extract<
+      E,
+      {
+        [n in N]: K;
+      }
+    >,
+  ) => IO<R1, E1, A1>,
   __tsplusTrace?: string,
-): IO<R | R1, Exclude<E, { [n in N]: K }> | E1, A | A1> {
-  return ma.catchAll((e) => {
-    if (tag in e && e[tag] === k) {
-      return f(e as any);
-    }
-    return IO.failNow(e as any);
-  });
+) {
+  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 fluent fncts.io.IO catchAll
+ * @tsplus pipeable fncts.io.IO catchAll
  */
-export function catchAll_<R, E, A, R1, E1, A1>(
-  ma: IO<R, E, A>,
-  f: (e: E) => IO<R1, E1, A1>,
-  __tsplusTrace?: string,
-): IO<R | R1, E1, A | A1> {
-  return ma.matchIO(f, IO.succeedNow);
+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);
+  };
 }
 
 /**
  *
  * Recovers from all errors with provided cause.
  *
- * @tsplus fluent fncts.io.IO catchAllCause
+ * @tsplus pipeable fncts.io.IO catchAllCause
  */
-export function catchAllCause_<R, E, A, R1, E1, A1>(
-  ma: IO<R, E, A>,
-  f: (_: Cause<E>) => IO<R1, E1, A1>,
-  __tsplusTrace?: string,
-) {
-  return ma.matchCauseIO(f, IO.succeedNow);
+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);
 }
 
 /**
  * Recovers from some or all of the error cases.
  *
- * @tsplus fluent fncts.io.IO catchJust
+ * @tsplus pipeable fncts.io.IO catchJust
  */
-export function catchJust_<R, E, A, R1, E1, A1>(
-  ma: IO<R, E, A>,
-  f: (e: E) => Maybe<IO<R1, E1, A1>>,
-  __tsplusTrace?: string,
-): IO<R | R1, E | E1, A | A1> {
-  return ma.matchCauseIO(
-    (cause) => cause.failureOrCause.match((e) => f(e).getOrElse(IO.failCauseNow(cause)), IO.failCauseNow),
-    IO.succeedNow,
-  );
+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),
+      IO.succeedNow,
+    );
+  };
 }
 
 /**
  * Recovers from some or all of the error cases with provided cause.
  *
- * @tsplus fluent fncts.io.IO catchJustCause
+ * @tsplus pipeable fncts.io.IO catchJustCause
  */
-export function catchJustCause_<R, E, A, R1, E1, A1>(
-  ma: IO<R, E, A>,
-  f: (_: Cause<E>) => Maybe<IO<R1, E1, A1>>,
-  __tsplusTrace?: string,
-): 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>(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);
+  };
 }
 
 /**
@@ -280,28 +229,54 @@ export function catchJustCause_<R, E, A, R1, E1, A1>(
  * system, to transmit information on a defect for diagnostic or explanatory
  * purposes.
  *
- * @tsplus fluent fncts.io.IO catchJustDefect
+ * @tsplus pipeable fncts.io.IO catchJustDefect
  */
-export function catchJustDefect_<R, E, A, R1, E1, A1>(
-  ma: IO<R, E, A>,
-  f: (_: unknown) => Maybe<IO<R1, E1, A1>>,
-  __tsplusTrace?: string,
-): 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>(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>);
+  };
 }
 
 /**
  * Recovers from the specified error
  *
- * @tsplus fluent IO catchTag
- */
-export function catchTag_<K extends E["_tag"] & string, R, E extends { _tag: string }, A, R1, E1, A1>(
-  ma: IO<R, E, A>,
+ * @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>,
+  f: (
+    e: Extract<
+      E,
+      {
+        _tag: K;
+      }
+    >,
+  ) => IO<R1, E1, A1>,
   __tsplusTrace?: string,
-): IO<R | R1, Exclude<E, { _tag: K }> | E1, A | A1> {
-  return ma.catch("_tag", k, f);
+) {
+  return <R, A>(
+    ma: IO<R, E, A>,
+  ): IO<
+    R | R1,
+    | Exclude<
+        E,
+        {
+          _tag: K;
+        }
+      >
+    | E1,
+    A | A1
+  > => {
+    return ma.catch("_tag", k, f);
+  };
 }
 
 /**
@@ -312,79 +287,71 @@ export function cause<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, n
 }
 
 /**
- * @tsplus fluent fncts.io.IO causeAsError
+ * @tsplus pipeable fncts.io.IO causeAsError
  */
-export function causeAsError<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, Cause<E>, A> {
-  return ma.matchCauseIO(IO.failNow, IO.succeedNow);
+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);
+  };
 }
 
 /**
- * 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.
+ * Checks the interrupt status, and produces the IO returned by the
+ * specified callback.
  *
- * @tsplus fluent fncts.io.IO flatMap
+ * @tsplus static fncts.io.IOOps checkInterruptible
  */
-export function flatMap_<R, E, A, R1, E1, B>(
-  ma: IO<R, E, A>,
-  f: (a: A) => IO<R1, E1, B>,
+export function checkInterruptible<R, E, A>(
+  f: (i: InterruptStatus) => IO<R, E, A>,
   __tsplusTrace?: string,
-): IO<R | R1, E | E1, B> {
-  return new Chain(ma, f, __tsplusTrace);
+): IO<R, E, A> {
+  return IO.withFiberRuntime((_, status) => f(InterruptStatus.fromBoolean(status.runtimeFlags.interruption)));
 }
 
 /**
- * @tsplus fluent fncts.io.IO flatMapError
+ * 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 flatMapError_<R, R1, E, E1, A>(
-  ma: IO<R, E, A>,
-  f: (e: E) => IO<R1, never, E1>,
-  __tsplusTrace?: string,
-): IO<R | R1, E1, A> {
-  return ma.swapWith((effect) => effect.flatMap(f));
+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> => {
+    return new OnSuccess(ma, f, __tsplusTrace);
+  };
 }
 
 /**
- * Checks the interrupt status, and produces the IO returned by the
- * specified callback.
- *
- * @tsplus static fncts.io.IOOps checkInterruptible
+ * @tsplus pipeable fncts.io.IO flatMapError
  */
-export function checkInterruptible<R, E, A>(
-  f: (i: InterruptStatus) => IO<R, E, A>,
-  __tsplusTrace?: string,
-): IO<R, E, A> {
-  return IO.withFiberContext((fiber) => f(InterruptStatus.fromBoolean(fiber.unsafeIsInterruptible)));
+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));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.IO collect
+ * @tsplus pipeable fncts.io.IO collect
  */
-export function collect_<R, E, A, E1, A1>(
-  ma: IO<R, E, A>,
-  f: Lazy<E1>,
-  pf: (a: A) => Maybe<A1>,
-  __tsplusTrace?: string,
-): IO<R, E | E1, A1> {
-  return ma.collectIO(f, (a) => pf(a).map(IO.succeedNow));
+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));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.IO collectIO
+ * @tsplus pipeable fncts.io.IO collectIO
  */
-export function collectIO_<R, E, A, R1, E1, A1, E2>(
-  ma: IO<R, E, A>,
-  f: Lazy<E2>,
-  pf: (a: A) => Maybe<IO<R1, E1, A1>>,
-  __tsplusTrace?: string,
-): IO<R | R1, E | E1 | E2, A1> {
-  return ma.flatMap((a) => pf(a).getOrElse(IO.fail(f)));
+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)));
+  };
 }
 
 /**
  * @tsplus static fncts.io.IOOps condIO
  */
-export function condIO_<R, R1, E, A>(
+export function condIO<R, R1, E, A>(
   b: boolean,
   onTrue: URIO<R, A>,
   onFalse: URIO<R1, E>,
@@ -402,22 +369,7 @@ export function condIO_<R, R1, E, A>(
  * @tsplus static fncts.io.IOOps defer
  */
 export function defer<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, A> {
-  return new Defer(io, __tsplusTrace);
-}
-
-/**
- * Returns a lazily constructed effect, whose construction may itself require
- * effects. The effect must not throw any exceptions. When no environment is required (i.e., when R == unknown)
- * it is conceptually equivalent to `flatten(effectTotal(io))`. If you wonder if the effect throws exceptions,
- * do not use this method, use `IO.deferTryCatchWith`.
- *
- * @tsplus static fncts.io.IOOps deferWith
- */
-export function deferWith<R, E, A>(
-  io: (runtimeConfig: RuntimeConfig, id: FiberId) => IO<R, E, A>,
-  __tsplusTrace?: string,
-): IO<R, E, A> {
-  return new DeferWith(io, __tsplusTrace);
+  return IO.succeed(io).flatMap(identity);
 }
 
 /**
@@ -431,30 +383,11 @@ export function deferTry<R, E, A>(io: () => IO<R, E, A>, __tsplusTrace?: string)
     try {
       return io();
     } catch (u) {
-      throw new IOError(Exit.fail(u));
+      throw new IOError(Cause.fail(u));
     }
   }, __tsplusTrace);
 }
 
-/**
- * Returns a lazily constructed effect, whose construction may itself require effects.
- * When no environment is required (i.e., when R == unknown) it is conceptually equivalent to `flatten(effect(io))`.
- *
- * @tsplus static IOOps deferTryWith
- */
-export function deferTryWith<R, E, A>(
-  io: (runtimeConfig: RuntimeConfig, id: FiberId) => IO<R, E, A>,
-  __tsplusTrace?: string,
-): IO<R, unknown, A> {
-  return IO.deferWith((runtimeConfig, id) => {
-    try {
-      return io(runtimeConfig, id);
-    } catch (u) {
-      throw new IOError(Exit.fail(u));
-    }
-  });
-}
-
 /**
  * Returns a lazily constructed effect, whose construction may itself require effects,
  * translating any thrown exceptions into typed failed effects and mapping the error.
@@ -472,48 +405,11 @@ export function deferTryCatch<R, E, A, E1>(
     try {
       return io();
     } catch (u) {
-      throw new IOError(Exit.fail(onThrow(u)));
+      throw new IOError(Cause.fail(onThrow(u)));
     }
   });
 }
 
-/**
- * Returns a lazily constructed effect, whose construction may itself require effects,
- * translating any thrown exceptions into typed failed effects and mapping the error.
- *
- * When no environment is required (i.e., when R == unknown) it is conceptually equivalent to `flatten(effect(io))`.
- *
- * @tsplus static IOOps deferTryCatchWith
- */
-export function deferTryCatchWith<R, E, A, E1>(
-  io: (runtimeConfig: RuntimeConfig, id: FiberId) => IO<R, E, A>,
-  onThrow: (error: unknown) => E1,
-  __tsplusTrace?: string,
-): IO<R, E | E1, A> {
-  return IO.deferWith((runtimeConfig, id) => {
-    try {
-      return io(runtimeConfig, id);
-    } catch (u) {
-      throw new IOError(Exit.fail(onThrow(u)));
-    }
-  });
-}
-
-/**
- * @tsplus static fncts.io.IOOps descriptor
- */
-export const descriptor = descriptorWith(IO.succeedNow);
-
-/**
- * Constructs an IO based on information about the current fiber, such as
- * its identity.
- *
- * @tsplus static fncts.io.IOOps descriptorWith
- */
-export function descriptorWith<R, E, A>(f: (d: FiberDescriptor) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return IO.withFiberContext((fiber) => f(fiber.unsafeGetDescriptor()));
-}
-
 /**
  * Folds an `IO` that may fail with `E` or succeed with `A` into one that never fails but succeeds with `Either<E, A>`
  *
@@ -524,24 +420,12 @@ export function either<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R
 }
 
 /**
- * @tsplus fluent fncts.io.IO ensuring
- */
-export function ensuring_<R, E, A, R1>(
-  self: IO<R, E, A>,
-  finalizer: IO<R1, never, any>,
-  __tsplusTrace?: string,
-): IO<R | R1, E, A> {
-  return IO.withFiberContext((fiber) => {
-    fiber.unsafeAddFinalizer(finalizer);
-    return self;
-  });
-}
-
-/**
- * @tsplus fluent fncts.io.IO errorAsCause
+ * @tsplus pipeable fncts.io.IO errorAsCause
  */
-export function errorAsCause<R, E, A>(ma: IO<R, Cause<E>, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return ma.matchIO(IO.failCauseNow, IO.succeedNow);
+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);
+  };
 }
 
 /**
@@ -552,24 +436,33 @@ export function eventually<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO
 }
 
 /**
- * @tsplus fluent fncts.io.IO extend
+ * @tsplus pipeable fncts.io.IO extend
  */
-export function extend_<R, E, A, B>(wa: IO<R, E, A>, f: (wa: IO<R, E, A>) => B, __tsplusTrace?: string): IO<R, E, B> {
-  return wa.matchIO(IO.failNow, (_) => IO.succeed(f(wa)));
+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)));
+  };
 }
 
 /**
  * @tsplus static fncts.io.IOOps fail
  */
 export function fail<E>(e: Lazy<E>, __tsplusTrace?: string): FIO<E, never> {
-  return new Fail(() => Cause.fail(e()), __tsplusTrace);
+  return IO.failCause(Cause.fail(e()));
 }
 
 /**
  * @tsplus static fncts.io.IOOps failNow
  */
 export function failNow<E>(e: E, __tsplusTrace?: string): FIO<E, never> {
-  return new Fail(() => Cause.fail(e), __tsplusTrace);
+  return IO.failCause(Cause.fail(e));
+}
+
+/**
+ * @tsplus static fncts.io.IOOps refailCause
+ */
+export function refailCause<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E, never> {
+  return new Fail(() => cause, __tsplusTrace);
 }
 
 /**
@@ -587,7 +480,7 @@ export function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E,
  * @tsplus static fncts.io.IOOps failCause
  */
 export function failCause<E = never, A = never>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): FIO<E, A> {
-  return new Fail(cause, __tsplusTrace);
+  return IO.stackTrace(__tsplusTrace).flatMap((trace) => IO.refailCause(Cause.traced(cause(), trace)));
 }
 
 /**
@@ -595,14 +488,14 @@ export function failCause<E = never, A = never>(cause: Lazy<Cause<E>>, __tsplusT
  *
  * @tsplus static fncts.io.IOOps fiberId
  */
-export const fiberId: IO<never, never, FiberId> = IO.descriptorWith((d) => IO.succeedNow(d.id));
+export const fiberId: IO<never, never, FiberId> = IO.withFiberRuntime((fiber) => IO.succeed(fiber.id));
 
 /**
  * Filters the collection using the specified effectual predicate.
  *
  * @tsplus static fncts.io.IOOps filter
  */
-export function filter_<A, R, E>(
+export function filter<A, R, E>(
   as: Iterable<A>,
   f: (a: A) => IO<R, E, boolean>,
   __tsplusTrace?: string,
@@ -622,7 +515,7 @@ export function filter_<A, R, E>(
 /**
  * @tsplus static fncts.io.IOOps filterMap
  */
-export function filterMap_<A, R, E, B>(
+export function filterMap<A, R, E, B>(
   as: Iterable<A>,
   f: (a: A) => IO<R, E, Maybe<B>>,
   __tsplusTrace?: string,
@@ -633,7 +526,7 @@ export function filterMap_<A, R, E, B>(
 /**
  * @tsplus static fncts.io.IOOps filterMapWithIndex
  */
-export function filterMapWithIndex_<A, R, E, B>(
+export function filterMapWithIndex<A, R, E, B>(
   as: Iterable<A>,
   f: (i: number, a: A) => IO<R, E, Maybe<B>>,
   __tsplusTrace?: string,
@@ -656,7 +549,7 @@ export function filterMapWithIndex_<A, R, E, B>(
  *
  * @tsplus static fncts.io.IOOps filterNot
  */
-export function filterNot_<A, R, E>(
+export function filterNot<A, R, E>(
   as: Iterable<A>,
   f: (a: A) => IO<R, E, boolean>,
   __tsplusTrace?: string,
@@ -667,54 +560,43 @@ export function filterNot_<A, R, E>(
 /**
  * Applies `or` if the predicate fails.
  *
- * @tsplus fluent fncts.io.IO filterOrElse
+ * @tsplus pipeable fncts.io.IO filterOrElse
  */
-export function filterOrElse_<R, E, A, B extends A, R1, E1, A1>(
-  fa: IO<R, E, A>,
+export function filterOrElse<A, B extends A, R1, E1, A1>(
   refinement: Refinement<A, B>,
   or: (a: Exclude<A, B>) => IO<R1, E1, A1>,
   __tsplusTrace?: string,
-): IO<R | R1, E | E1, B | A1>;
-export function filterOrElse_<R, E, A, R1, E1, A1>(
-  fa: IO<R, E, A>,
+): <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,
-): IO<R | R1, E | E1, A | A1>;
-export function filterOrElse_<R, E, A, R1, E1, A1>(
-  fa: IO<R, E, A>,
-  predicate: Predicate<A>,
-  or: unknown,
-  __tsplusTrace?: string,
-): IO<R | R1, E | E1, A | A1> {
-  return flatMap_(
-    fa,
-    (a): IO<R1, E1, A | A1> => (predicate(a) ? IO.succeedNow(a) : IO.defer((or as (a: A) => IO<R1, E1, A1>)(a))),
-  );
+): <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(
+      (a): IO<R1, E1, A | A1> => (predicate(a) ? IO.succeedNow(a) : IO.defer((or as (a: A) => IO<R1, E1, A1>)(a))),
+    );
+  };
 }
 
 /**
  * Fails with `failWith` if the predicate fails.
  *
- * @tsplus fluent fncts.io.IO filterOrFail
+ * @tsplus pipeable fncts.io.IO filterOrFail
  */
-export function filterOrFail_<R, E, A, B extends A, E1>(
-  fa: IO<R, E, A>,
+export function filterOrFail<A, B extends A, E1>(
   refinement: Refinement<A, B>,
   failWith: (a: Exclude<A, B>) => E1,
-): IO<R, E | E1, B>;
-export function filterOrFail_<R, E, A, E1>(
-  fa: IO<R, E, A>,
+): <R, E>(fa: IO<R, E, A>) => IO<R, E | E1, B>;
+export function filterOrFail<A, E1>(
   predicate: Predicate<A>,
   failWith: (a: A) => E1,
-): IO<R, E | E1, A>;
-export function filterOrFail_<R, E, A, E1>(
-  fa: IO<R, E, A>,
-  predicate: Predicate<A>,
-  failWith: unknown,
-  __tsplusTrace?: string,
-): IO<R, E | E1, A> {
-  return filterOrElse_(fa, predicate, (a) => IO.failNow((failWith as (a: A) => E1)(a)));
+): <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)));
+  };
 }
 
 /**
@@ -730,27 +612,22 @@ export function firstSuccess<R, E, A>(mas: NonEmptyArray<IO<R, E, A>>, __tsplusT
 /**
  * Halts with specified `unknown` if the predicate fails.
  *
- * @tsplus fluent fncts.io.IO filterOrHalt
+ * @tsplus pipeable fncts.io.IO filterOrHalt
  */
-export function filterOrHalt_<R, E, A, B extends A>(
-  fa: IO<R, E, A>,
+export function filterOrHalt<A, B extends A>(
   refinement: Refinement<A, B>,
   haltWith: (a: Exclude<A, B>) => unknown,
   __tsplusTrace?: string,
-): IO<R, E, A>;
-export function filterOrHalt_<R, E, A>(
-  fa: IO<R, E, A>,
+): <R, E>(fa: IO<R, E, A>) => IO<R, E, A>;
+export function filterOrHalt<A>(
   predicate: Predicate<A>,
   haltWith: (a: A) => unknown,
   __tsplusTrace?: string,
-): IO<R, E, A>;
-export function filterOrHalt_<R, E, A>(
-  fa: IO<R, E, A>,
-  predicate: Predicate<A>,
-  haltWith: unknown,
-  __tsplusTrace?: string,
-): IO<R, E, A> {
-  return fa.filterOrElse(predicate, (a) => IO.haltNow((haltWith as (a: A) => unknown)(a)));
+): <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)));
+  };
 }
 
 /**
@@ -765,7 +642,7 @@ export function flatten<R, E, R1, E1, A>(self: IO<R, E, IO<R1, E1, A>>, __tsplus
  *
  * @tsplus static fncts.io.IOOps foldLeft
  */
-export function foldLeft_<A, B, R, E>(
+export function foldLeft<A, B, R, E>(
   as: Iterable<A>,
   b: B,
   f: (b: B, a: A) => IO<R, E, B>,
@@ -779,12 +656,12 @@ export function foldLeft_<A, B, R, E>(
  *
  * @tsplus static fncts.io.IOOps foldMap
  */
-export function foldMap_<R, E, A, M>(
+export function foldMap<R, E, A, M>(
   as: 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(m, f(a))));
+  return IO.foldLeft(as, M.nat, (m, a) => a.map((a) => M.combine(f(a))(m)));
 }
 
 function foldRightLoop<A, B, R, E>(
@@ -802,7 +679,7 @@ function foldRightLoop<A, B, R, E>(
  *
  * @tsplus static fncts.io.IOOps foldRight
  */
-export function foldRight_<A, B, R, E>(
+export function foldRight<A, B, R, E>(
   as: Iterable<A>,
   b: UIO<B>,
   f: (a: A, b: IO<R, E, B>) => IO<R, E, B>,
@@ -830,7 +707,7 @@ function foreachWithIndexDiscardLoop<A, R, E, B>(
  *
  * @tsplus static fncts.io.IOOps foreach
  */
-export function foreach_<A, R, E, B>(
+export function foreach<A, R, E, B>(
   as: Iterable<A>,
   f: (a: A) => IO<R, E, B>,
   __tsplusTrace?: string,
@@ -855,7 +732,7 @@ export function foreach_<A, R, E, B>(
  *
  * @tsplus static fncts.io.IOOps foreachWithIndex
  */
-export function foreachWithIndex_<A, R, E, B>(
+export function foreachWithIndex<A, R, E, B>(
   as: Iterable<A>,
   f: (i: number, a: A) => IO<R, E, B>,
   __tsplusTrace?: string,
@@ -874,7 +751,7 @@ export function foreachWithIndex_<A, R, E, B>(
 /**
  * @tsplus static fncts.io.IOOps foreachWithIndexDiscard
  */
-export function foreachWithIndexDiscard_<A, R, E, B>(
+export function foreachWithIndexDiscard<A, R, E, B>(
   as: Iterable<A>,
   f: (i: number, a: A) => IO<R, E, B>,
   __tsplusTrace?: string,
@@ -888,7 +765,7 @@ export function foreachWithIndexDiscard_<A, R, E, B>(
  *
  * @tsplus static fncts.io.IOOps foreachDiscard
  */
-export function foreachDiscard_<A, R, E, B>(
+export function foreachDiscard<A, R, E, B>(
   as: Iterable<A>,
   f: (a: A) => IO<R, E, B>,
   __tsplusTrace?: string,
@@ -902,35 +779,7 @@ export function foreachDiscard_<A, R, E, B>(
  * @tsplus getter fncts.io.IO forever
  */
 export function forever<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, never> {
-  return ma.apSecond(IO.yieldNow).flatMap(() => ma.forever);
-}
-
-/**
- * Returns an IO that forks this IO into its own separate fiber,
- * returning the fiber immediately, without waiting for it to begin executing
- * the IO.
- *
- * You can use the `fork` method whenever you want to execute an IO in a
- * new fiber, concurrently and without "blocking" the fiber executing other
- * IOs. Using fibers can be tricky, so instead of using this method
- * directly, consider other higher-level methods, such as `raceWith`,
- * `zipPar`, and so forth.
- *
- * The fiber returned by this method has methods interrupt the fiber and to
- * wait for it to finish executing the IO. See `Fiber` for more
- * information.
- *
- * Whenever you use this method to launch a new fiber, the new fiber is
- * attached to the parent fiber's scope. This means when the parent fiber
- * terminates, the child fiber will be terminated as well, ensuring that no
- * fibers leak. This behavior is called "None supervision", and if this
- * behavior is not desired, you may use the `forkDaemon` or `forkIn`
- * methods.
- *
- * @tsplus getter fncts.io.IO fork
- */
-export function fork<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R, FiberContext<E, A>> {
-  return new Fork(ma, Nothing(), __tsplusTrace);
+  return ma.zipRight(IO.yieldNow).flatMap(() => ma.forever);
 }
 
 /**
@@ -946,6 +795,7 @@ export function fromEither<E, A>(either: Lazy<Either<E, A>>, __tsplusTrace?: str
  * Lifts an `Either` into an `IO`
  *
  * @tsplus static fncts.io.IOOps fromEitherNow
+ * @tsplus getter fncts.Either toIO
  */
 export function fromEitherNow<E, A>(either: Either<E, A>, __tsplusTrace?: string): IO<never, E, A> {
   return either.match(IO.failNow, IO.succeedNow);
@@ -955,6 +805,7 @@ export function fromEitherNow<E, A>(either: Either<E, A>, __tsplusTrace?: string
  * Lifts an `Eval` into an `IO`
  *
  * @tsplus static fncts.io.IOOps fromEval
+ * @tsplus getter fncts.Eval toIO
  */
 export function fromEval<A>(computation: Eval<A>, __tsplusTrace?: string): IO<never, never, A> {
   return IO.succeed(computation.run);
@@ -973,6 +824,7 @@ export function fromExit<E, A>(exit: Lazy<Exit<E, A>>, __tsplusTrace?: string):
  * Creates a `IO` from an exit value
  *
  * @tsplus static fncts.io.IOOps fromExitNow
+ * @tsplus getter fncts.Exit toIO
  */
 export function fromExitNow<E, A>(exit: Exit<E, A>, __tsplusTrace?: string): FIO<E, A> {
   return exit.match(IO.failCauseNow, IO.succeedNow);
@@ -990,6 +842,7 @@ export function fromMaybe<A>(maybe: Lazy<Maybe<A>>, __tsplusTrace?: string): FIO
 
 /**
  * @tsplus static fncts.io.IOOps fromMaybeNow
+ * @tsplus getter fncts.Maybe toIO
  */
 export function fromMaybeNow<A = never>(maybe: Maybe<A>, __tsplusTrace?: string): IO<unknown, Maybe<never>, A> {
   return maybe.match(() => IO.failNow(Nothing()), IO.succeedNow);
@@ -1051,27 +904,23 @@ export function get<R, E, A>(ma: IO<R, E, Maybe<A>>, __tsplusTrace?: string): IO
 /**
  * Extracts the optional value, or returns the given 'orElse'.
  *
- * @tsplus fluent fncts.io.IO getOrElse
+ * @tsplus pipeable fncts.io.IO getOrElse
  */
-export function getOrElse_<R, E, A, B>(
-  ma: IO<R, E, Maybe<A>>,
-  orElse: Lazy<B>,
-  __tsplusTrace?: string,
-): IO<R, E, A | B> {
-  return ma.map((ma) => ma.getOrElse(orElse));
+export function getOrElse<B>(orElse: Lazy<B>, __tsplusTrace?: string) {
+  return <R, E, A>(ma: IO<R, E, Maybe<A>>): IO<R, E, A | B> => {
+    return ma.map((ma) => ma.getOrElse(orElse));
+  };
 }
 
 /**
  * Extracts the optional value, or executes the effect 'orElse'.
  *
- * @tsplus fluent fncts.io.IO getOrElseIO
+ * @tsplus pipeable fncts.io.IO getOrElseIO
  */
-export function getOrElseIO_<R, E, A, R1, E1, B>(
-  ma: IO<R, E, Maybe<A>>,
-  orElse: Lazy<IO<R1, E1, B>>,
-  __tsplusTrace?: string,
-): IO<R | R1, E | E1, A | B> {
-  return (ma as IO<R, E, Maybe<A | B>>).flatMap((mab) => mab.map(IO.succeedNow).getOrElse(orElse));
+export function getOrElseIO<R1, E1, B>(orElse: Lazy<IO<R1, E1, B>>, __tsplusTrace?: string) {
+  return <R, E, A>(ma: IO<R, E, Maybe<A>>): IO<R | R1, E | E1, A | B> => {
+    return (ma as IO<R, E, Maybe<A | B>>).flatMap((mab) => mab.map(IO.succeedNow).getOrElse(orElse));
+  };
 }
 
 /**
@@ -1079,7 +928,7 @@ export function getOrElseIO_<R, E, A, R1, E1, B>(
  *
  * @tsplus static fncts.io.IOOps getOrFailWith
  */
-export function getOrFailWith_<E, A>(maybe: Maybe<A>, onNothing: Lazy<E>, __tsplusTrace?: string): FIO<E, A> {
+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));
 }
 
@@ -1113,23 +962,23 @@ 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 fluent fncts.io.IO ifIO
+ * @tsplus pipeable fncts.io.IO ifIO
  */
-export function ifIO_<R, E, R1, E1, B, R2, E2, C>(
-  self: IO<R, E, boolean>,
+export function ifIO<R1, E1, B, R2, E2, C>(
   onFalse: Lazy<IO<R1, E1, B>>,
   onTrue: Lazy<IO<R2, E2, C>>,
   __tsplusTrace?: string,
-): IO<R | R1 | R2, E | E1 | E2, B | C> {
-  return self.flatMap((b) => (b ? onTrue() : onFalse()));
+) {
+  return <R, E>(self: IO<R, E, boolean>): IO<R | R1 | R2, E | E1 | E2, B | C> => {
+    return self.flatMap((b) => (b ? onTrue() : onFalse()));
+  };
 }
 
 /**
  * @tsplus static fncts.io.IOOps if
  */
-export function if_<R, E, A, R1, E1, A1>(
+export function cond<R, E, A, R1, E1, A1>(
   b: boolean,
   onTrue: Lazy<IO<R, E, A>>,
   onFalse: Lazy<IO<R1, E1, A1>>,
@@ -1171,6 +1020,7 @@ export function isSuccess<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<
     () => true,
   );
 }
+
 /**
  * Iterates with the specified effectual function. The moral equivalent of:
  *
@@ -1186,7 +1036,7 @@ export function isSuccess<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<
  *
  * @tsplus static fncts.io.IOOps iterate
  */
-export function iterate_<R, E, A>(
+export function iterate<R, E, A>(
   initial: A,
   cont: (a: A) => boolean,
   body: (a: A) => IO<R, E, A>,
@@ -1208,7 +1058,10 @@ export function left<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<Either<A, never
  * @tsplus static fncts.io.IOOps log
  */
 export function log(message: Lazy<string>, __tsplusTrace?: string): UIO<void> {
-  return new Logged(message, Cause.empty(), Nothing(), __tsplusTrace);
+  return IO.withFiberRuntime((fiber) => {
+    fiber.log(message, Cause.empty(), Nothing(), __tsplusTrace);
+    return IO.unit;
+  });
 }
 
 /**
@@ -1229,7 +1082,7 @@ export function log(message: Lazy<string>, __tsplusTrace?: string): UIO<void> {
  *
  * @tsplus static fncts.io.IOOps loop
  */
-export function loop_<A, R, E, B>(
+export function loop<A, R, E, B>(
   initial: A,
   cont: (a: A) => boolean,
   inc: (b: A) => A,
@@ -1258,7 +1111,7 @@ export function loop_<A, R, E, B>(
  *
  * @tsplus static fncts.io.IOOps loopUnit
  */
-export function loopUnit_<A, R, E>(
+export function loopUnit<A, R, E>(
   initial: A,
   cont: (a: A) => boolean,
   inc: (a: A) => A,
@@ -1275,10 +1128,12 @@ export function loopUnit_<A, R, E>(
 /**
  * Returns an `IO` whose success is mapped by the specified function `f`.
  *
- * @tsplus fluent fncts.io.IO map
+ * @tsplus pipeable fncts.io.IO map
  */
-export function map_<R, E, A, B>(fa: IO<R, E, A>, f: (a: A) => B, __tsplusTrace?: string): IO<R, E, B> {
-  return fa.flatMap((a) => IO.succeedNow(f(a)));
+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)));
+  };
 }
 
 /**
@@ -1288,16 +1143,18 @@ export function map_<R, E, A, B>(fa: IO<R, E, A>, f: (a: A) => B, __tsplusTrace?
  * function. This can be used to lift a "smaller" error into a "larger"
  * error.
  *
- * @tsplus fluent fncts.io.IO mapError
+ * @tsplus pipeable fncts.io.IO mapError
  */
-export function mapError_<R, E, A, E1>(fea: IO<R, E, A>, f: (e: E) => E1, __tsplusTrace?: string): IO<R, E1, A> {
-  return fea.matchCauseIO((cause) => IO.failCauseNow(cause.map(f)), IO.succeedNow);
+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);
+  };
 }
 
 /**
  * @tsplus static fncts.io.IOOps mapTryCatch
  */
-export function mapTryCatch_<R, E, A, E1, B>(
+export function mapTryCatch<R, E, A, E1, B>(
   io: IO<R, E, A>,
   f: (a: A) => B,
   onThrow: (u: unknown) => E1,
@@ -1311,57 +1168,58 @@ export function mapTryCatch_<R, E, A, E1, B>(
  * the specified function. This can be used to transform errors
  * while preserving the original structure of Cause.
  *
- * @tsplus fluent fncts.io.IO mapErrorCause
+ * @tsplus pipeable fncts.io.IO mapErrorCause
  */
-export function mapErrorCause_<R, E, A, E1>(
-  ma: IO<R, E, A>,
-  f: (cause: Cause<E>) => Cause<E1>,
-  __tsplusTrace?: string,
-): IO<R, E1, A> {
-  return ma.matchCauseIO((cause) => IO.failCauseNow(f(cause)), IO.succeedNow);
+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);
+  };
 }
 
 /**
  * A more powerful version of `match_` that allows recovering from any kind of failure except interruptions.
  *
- * @tsplus fluent fncts.io.IO matchCause
+ * @tsplus pipeable fncts.io.IO matchCause
  */
-export function matchCause_<R, E, A, A1, A2>(
-  self: IO<R, E, A>,
+export function matchCause<E, A, A1, A2>(
   onFailure: (cause: Cause<E>) => A1,
   onSuccess: (a: A) => A2,
   __tsplusTrace?: string,
-): IO<R, never, A1 | A2> {
-  return self.matchCauseIO(
-    (cause) => IO.succeedNow(onFailure(cause)),
-    (a) => IO.succeedNow(onSuccess(a)),
-  );
+) {
+  return <R>(self: IO<R, E, A>): IO<R, never, A1 | A2> => {
+    return self.matchCauseIO(
+      (cause) => IO.succeedNow(onFailure(cause)),
+      (a) => IO.succeedNow(onSuccess(a)),
+    );
+  };
 }
 
 /**
  * A more powerful version of `matchIO` that allows recovering from any kind of failure except interruptions.
  *
- * @tsplus fluent fncts.io.IO matchCauseIO
+ * @tsplus pipeable fncts.io.IO matchCauseIO
  */
-export function matchCauseIO_<R, E, A, R1, E1, A1, R2, E2, A2>(
-  self: IO<R, E, A>,
+export function matchCauseIO<E, A, R1, E1, A1, R2, E2, A2>(
   onFailure: (cause: Cause<E>) => IO<R1, E1, A1>,
   onSuccess: (a: A) => IO<R2, E2, A2>,
   __tsplusTrace?: string,
-): IO<R | R1 | R2, E1 | E2, A1 | A2> {
-  return new Match(self, onFailure, onSuccess, __tsplusTrace);
+) {
+  return <R>(self: IO<R, E, A>): IO<R | R1 | R2, E1 | E2, A1 | A2> => {
+    return new OnSuccessAndFailure(self, onFailure, onSuccess, __tsplusTrace);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.IO matchIO
+ * @tsplus pipeable fncts.io.IO matchIO
  */
-export function matchIO_<R, R1, R2, E, E1, E2, A, A1, A2>(
-  self: IO<R, E, A>,
+export function matchIO<R1, R2, E, E1, E2, A, A1, A2>(
   onFailure: (e: E) => IO<R1, E1, A1>,
   onSuccess: (a: A) => IO<R2, E2, A2>,
   __tsplusTrace?: string,
-): IO<R | R1 | R2, E1 | E2, A1 | A2> {
-  return self.matchCauseIO((cause) => cause.failureOrCause.match(onFailure, IO.failCauseNow), onSuccess);
+) {
+  return <R>(self: IO<R, E, A>): IO<R | R1 | R2, E1 | E2, A1 | A2> => {
+    return self.matchCauseIO((cause) => cause.failureOrCause.match(onFailure, IO.failCauseNow), onSuccess);
+  };
 }
 
 /**
@@ -1369,35 +1227,33 @@ export function matchIO_<R, R1, R2, E, E1, E2, A, A1, A2>(
  * does not fail, but succeeds with the value returned by the left or right
  * function passed to `match_`.
  *
- * @tsplus fluent fncts.io.IO match
+ * @tsplus pipeable fncts.io.IO match
  */
-export function match_<R, E, A, B, C>(
-  self: IO<R, E, A>,
-  onFailure: (e: E) => B,
-  onSuccess: (a: A) => C,
-  __tsplusTrace?: string,
-): IO<R, never, B | C> {
-  return self.matchIO(
-    (e) => IO.succeedNow(onFailure(e)),
-    (a) => IO.succeedNow(onSuccess(a)),
-  );
+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.
  *
- * @tsplus fluent fncts.io.IO matchTraceIO
+ * @tsplus pipeable fncts.io.IO matchTraceIO
  */
-export function matchTraceIO_<R, E, A, R1, E1, A1, R2, E2, A2>(
-  ma: IO<R, E, A>,
+export function matchTraceIO<E, A, R1, E1, A1, R2, E2, A2>(
   onFailure: (e: E, trace: Trace) => IO<R1, E1, A1>,
   onSuccess: (a: A) => IO<R2, E2, A2>,
   __tsplusTrace?: string,
-): IO<R | R1 | R2, E1 | E2, A1 | A2> {
-  return ma.matchCauseIO(
-    (cause) => cause.failureTraceOrCause.match(([e, trace]) => onFailure(e, trace), IO.failCauseNow),
-    onSuccess,
-  );
+) {
+  return <R>(ma: IO<R, E, A>): IO<R | R1 | R2, E1 | E2, A1 | A2> => {
+    return ma.matchCauseIO(
+      (cause) => cause.failureTraceOrCause.match(([e, trace]) => onFailure(e, trace), IO.failCauseNow),
+      onSuccess,
+    );
+  };
 }
 
 /**
@@ -1419,7 +1275,7 @@ 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>(
+export function mergeAll<R, E, A, B>(
   fas: Iterable<IO<R, E, A>>,
   b: B,
   f: (b: B, a: A) => B,
@@ -1428,25 +1284,6 @@ export function mergeAll_<R, E, A, B>(
   return fas.foldLeft(IO.succeed(b) as IO<R, E, B>, (b, a) => b.zipWith(a, f));
 }
 
-/**
- * Returns a `IO` that will never produce anything. The moral equivalent of
- * `while(true) {}`, only without the wasted CPU cycles.
- *
- * @tsplus static fncts.io.IOOps never
- */
-export const never: UIO<never> = defer(() =>
-  asyncInterrupt<never, never, never>(() => {
-    const interval = setInterval(() => {
-      //
-    }, 60000);
-    return Either.left(
-      IO.succeed(() => {
-        clearInterval(interval);
-      }),
-    );
-  }),
-);
-
 /**
  * Converts an option on errors into an option on values.
  *
@@ -1465,61 +1302,58 @@ export function optional<R, E, A>(ma: IO<R, Maybe<E>, A>, __tsplusTrace?: string
  * operator has "short circuiting" behavior so if the value returned by this
  * effect is true the specified effect will not be evaluated.
  *
- * @tsplus fluent fncts.io.IO or
+ * @tsplus pipeable fncts.io.IO or
+ * @tsplus pipeable-operator fncts.io.IO ||
  */
-export function or_<R, E, R1, E1>(
-  ma: IO<R, E, boolean>,
-  mb: IO<R1, E1, boolean>,
-  __tsplusTrace?: string,
-): IO<R | R1, E | E1, boolean> {
-  return ma.flatMap((b) => (b ? IO.succeedNow(true) : mb));
+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));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.IO orElse
+ * @tsplus pipeable fncts.io.IO orElse
  */
-export function orElse_<R, E, A, R1, E1, A1>(
-  ma: IO<R, E, A>,
-  that: Lazy<IO<R1, E1, A1>>,
-  __tsplusTrace?: string,
-): IO<R | R1, E1, A | A1> {
-  return tryOrElse_(ma, that, IO.succeedNow);
+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);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.IO orElseEither
+ * @tsplus pipeable fncts.io.IO orElseEither
  */
-export function orElseEither_<R, E, A, R1, E1, A1>(
-  self: IO<R, E, A>,
-  that: Lazy<IO<R1, E1, A1>>,
-  __tsplusTrace?: string,
-): IO<R | R1, E1, Either<A, A1>> {
-  return self.tryOrElse(that().map(Either.right), (a) => IO.succeedNow(Either.left(a)));
+export function orElseEither<R1, E1, A1>(that: Lazy<IO<R1, E1, A1>>, __tsplusTrace?: string) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E1, Either<A, A1>> => {
+    return self.tryOrElse(that().map(Either.right), (a) => IO.succeedNow(Either.left(a)));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.IO orElseFail
+ * @tsplus pipeable fncts.io.IO orElseFail
  */
-export function orElseFail_<R, E, A, E1>(ma: IO<R, E, A>, e: Lazy<E1>, __tsplusTrace?: string): IO<R, E1, A> {
-  return ma.orElse(IO.fail(e));
+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));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.IO orElseMaybe
+ * @tsplus pipeable fncts.io.IO orElseMaybe
  */
-export function orElseMaybe_<R, E, A, R1, E1, A1>(
-  ma: IO<R, Maybe<E>, A>,
-  that: Lazy<IO<R1, Maybe<E1>, A1>>,
-  __tsplusTrace?: string,
-): IO<R | R1, Maybe<E | E1>, A | A1> {
-  return ma.catchAll((me) => me.match(that, (e) => IO.fail(Just(e))));
+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))));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.IO orElseSucceed
+ * @tsplus pipeable fncts.io.IO orElseSucceed
  */
-export function orElseSucceed_<R, E, A, A1>(ma: IO<R, E, A>, a: Lazy<A1>, __tsplusTrace?: string): IO<R, E, A | A1> {
-  return ma.orElse(IO.succeed(a));
+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));
+  };
 }
 
 /**
@@ -1537,26 +1371,30 @@ export function orHaltKeep<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO
 }
 
 /**
- * @tsplus fluent fncts.io.IO orHaltWith
+ * @tsplus pipeable fncts.io.IO orHaltWith
  */
-export function orHaltWith_<R, E, A>(ma: IO<R, E, A>, f: (e: E) => unknown, __tsplusTrace?: string): IO<R, never, A> {
-  return matchIO_(ma, (e) => IO.haltNow(f(e)), IO.succeedNow);
+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 fluent fncts.io.IO parallelErrors
+ * @tsplus pipeable fncts.io.IO concurrentErrors
  */
-export function parallelErrors<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): 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);
+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);
+  };
 }
 
 /**
@@ -1565,7 +1403,7 @@ export function parallelErrors<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string)
  *
  * @tsplus static fncts.io.IOOps partition
  */
-export function partition_<R, E, A, B>(
+export function partition<R, E, A, B>(
   as: Iterable<A>,
   f: (a: A) => IO<R, E, B>,
   __tsplusTrace?: string,
@@ -1576,43 +1414,36 @@ export function partition_<R, E, A, B>(
 /**
  * Keeps some of the errors, and terminates the fiber with the rest
  *
- * @tsplus fluent fncts.io.IO refineOrHalt
+ * @tsplus pipeable fncts.io.IO refineOrHalt
  */
-export function refineOrHalt_<R, E, A, E1>(
-  fa: IO<R, E, A>,
-  pf: (e: E) => Maybe<E1>,
-  __tsplusTrace?: string,
-): IO<R, E1, A> {
-  return fa.refineOrHaltWith(pf, identity);
+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);
+  };
 }
 
 /**
  * Keeps some of the errors, and terminates the fiber with the rest, using
  * the specified function to convert the `E` into a `Throwable`.
  *
- * @tsplus fluent fncts.io.IO refineOrHaltWith
+ * @tsplus pipeable fncts.io.IO refineOrHaltWith
  */
-export function refineOrHaltWith_<R, E, A, E1>(
-  fa: IO<R, E, A>,
-  pf: (e: E) => Maybe<E1>,
-  f: (e: E) => unknown,
-  __tsplusTrace?: string,
-): IO<R, E1, A> {
-  return fa.catchAll((e) => pf(e).match(() => IO.haltNow(f(e)), IO.failNow));
+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));
+  };
 }
 
 /**
  * Fail with the returned value if the partial function `pf` matches, otherwise
  * continue with the held value.
  *
- * @tsplus fluent fncts.io.IO reject
+ * @tsplus pipeable fncts.io.IO reject
  */
-export function reject_<R, E, A, E1>(
-  fa: IO<R, E, A>,
-  pf: (a: A) => Maybe<E1>,
-  __tsplusTrace?: string,
-): IO<R, E | E1, A> {
-  return fa.rejectIO((a) => pf(a).map(IO.failNow));
+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));
+  };
 }
 
 /**
@@ -1620,86 +1451,90 @@ export function reject_<R, E, A, E1>(
  * translating the successful match into a failure, otherwise continue with
  * the held value.
  *
- * @tsplus fluent fncts.io.IO rejectIO
+ * @tsplus pipeable fncts.io.IO rejectIO
  */
-export function rejectIO_<R, E, A, R1, E1>(
-  fa: IO<R, E, A>,
-  pf: (a: A) => Maybe<IO<R1, E1, E1>>,
-  __tsplusTrace?: string,
-): IO<R | R1, E | E1, A> {
-  return fa.flatMap((a) =>
-    pf(a).match(
-      () => IO.succeedNow(a),
-      (io) => io.flatMap(IO.failNow),
-    ),
-  );
+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) =>
+      pf(a).match(
+        () => IO.succeedNow(a),
+        (io) => io.flatMap(IO.failNow),
+      ),
+    );
+  };
 }
 
 /**
  * Repeats this effect the specified number of times.
  *
- * @tsplus fluent fncts.io.IO repeatN
+ * @tsplus pipeable fncts.io.IO repeatN
  */
-export function repeatN_<R, E, A>(ma: IO<R, E, A>, n: number, __tsplusTrace?: string): IO<R, E, A> {
-  return ma.flatMap((a) => (n <= 0 ? IO.succeed(a) : ma.repeatN(n - 1)));
+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)));
+  };
 }
 
 /**
  * Repeats this effect until its result satisfies the specified predicate.
  *
- * @tsplus fluent fncts.io.IO repeatUntil
+ * @tsplus pipeable fncts.io.IO repeatUntil
  */
-export function repeatUntil_<R, E, A>(ma: IO<R, E, A>, f: (a: A) => boolean, __tsplusTrace?: string): IO<R, E, A> {
-  return ma.repeatUntilIO((a) => IO.succeedNow(f(a)));
+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)));
+  };
 }
 
 /**
  * Repeats this effect until its error satisfies the specified effectful predicate.
  *
- * @tsplus fluent fncts.io.IO repeatUntilIO
+ * @tsplus pipeable fncts.io.IO repeatUntilIO
  */
-export function repeatUntilIO_<R, E, A, R1, E1>(
-  ma: IO<R, E, A>,
-  f: (a: A) => IO<R1, E1, boolean>,
-  __tsplusTrace?: string,
-): IO<R | R1, E | E1, A> {
-  return ma.flatMap((a) => f(a).flatMap((b) => (b ? IO.succeed(a) : ma.repeatUntilIO(f))));
+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))));
+  };
 }
 
 /**
  * Repeats this effect while its error satisfies the specified predicate.
  *
- * @tsplus fluent fncts.io.IO repeatWhile
+ * @tsplus pipeable fncts.io.IO repeatWhile
  */
-export function repeatWhile_<R, E, A>(ma: IO<R, E, A>, f: (a: A) => boolean, __tsplusTrace?: string): IO<R, E, A> {
-  return ma.repeatWhileIO((a) => IO.succeedNow(f(a)));
+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)));
+  };
 }
 
 /**
  * Repeats this effect while its error satisfies the specified effectful predicate.
  *
- * @tsplus fluent fncts.io.IO repeatWhileIO
+ * @tsplus pipeable fncts.io.IO repeatWhileIO
  */
-export function repeatWhileIO_<R, E, A, R1, E1>(
-  ma: IO<R, E, A>,
-  f: (a: A) => IO<R1, E1, boolean>,
-  __tsplusTrace?: string,
-): IO<R | R1, E | E1, A> {
-  return ma.flatMap((a) => f(a).flatMap((b) => (b ? ma.repeatWhileIO(f) : IO.succeed(a))));
+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))));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.IO replicate
+ * @tsplus pipeable fncts.io.IO replicate
  */
-export function replicate_<R, E, A>(self: IO<R, E, A>, n: number, __tsplusTrace?: string): ImmutableArray<IO<R, E, A>> {
-  return ImmutableArray.range(0, n).map(() => self);
+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);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.IO require
+ * @tsplus pipeable fncts.io.IO require
  */
-export function require_<R, E, A>(ma: IO<R, E, Maybe<A>>, error: Lazy<E>, __tsplusTrace?: string): IO<R, E, A> {
-  return ma.flatMap((ma) => ma.match(() => IO.fail(error), IO.succeedNow));
+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));
+  };
 }
 
 /**
@@ -1727,54 +1562,47 @@ export function resurrect<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<
 /**
  * Retries this effect until its error satisfies the specified predicate.
  *
- * @tsplus fluent fncts.io.IO retryUntil
+ * @tsplus pipeable fncts.io.IO retryUntil
  */
-export function retryUntil_<R, E, A>(fa: IO<R, E, A>, f: (e: E) => boolean, __tsplusTrace?: string): IO<R, E, A> {
-  return fa.retryUntilIO((e) => IO.succeedNow(f(e)));
+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)));
+  };
 }
 
 /**
  * Retries this effect until its error satisfies the specified effectful predicate.
  *
- * @tsplus fluent fncts.io.IO retryUntilIO
+ * @tsplus pipeable fncts.io.IO retryUntilIO
  */
-export function retryUntilIO_<R, E, A, R1, E1>(
-  fa: IO<R, E, A>,
-  f: (e: E) => IO<R1, E1, boolean>,
-  __tsplusTrace?: string,
-): IO<R | R1, E | E1, A> {
-  return fa.catchAll((e) => f(e).flatMap((b) => (b ? IO.failNow(e) : fa.retryUntilIO(f))));
+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))));
+  };
 }
 
 /**
  * Retries this effect while its error satisfies the specified predicate.
  *
- * @tsplus fluent fncts.io.IO retryWhile
+ * @tsplus pipeable fncts.io.IO retryWhile
  */
-export function retryWhile_<R, E, A>(fa: IO<R, E, A>, f: (e: E) => boolean, __tsplusTrace?: string): IO<R, E, A> {
-  return fa.retryWhileIO((e) => IO.succeedNow(f(e)));
+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)));
+  };
 }
 
 /**
  * Retries this effect while its error satisfies the specified effectful predicate.
  *
- * @tsplus fluent fncts.io.IO retryWhileIO
+ * @tsplus pipeable fncts.io.IO retryWhileIO
  */
-export function retryWhileIO_<R, E, A, R1, E1>(
-  fa: IO<R, E, A>,
-  f: (e: E) => IO<R1, E1, boolean>,
-  __tsplusTrace?: string,
-): IO<R | R1, E | E1, A> {
-  return fa.catchAll((e) => f(e).flatMap((b) => (b ? fa.retryWhileIO(f) : IO.fail(e))));
+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))));
+  };
 }
 
-/**
- * Retrieves the runtimeConfig that this effect is running on.
- *
- * @tsplus static fncts.io.IOOps runtimeConfig
- */
-export const runtimeConfig: UIO<RuntimeConfig> = IO.deferWith((runtimeConfig) => IO.succeedNow(runtimeConfig));
-
 /**
  * Exposes the full cause of failure of this effect.
  *
@@ -1785,22 +1613,12 @@ export function sandbox<R, E, A>(fa: IO<R, E, A>, __tsplusTrace?: string): IO<R,
 }
 
 /**
- * @tsplus fluent fncts.io.IO sandboxWith
- */
-export function sandboxWith_<R, E, A, E1>(
-  ma: IO<R, E, A>,
-  f: (_: IO<R, Cause<E>, A>) => IO<R, Cause<E1>, A>,
-  __tsplusTrace?: string,
-): IO<R, E1, A> {
-  return f(ma.sandbox).unsandbox;
-}
-
-/**
- * Sets the runtime configuration to the specified value.
- * @tsplus static fncts.io.IOOps setRuntimeConfig
+ * @tsplus pipeable fncts.io.IO sandboxWith
  */
-export function setRuntimeConfig(runtimeConfig: Lazy<RuntimeConfig>, __tsplusTrace?: string): UIO<void> {
-  return IO.withFiberContext((fiber) => IO((fiber.runtimeConfig = runtimeConfig())));
+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;
+  };
 }
 
 /**
@@ -1835,24 +1653,21 @@ export function succeedNow<A>(value: A, __tsplusTrace?: string): IO<never, never
  * @tsplus static fncts.io.IOOps __call
  */
 export function succeed<A>(effect: Lazy<A>, __tsplusTrace?: string): UIO<A> {
-  return new Succeed(effect, __tsplusTrace);
+  return new Sync(effect, __tsplusTrace);
 }
 
 /**
- * @tsplus fluent fncts.io.IO summarized
+ * @tsplus pipeable fncts.io.IO summarized
  */
-export function summarized_<R, E, A, R1, E1, B, C>(
-  ma: IO<R, E, A>,
-  summary: IO<R1, E1, B>,
-  f: (start: B, end: B) => C,
-  __tsplusTrace?: string,
-): IO<R | R1, E | E1, readonly [C, A]> {
-  return gen(function* (_) {
-    const start = yield* _(summary);
-    const value = yield* _(ma);
-    const end   = yield* _(summary);
-    return tuple(f(start, end), value);
-  });
+export function summarized<R1, E1, B, C>(summary: IO<R1, E1, B>, f: (start: B, end: B) => C, __tsplusTrace?: string) {
+  return <R, E, A>(ma: IO<R, E, A>): IO<R | R1, E | E1, readonly [C, A]> => {
+    return gen(function* (_) {
+      const start = yield* _(summary);
+      const value = yield* _(ma);
+      const end   = yield* _(summary);
+      return tuple(f(start, end), value);
+    });
+  };
 }
 
 /**
@@ -1867,23 +1682,20 @@ export function swap<R, E, A>(pab: IO<R, E, A>, __tsplusTrace?: string): IO<R, A
 /**
  * Swaps the error/value parameters, applies the function `f` and flips the parameters back
  *
- * @tsplus fluent fncts.io.IO swapWith
+ * @tsplus pipeable fncts.io.IO swapWith
  */
-export function swapWith_<R, E, A, R1, E1, A1>(
-  fa: IO<R, E, A>,
-  f: (ma: IO<R, A, E>) => IO<R1, A1, E1>,
-  __tsplusTrace?: string,
-) {
-  return f(fa.swap).swap;
+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 fluent fncts.io.IO timedWith
+ * @tsplus pipeable fncts.io.IO timedWith
  */
-export function timedWith_<R, E, A, R1, E1>(ma: IO<R, E, A>, msTime: IO<R1, E1, number>, __tsplusTrace?: string) {
-  return ma.summarized(msTime, (start, end) => end - start);
+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);
 }
 
 /**
@@ -1896,7 +1708,7 @@ export function tryCatch<E, A>(effect: Lazy<A>, onThrow: (error: unknown) => E,
     try {
       return effect();
     } catch (u) {
-      throw new IOError(Exit.fail(onThrow(u)));
+      throw new IOError(Cause.fail(onThrow(u)));
     }
   });
 }
@@ -1916,70 +1728,66 @@ export function absolve<R, E, E1, A>(ma: IO<R, E, Either<E1, A>>, __tsplusTrace?
  *
  * Returns an IO that effectfully "peeks" at the success of this effect.
  *
- * @tsplus fluent fncts.io.IO tap
+ * @tsplus pipeable fncts.io.IO tap
  */
-export function tap_<R, E, A, R1, E1, B>(
-  self: IO<R, E, A>,
-  f: (a: A) => IO<R1, E1, B>,
-  __tsplusTrace?: string,
-): IO<R1 | R, E1 | E, A> {
-  return self.flatMap((a) => f(a).map(() => a));
+export function tap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E>(self: IO<R, E, A>): IO<R1 | R, E1 | E, A> => {
+    return self.flatMap((a) => f(a).map(() => a));
+  };
 }
 
 /**
  * Returns an IO that effectually "peeks" at the cause of the failure of
  * this IO.
  *
- * @tsplus fluent fncts.io.IO tapCause
+ * @tsplus pipeable fncts.io.IO tapCause
  */
-export function tapCause_<R2, A2, R, E, E2>(
-  ma: IO<R2, E2, A2>,
-  f: (e: Cause<E2>) => IO<R, E, any>,
-  __tsplusTrace?: string,
-): IO<R2 | R, E | E2, A2> {
-  return ma.matchCauseIO((c) => f(c).flatMap(() => IO.failCauseNow(c)), IO.succeedNow);
+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);
+  };
 }
 
 /**
  * Returns an IO that effectfully "peeks" at the failure of this effect.
  *
- * @tsplus fluent fncts.io.IO tapError
- */
-export function tapError_<R, E, A, R1, E1>(self: IO<R, E, A>, f: (e: E) => IO<R1, E1, any>, __tsplusTrace?: string) {
-  return self.matchCauseIO(
-    (cause) =>
-      cause.failureOrCause.match(
-        (e) => f(e).flatMap(() => IO.failCauseNow(cause)),
-        (_) => IO.failCauseNow(cause),
-      ),
-    IO.succeedNow,
-  );
+ * @tsplus pipeable fncts.io.IO tapError
+ */
+export function tapError<E, R1, E1>(f: (e: E) => IO<R1, E1, any>, __tsplusTrace?: string) {
+  return <R, A>(self: IO<R, E, A>) =>
+    self.matchCauseIO(
+      (cause) =>
+        cause.failureOrCause.match(
+          (e) => f(e).flatMap(() => IO.failCauseNow(cause)),
+          (_) => IO.failCauseNow(cause),
+        ),
+      IO.succeedNow,
+    );
 }
 
 /**
  * Returns an effect that effectually "peeks" at the cause of the failure of
  * this effect.
  *
- * @tsplus fluent fncts.io.IO tapErrorCause
+ * @tsplus pipeable fncts.io.IO tapErrorCause
  */
-export function tapErrorCause_<R, E, A, R1, E1>(
-  self: IO<R, E, A>,
-  f: (e: Cause<E>) => IO<R1, E1, any>,
-  __tsplusTrace?: string,
-): IO<R | R1, E | E1, A> {
-  return self.matchCauseIO((cause) => f(cause).apSecond(IO.failCauseNow(cause)), IO.succeedNow);
+export function tapErrorCause<E, R1, E1>(f: (e: Cause<E>) => IO<R1, E1, any>, __tsplusTrace?: string) {
+  return <R, A>(self: IO<R, E, A>): IO<R | R1, E | E1, A> => {
+    return self.matchCauseIO((cause) => f(cause).zipRight(IO.failCauseNow(cause)), IO.succeedNow);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.IO tryOrElse
+ * @tsplus pipeable fncts.io.IO tryOrElse
  */
-export function tryOrElse_<R, E, A, R1, E1, A1, R2, E2, A2>(
-  ma: IO<R, E, A>,
+export function tryOrElse<A, R1, E1, A1, R2, E2, A2>(
   that: Lazy<IO<R1, E1, A1>>,
   onSuccess: (a: A) => IO<R2, E2, A2>,
   __tsplusTrace?: string,
-): IO<R | R1 | R2, E1 | E2, A1 | A2> {
-  return ma.matchCauseIO((cause) => cause.keepDefects.match(that, IO.failCauseNow), onSuccess);
+) {
+  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);
+  };
 }
 
 /**
@@ -2003,17 +1811,14 @@ export function unjust<R, E, A>(self: IO<R, Maybe<E>, A>, __tsplusTrace?: string
  * Takes some fiber failures and converts them into errors, using the
  * specified function to convert the `E` into an `E1 | E2`.
  *
- * @tsplus fluent fncts.io.IO unrefineWith
+ * @tsplus pipeable fncts.io.IO unrefineWith
  */
-export function unrefineWith_<R, E, A, E1, E2>(
-  fa: IO<R, E, A>,
-  pf: (u: unknown) => Maybe<E1>,
-  f: (e: E) => E2,
-  __tsplusTrace?: string,
-): IO<R, E1 | E2, A> {
-  return fa.catchAllCause((cause) =>
-    cause.find((c) => (c.isHalt() ? pf(c.value) : Nothing())).match(() => IO.failCauseNow(cause.map(f)), IO.failNow),
-  );
+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) =>
+      cause.find((c) => (c.isHalt() ? pf(c.value) : Nothing())).match(() => IO.failCauseNow(cause.map(f)), IO.failNow),
+    );
+  };
 }
 
 /**
@@ -2035,22 +1840,10 @@ export function updateFiberRefs(
   f: (fiberId: FiberId.Runtime, fiberRefs: FiberRefs) => FiberRefs,
   __tsplusTrace?: string,
 ): UIO<void> {
-  return IO.withFiberContext((fiber) =>
-    IO(() => {
-      const newFiberRefs   = f(fiber.fiberId, fiber.fiberRefs);
-      fiber.fiberRefLocals = newFiberRefs.fiberRefLocals;
-    }),
-  );
-}
-
-/**
- * @tsplus static fncts.io.IOOps withFiberContext
- */
-export function withFiberContext<R, E, A>(
-  onState: (fiber: FiberContext<E, A>, status: FiberStatus) => IO<R, E, A>,
-  __tsplusTrace?: string,
-): IO<R, E, A> {
-  return new Stateful(onState, __tsplusTrace);
+  return IO.withFiberRuntime((state) => {
+    state.setFiberRefs(f(state.id, state.getFiberRefs()));
+    return IO.unit;
+  });
 }
 
 /**
@@ -2059,23 +1852,47 @@ export function withFiberContext<R, E, A>(
 export const via: typeof pipe = pipe;
 
 /**
- * @tsplus fluent fncts.io.IO when
+ * @tsplus pipeable fncts.io.IO when
  */
-export function when_<R, E, A>(ma: IO<R, E, A>, b: Lazy<boolean>, __tsplusTrace?: string): IO<R, E, void> {
-  return ma.whenIO(IO.succeed(b));
+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));
+  };
 }
 
 /**
  * The moral equivalent of `if (p) exp` when `p` has side-effects
  *
- * @tsplus fluent fncts.io.IO whenIO
+ * @tsplus pipeable fncts.io.IO whenIO
  */
-export function whenIO_<R, E, A, R1, E1>(
-  ma: IO<R, E, A>,
-  mb: IO<R1, E1, boolean>,
+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, void> => {
+    return mb.flatMap((b) => (b ? ma.asUnit : IO.unit));
+  };
+}
+
+/**
+ * @tsplus static fncts.io.IOOps withFiberRuntime
+ */
+export function withFiberRuntime<R, E, A>(
+  onState: (fiber: FiberRuntime<E, A>, status: Running) => IO<R, E, A>,
   __tsplusTrace?: string,
-): IO<R1 | R, E | E1, void> {
-  return mb.flatMap((b) => (b ? ma.asUnit : IO.unit));
+): IO<R, E, A> {
+  return new Stateful(onState, __tsplusTrace);
+}
+
+/**
+ * @tsplus static fncts.io.IOOps updateRuntimeFlags
+ */
+export function updateRuntimeFlags(patch: RuntimeFlags.Patch, __tsplusTrace?: string): IO<never, never, void> {
+  return new UpdateRuntimeFlags(patch, __tsplusTrace);
+}
+
+/**
+ * @tsplus static fncts.io.IOOps stackTrace
+ */
+export function stackTrace(__tsplusTrace?: string): UIO<Trace> {
+  return new GenerateStackTrace(__tsplusTrace);
 }
 
 /**
@@ -2085,29 +1902,24 @@ export function whenIO_<R, E, A, R1, E1>(
  *
  * @tsplus static fncts.io.IOOps yieldNow
  */
-export const yieldNow: UIO<void> = new Yield();
+export const yieldNow: UIO<void> = new YieldNow();
 
 /**
- * @tsplus fluent fncts.io.IO zip
+ * @tsplus pipeable fncts.io.IO zip
  */
-export function zip_<R, E, A, R1, E1, B>(
-  self: IO<R, E, A>,
-  that: IO<R1, E1, B>,
-  __tsplusTrace?: string,
-): IO<R | R1, E | E1, readonly [A, B]> {
-  return self.zipWith(that, tuple);
+export function zip<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E | E1, readonly [A, B]> => {
+    return self.zipWith(that, tuple);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.IO zipWith
+ * @tsplus pipeable fncts.io.IO zipWith
  */
-export function zipWith_<R, E, A, R1, E1, B, C>(
-  self: IO<R, E, A>,
-  that: IO<R1, E1, B>,
-  f: (a: A, b: B) => C,
-  __tsplusTrace?: string,
-): IO<R | R1, E | E1, C> {
-  return self.flatMap((a) => that.map((b) => f(a, b)));
+export function zipWith<A, R1, E1, B, C>(that: IO<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string) {
+  return <R, E>(self: IO<R, E, A>): IO<R | R1, E | E1, C> => {
+    return self.flatMap((a) => that.map((b) => f(a, b)));
+  };
 }
 
 export class GenIO<R, E, A> {
@@ -2126,22 +1938,6 @@ export class GenIO<R, E, A> {
  * @internal
  */
 export const __adapter = (_: any) => {
-  // if (Either.isEither(_)) {
-  //   return IO.fromEither(_);
-  // }
-  // if (Maybe.isMaybe(_)) {
-  //   return __
-  //     ? _._tag === "Nothing"
-  //       ? IO.failNow(__())
-  //       : IO.succeed(_.value)
-  //     : getOrFail(_);
-  // }
-  // if (isTag(_)) {
-  //   return service(_);
-  // }
-  // if (S.isSync(_)) {
-  //   return fromSync(_);
-  // }
   return _;
 };
 
@@ -2160,8 +1956,7 @@ export function gen<T extends GenIO<any, any, any>, A>(
   return IO.defer(() => {
     const iterator = f(adapter as any);
     const state    = iterator.next();
-
-    const run = (state: IteratorYieldResult<T> | IteratorReturnResult<A>): IO<any, any, A> => {
+    const run      = (state: IteratorYieldResult<T> | IteratorReturnResult<A>): IO<any, any, A> => {
       if (state.done) {
         return IO.succeed(state.value);
       }
@@ -2171,7 +1966,6 @@ export function gen<T extends GenIO<any, any, any>, A>(
       };
       return state.value.effect.flatMap(f);
     };
-
     return run(state);
   });
 }