@fncts/io 0.0.48 → 0.0.49

package/IO/api.d.ts

@@ -1,21 +1,20 @@
-import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { InterruptStatus } from "@fncts/io/InterruptStatus";
 import { URIO, FIO, UIO } from "@fncts/io/IO/definition";
 import { Either } from "@fncts/base/data/Either/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { Conc, ConcBuilder } from "@fncts/base/collection/immutable/Conc";
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
-import { NonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+import { ReadonlyNonEmptyArray } from "@fncts/base/collection/immutable/ReadonlyNonEmptyArray/definition";
 import { Eval } from "@fncts/base/control/Eval/definition";
-import { Exit } from "@fncts/base/data/Exit/definition";
 import { NoSuchElementError } from "@fncts/base/data/exceptions";
 import { FiberRefs } from "@fncts/io/FiberRefs";
 import { Trace } from "@fncts/base/data/Trace/definition";
 import { List } from "@fncts/base/collection/immutable/List/definition";
-import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 import type { Running } from "../FiberStatus.js";
 import type { ShowOptions } from "@fncts/base/data/Showable.js";
 import type * as P from "@fncts/base/typeclass";
@@ -24,12 +23,6 @@ import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
 import type { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 import { pipe } from "@fncts/base/data/function";
 import { IO } from "@fncts/io/IO/definition";
-/**
- * Imports an asynchronous side-effect into a `IO`
- * @tsplus static fncts.io.IOOps async
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function async<R, E, A>(register: (resolve: (_: IO<R, E, A>) => void) => void, blockingOn?: FiberId, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Attempts to convert defects into a failure, throwing away all information
  * about the cause of the failure.
@@ -37,19 +30,6 @@ export declare function async<R, E, A>(register: (resolve: (_: IO<R, E, A>) => v
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function absorbWith<R, E, A>(f: (e: E) => unknown, __tsplusTrace?: string): (ma: IO<R, E, A>) => IO<R, unknown, A>;
-/**
- * @tsplus pipeable fncts.io.IO zipLeft
- * @tsplus pipeable-operator fncts.io.IO <
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function zipLeft<R1, E1, B>(fb: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E1 | E, A>;
-/**
- * Combine two effectful actions, keeping only the result of the second
- * @tsplus pipeable fncts.io.IO zipRight
- * @tsplus pipeable-operator fncts.io.IO >
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function zipRight<R1, E1, B>(fb: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E1 | E, B>;
 /**
  * @tsplus pipeable fncts.io.IO as
  * @tsplus location "@fncts/io/IO/api"
@@ -60,25 +40,31 @@ export declare function as<B>(b: Lazy<B>, __tsplusTrace?: string): <R, E, A>(sel
  * @tsplus getter fncts.io.IO asJust
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function asJust<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, Maybe<A>>;
+export declare function asJust<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, Maybe<A>>;
 /**
  * Maps the error value of this IO to an optional value.
  * @tsplus getter fncts.io.IO asJustError
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function asJustError<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, Maybe<E>, A>;
+export declare function asJustError<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, Maybe<E>, A>;
 /**
  * @tsplus getter fncts.io.IO asUnit
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function asUnit<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, void>;
+/**
+ * Imports an asynchronous side-effect into a `IO`
+ * @tsplus static fncts.io.IOOps async
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function async<R, E, A>(register: (resolve: (_: IO<R, E, A>) => void) => void, blockingOn?: FiberId, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * 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
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function bimap<E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B, __tsplusTrace?: string): <R>(self: IO<R, E, A>) => IO<R, E1, B>;
+export declare function bimap<E, A, E1, B>(onFailure: (e: E) => E1, onSuccess: (a: A) => B, __tsplusTrace?: string): <R>(self: IO<R, E, A>) => IO<R, E1, B>;
 /**
  * Returns an IO that effectfully "peeks" at the failure or success of
  * this effect.
@@ -86,39 +72,31 @@ export declare function bimap<E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B, __ts
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function bitap<E, A, R1, E1, R2, E2>(onFailure: (e: E) => IO<R1, E1, any>, onSuccess: (a: A) => IO<R2, E2, any>, __tsplusTrace?: string): <R>(self: IO<R, E, A>) => IO<R | R1 | R2, E | E1 | E2, A>;
-/**
- * Recovers from the specified error
- * @tsplus pipeable fncts.io.IO catch
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare 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): <R, A>(ma: IO<R, E, A>) => IO<R | R1, Exclude<E, { [n in N]: K; }> | E1, A | A1>;
 /**
  * Recovers from all errors
  * @tsplus pipeable fncts.io.IO catchAll
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function catchAll<E, R1, E1, A1>(f: (e: E) => IO<R1, E1, A1>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R | R1, E1, A | A1>;
+export declare function catchAll<E, R1, E1, A1>(onFailure: (e: E) => IO<R1, E1, A1>, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R | R1, E1, A | A1>;
 /**
  *
  * Recovers from all errors with provided cause.
  * @tsplus pipeable fncts.io.IO catchAllCause
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function catchAllCause<R, E, A, R1, E1, A1>(f: (_: Cause<E>) => IO<R1, E1, A1>, __tsplusTrace?: string): (ma: IO<R, E, A>) => IO<R | R1, E1, A | A1>;
+export declare function catchAllCause<R, E, A, R1, E1, A1>(onFailure: (_: Cause<E>) => IO<R1, E1, A1>, __tsplusTrace?: string): (self: IO<R, E, A>) => IO<R | R1, E1, A | A1>;
 /**
  * Recovers from some or all of the error cases.
  * @tsplus pipeable fncts.io.IO catchJust
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function catchJust<E, R1, E1, A1>(f: (e: E) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R | R1, E | E1, A | A1>;
+export declare function catchJust<E, R1, E1, A1>(onFailure: (e: E) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R | R1, E | E1, A | A1>;
 /**
  * Recovers from some or all of the error cases with provided cause.
  * @tsplus pipeable fncts.io.IO catchJustCause
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function catchJustCause<E, R1, E1, A1>(f: (_: Cause<E>) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R | R1, E | E1, A | A1>;
+export declare function catchJustCause<E, R1, E1, A1>(onFailure: (_: Cause<E>) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R | R1, E | E1, A | A1>;
 /**
  * Recovers from some or all of the defects with provided partial function.
  *
@@ -129,29 +107,37 @@ export declare function catchJustCause<E, R1, E1, A1>(f: (_: Cause<E>) => Maybe<
  * @tsplus pipeable fncts.io.IO catchJustDefect
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function catchJustDefect<R1, E1, A1>(f: (_: unknown) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R | R1, E | E1, A | A1>;
+export declare function catchJustDefect<R1, E1, A1>(onFailure: (_: unknown) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R | R1, E | E1, A | A1>;
 /**
  * Recovers from the specified error
  * @tsplus pipeable IO catchTag
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function catchTag<K extends E["_tag"] & string, E extends {
+export declare function catchTag<T extends E["_tag"] & string, E extends {
     _tag: string;
-}, R1, E1, A1>(k: K, f: (e: Extract<E, {
-    _tag: K;
-}>) => IO<R1, E1, A1>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R | R1, Exclude<E, {
-    _tag: K;
+}, R1, E1, A1>(tag: T, onFailure: (e: Extract<E, {
+    _tag: T;
+}>) => IO<R1, E1, A1>, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R | R1, Exclude<E, {
+    _tag: T;
 }> | E1, A | A1>;
+/**
+ * Recovers from the specified error
+ * @tsplus pipeable fncts.io.IO catch
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare 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): <R, A>(self: IO<R, E, A>) => IO<R | R1, Exclude<E, { [n in K]: T; }> | E1, A | A1>;
 /**
  * @tsplus getter fncts.io.IO cause
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function cause<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, Cause<E>>;
+export declare function cause<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, Cause<E>>;
 /**
  * @tsplus pipeable fncts.io.IO causeAsError
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function causeAsError(__tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, Cause<E>, A>;
+export declare function causeAsError(__tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R, Cause<E>, A>;
 /**
  * Checks the interrupt status, and produces the IO returned by the
  * specified callback.
@@ -160,28 +146,20 @@ export declare function causeAsError(__tsplusTrace?: string): <R, E, A>(ma: IO<R
  */
 export declare function checkInterruptible<R, E, A>(f: (i: InterruptStatus) => IO<R, E, A>, __tsplusTrace?: string): IO<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
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function flatMap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R | R1, E | E1, B>;
-/**
- * @tsplus pipeable fncts.io.IO flatMapError
+ * @tsplus pipeable fncts.io.IO collect
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function flatMapError<R1, E, E1>(f: (e: E) => IO<R1, never, E1>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R | R1, E1, A>;
+export declare function collect<A, E1, A1>(f: Lazy<E1>, pf: (a: A) => Maybe<A1>, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R, E | E1, A1>;
 /**
- * @tsplus pipeable fncts.io.IO collect
+ * @tsplus pipeable fncts.io.IO collectIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function collect<A, E1, A1>(f: Lazy<E1>, pf: (a: A) => Maybe<A1>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R, E | E1, A1>;
+export declare function collectIO<A, R1, E1, A1, E2>(onNothing: Lazy<E2>, pf: (a: A) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R | R1, E | E1 | E2, A1>;
 /**
- * @tsplus pipeable fncts.io.IO collectIO
+ * @tsplus static fncts.io.IOOps if
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function collectIO<A, R1, E1, A1, E2>(f: Lazy<E2>, pf: (a: A) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R | R1, E | E1 | E2, A1>;
+export declare 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>;
 /**
  * @tsplus static fncts.io.IOOps condIO
  * @tsplus location "@fncts/io/IO/api"
@@ -202,7 +180,7 @@ export declare function defer<R = never, E = never, A = never>(io: Lazy<IO<R, E,
  * @tsplus static fncts.io.IOOps deferTry
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function deferTry<R = never, E = never, A = never>(io: () => IO<R, E, A>, __tsplusTrace?: string): IO<R, unknown, A>;
+export declare function deferTry<R = never, E = never, A = never>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<R, unknown, A>;
 /**
  * Returns a lazily constructed effect, whose construction may itself require effects,
  * translating any thrown exceptions into typed failed effects and mapping the error.
@@ -211,43 +189,44 @@ export declare function deferTry<R = never, E = never, A = never>(io: () => IO<R
  * @tsplus static IOOps deferTryCatch
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function deferTryCatch<R, E, A, E1>(io: () => IO<R, E, A>, onThrow: (error: unknown) => E1, __tsplusTrace?: string): IO<R, E | E1, A>;
+export declare function deferTryCatch<R, E, A, E1>(io: Lazy<IO<R, E, A>>, onThrow: (error: unknown) => E1, __tsplusTrace?: string): IO<R, E | E1, A>;
 /**
  * Folds an `IO` that may fail with `E` or succeed with `A` into one that never fails but succeeds with `Either<E, A>`
  * @tsplus getter fncts.io.IO either
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function either<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R, Either<E, A>>;
+export declare function either<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): URIO<R, Either<E, A>>;
 /**
  * @tsplus pipeable fncts.io.IO errorAsCause
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function errorAsCause(__tsplusTrace?: string): <R, E, A>(ma: IO<R, Cause<E>, A>) => IO<R, E, A>;
+export declare function errorAsCause(__tsplusTrace?: string): <R, E, A>(self: IO<R, Cause<E>, A>) => IO<R, E, A>;
 /**
  * @tsplus getter fncts.io.IO eventually
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function eventually<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, A>;
+export declare function eventually<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, A>;
 /**
- * @tsplus pipeable fncts.io.IO extend
+ * @tsplus pipeable fncts.io.IO exitWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function extend<R, E, A, B>(f: (wa: IO<R, E, A>) => B, __tsplusTrace?: string): (wa: IO<R, E, A>) => IO<R, E, B>;
+export declare function exitWith<E, A, R1, E1, B>(f: (exit: Exit<E, A>) => IO<R1, E1, B>, __tsplusTrace?: string): <R>(self: IO<R, E, A>) => IO<R | R1, E1, B>;
 /**
- * @tsplus static fncts.io.IOOps fail
+ * @tsplus pipeable fncts.io.IO extend
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function fail<E>(e: Lazy<E>, __tsplusTrace?: string): FIO<E, never>;
+export declare function extend<R, E, A, B>(f: (io: IO<R, E, A>) => B, __tsplusTrace?: string): (self: IO<R, E, A>) => IO<R, E, B>;
 /**
- * @tsplus static fncts.io.IOOps failNow
+ * @tsplus static fncts.io.IOOps fail
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function failNow<E>(e: E, __tsplusTrace?: string): FIO<E, never>;
+export declare function fail<E>(e: Lazy<E>, __tsplusTrace?: string): FIO<E, never>;
 /**
- * @tsplus static fncts.io.IOOps refailCause
+ * Returns an effect that models failure with the specified lazily-evaluated `Cause`.
+ * @tsplus static fncts.io.IOOps failCause
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function refailCause<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E, never>;
+export declare function failCause<E = never, A = never>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): FIO<E, A>;
 /**
  * Creates a `IO` that has failed with the specified `Cause`
  * @tsplus static fncts.io.IOOps failCauseNow
@@ -255,11 +234,10 @@ export declare function refailCause<E>(cause: Cause<E>, __tsplusTrace?: string):
  */
 export declare function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E, never>;
 /**
- * Returns an effect that models failure with the specified lazily-evaluated `Cause`.
- * @tsplus static fncts.io.IOOps failCause
+ * @tsplus static fncts.io.IOOps failNow
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function failCause<E = never, A = never>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): FIO<E, A>;
+export declare function failNow<E>(e: E, __tsplusTrace?: string): FIO<E, never>;
 /**
  * Returns the `FiberId` of the `Fiber` on which this `IO` is running
  * @tsplus static fncts.io.IOOps fiberId
@@ -308,20 +286,33 @@ export declare function filterOrElse<A, R1, E1, A1>(predicate: Predicate<A>, or:
  */
 export declare 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 declare function filterOrFail<A, E1>(predicate: Predicate<A>, failWith: (a: A) => E1): <R, E>(fa: IO<R, E, A>) => IO<R, E | E1, A>;
+/**
+ * Halts with specified `unknown` if the predicate fails.
+ * @tsplus pipeable fncts.io.IO filterOrHalt
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function filterOrHalt<A, B extends A>(refinement: Refinement<A, B>, haltWith: (a: Exclude<A, B>) => unknown, __tsplusTrace?: string): <R, E>(fa: IO<R, E, A>) => IO<R, E, A>;
+export declare function filterOrHalt<A>(predicate: Predicate<A>, haltWith: (a: A) => unknown, __tsplusTrace?: string): <R, E>(fa: IO<R, E, A>) => IO<R, E, A>;
 /**
  * Returns an `IO` that yields the value of the first
  * `IO` to succeed.
  * @tsplus static fncts.io.IOOps firstSuccess
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function firstSuccess<R, E, A>(mas: NonEmptyArray<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, A>;
+export declare function firstSuccess<R, E, A>(ios: ReadonlyNonEmptyArray<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, A>;
 /**
- * Halts with specified `unknown` if the predicate fails.
- * @tsplus pipeable fncts.io.IO filterOrHalt
+ * 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
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function filterOrHalt<A, B extends A>(refinement: Refinement<A, B>, haltWith: (a: Exclude<A, B>) => unknown, __tsplusTrace?: string): <R, E>(fa: IO<R, E, A>) => IO<R, E, A>;
-export declare function filterOrHalt<A>(predicate: Predicate<A>, haltWith: (a: A) => unknown, __tsplusTrace?: string): <R, E>(fa: IO<R, E, A>) => IO<R, E, A>;
+export declare function flatMap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R | R1, E | E1, B>;
+/**
+ * @tsplus pipeable fncts.io.IO flatMapError
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function flatMapError<R1, E, E1>(f: (e: E) => IO<R1, never, E1>, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R | R1, E1, A>;
 /**
  * @tsplus getter fncts.io.IO flatten
  * @tsplus location "@fncts/io/IO/api"
@@ -330,19 +321,22 @@ export declare function flatten<R, E, R1, E1, A>(self: IO<R, E, IO<R1, E1, A>>,
 /**
  * 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
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function foldLeft<A, B, R, E>(as: Iterable<A>, b: B, f: (b: B, a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, B>;
 /**
  * Combines an array of `IO`s using a `Monoid`
  * @tsplus static fncts.io.IOOps foldMap
+ * @tsplus fluent fncts.Iterable foldMapIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function foldMap<R, E, A, M>(as: Iterable<IO<R, E, A>>, f: (a: A) => M, 
+export declare function foldMap<R, E, A, M>(ios: Iterable<IO<R, E, A>>, f: (a: A) => M, 
 /** @tsplus auto */ M: P.Monoid<M>): IO<R, E, M>;
 /**
  * Performs a right-associative fold of an `Iterable<A>`
  * @tsplus static fncts.io.IOOps foldRight
+ * @tsplus fluent fncts.Iterable foldRightIO
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function foldRight<A, B, R, E>(as: Iterable<A>, b: UIO<B>, f: (a: A, b: IO<R, E, B>) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, B>;
@@ -353,9 +347,18 @@ export declare function foldRight<A, B, R, E>(as: Iterable<A>, b: UIO<B>, f: (a:
  * For a parallel version of this method, see `foreachC`.
  * 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
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function foreach<A, R, E, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, Conc<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
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function foreachDiscard<A, R, E, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, void>;
 /**
  * Applies the function `f` to each element of the `Iterable<A>` and
  * returns the results in a new `Conc<B>`.
@@ -363,21 +366,16 @@ export declare function foreach<A, R, E, B>(as: Iterable<A>, f: (a: A) => IO<R,
  * For a parallel version of this method, see `foreachC`.
  * 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
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function foreachWithIndex<A, R, E, B>(as: Iterable<A>, f: (i: number, a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, Conc<B>>;
 /**
  * @tsplus static fncts.io.IOOps foreachWithIndexDiscard
+ * @tsplus fluent fncts.Iterable foreachWithIndexDiscardIO
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function foreachWithIndexDiscard<A, R, E, B>(as: Iterable<A>, f: (i: number, a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, void>;
-/**
- * Applies the function `f` to each element of the `Iterable<A>` and runs
- * produced IOs sequentially.
- * @tsplus static fncts.io.IOOps foreachDiscard
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function foreachDiscard<A, R, E, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, void>;
 /**
  * Repeats this effect forever (until the first failure).
  * @tsplus getter fncts.io.IO forever
@@ -432,18 +430,18 @@ export declare function fromMaybe<A>(maybe: Lazy<Maybe<A>>, __tsplusTrace?: stri
 export declare function fromMaybeNow<A = never>(maybe: Maybe<A>, __tsplusTrace?: string): IO<never, NoSuchElementError, A>;
 /**
  * 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
+ * errors will produce failure as `unknown`
+ * @tsplus static fncts.io.IOOps fromPromise
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function fromPromiseCatch<E, A>(promise: Lazy<Promise<A>>, onReject: (reason: unknown) => E, __tsplusTrace?: string): FIO<E, A>;
+export declare function fromPromise<A>(promise: Lazy<Promise<A>>, __tsplusTrace?: string): FIO<unknown, 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
+ * errors will be handled using `onReject`
+ * @tsplus static fncts.io.IOOps fromPromiseCatch
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function fromPromise<A>(promise: Lazy<Promise<A>>, __tsplusTrace?: string): FIO<unknown, A>;
+export declare function fromPromiseCatch<E, A>(promise: Lazy<Promise<A>>, onReject: (reason: unknown) => E, __tsplusTrace?: string): FIO<E, A>;
 /**
  * Like fromPromise but produces a defect in case of errors
  * @tsplus static fncts.io.IOOps fromPromiseHalt
@@ -456,6 +454,11 @@ export declare function fromPromiseHalt<A>(promise: Lazy<Promise<A>>, __tsplusTr
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function get<R, E, A>(ma: IO<R, E, Maybe<A>>, __tsplusTrace?: string): IO<R, Maybe<E>, A>;
+/**
+ * @tsplus static fncts.io.IOOps getFiberRefs
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function getFiberRefs(__tsplusTrace?: string): UIO<FiberRefs>;
 /**
  * Extracts the optional value, or returns the given 'orElse'.
  * @tsplus pipeable fncts.io.IO getOrElse
@@ -468,12 +471,6 @@ export declare function getOrElse<B>(orElse: Lazy<B>, __tsplusTrace?: string): <
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function getOrElseIO<R1, E1, B>(orElse: Lazy<IO<R1, E1, B>>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, Maybe<A>>) => IO<R | R1, E | E1, A | B>;
-/**
- * Lifts a Maybe into an IO. If the option is `Nothing`, fail with `onNothing`.
- * @tsplus static fncts.io.IOOps getOrFailWith
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function getOrFailWith<E, A>(maybe: Maybe<A>, onNothing: Lazy<E>, __tsplusTrace?: string): FIO<E, A>;
 /**
  * Lifts a Maybe into a IO, if the Maybe is `Nothing` it fails with Unit.
  * @tsplus static fncts.io.IOOps getOrFailUnit
@@ -481,10 +478,11 @@ export declare function getOrFailWith<E, A>(maybe: Maybe<A>, onNothing: Lazy<E>,
  */
 export declare function getOrFailUnit<A>(option: Maybe<A>, __tsplusTrace?: string): FIO<void, A>;
 /**
- * @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
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function getFiberRefs(__tsplusTrace?: string): UIO<FiberRefs>;
+export declare function getOrFailWith<E, A>(maybe: Maybe<A>, onNothing: Lazy<E>, __tsplusTrace?: string): FIO<E, A>;
 /**
  * Creates an `IO` that halts with the specified lazily-evaluated defect.
  * This method can be used for terminating a fiber because a defect has been
@@ -506,28 +504,23 @@ export declare function haltNow(e: unknown, __tsplusTrace?: string): UIO<never>;
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function ifIO<R1, E1, B, R2, E2, C>(onFalse: Lazy<IO<R1, E1, B>>, onTrue: Lazy<IO<R2, E2, C>>, __tsplusTrace?: string): <R, E>(self: IO<R, E, boolean>) => IO<R | R1 | R2, E | E1 | E2, B | C>;
-/**
- * @tsplus static fncts.io.IOOps if
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare 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>;
 /**
  * @tsplus getter fncts.io.IO ignore
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function ignore<R, E, A>(fa: IO<R, E, A>, __tsplusTrace?: string): URIO<R, void>;
+export declare function ignore<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): URIO<R, void>;
 /**
  * Folds a `IO` to a boolean describing whether or not it is a failure
  * @tsplus getter fncts.io.IO isFailure
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function isFailure<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, boolean>;
+export declare function isFailure<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, boolean>;
 /**
  * Folds a `IO` to a boolean describing whether or not it is a success
  * @tsplus getter fncts.io.IO isSuccess
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function isSuccess<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, boolean>;
+export declare function isSuccess<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, boolean>;
 /**
  * Iterates with the specified effectual function. The moral equivalent of:
  *
@@ -544,27 +537,22 @@ export declare function isSuccess<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: stri
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function iterate<R, E, A>(initial: A, cont: (a: A) => boolean, body: (a: A) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
-/**
- * Returns an IO with the value on the left part.
- * @tsplus static fncts.io.IOOps left
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function left<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<Either<A, never>>;
 /**
  * @tsplus getter fncts.io.IO just
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function just<R, E, A>(self: IO<R, E, Maybe<A>>): IO<R, Maybe<E>, A>;
 /**
- * @tsplus static fncts.io.IOOps log
+ * Returns an IO with the value on the left part.
+ * @tsplus static fncts.io.IOOps left
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function log(message: Lazy<string>, __tsplusTrace?: string): UIO<void>;
+export declare function left<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<Either<A, never>>;
 /**
- * @tsplus static fncts.io.IOOps show
+ * @tsplus static fncts.io.IOOps log
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function show(message: Lazy<unknown>, options?: Partial<ShowOptions>, __tsplusTrace?: string): UIO<void>;
+export declare function log(message: Lazy<string>, __tsplusTrace?: string): UIO<void>;
 /**
  * Loops with the specified effectual function, collecting the results into a
  * list. The moral equivalent of:
@@ -605,7 +593,7 @@ export declare function loopUnit<A, R, E>(initial: A, cont: (a: A) => boolean, i
  * @tsplus pipeable fncts.io.IO map
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function map<A, B>(f: (a: A) => B, __tsplusTrace?: string): <R, E>(fa: IO<R, E, A>) => IO<R, E, B>;
+export declare function map<A, B>(f: (a: A) => B, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R, E, B>;
 /**
  * Map covariantly over the first argument.
  *
@@ -615,12 +603,7 @@ export declare function map<A, B>(f: (a: A) => B, __tsplusTrace?: string): <R, E
  * @tsplus pipeable fncts.io.IO mapError
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function mapError<E, E1>(f: (e: E) => E1, __tsplusTrace?: string): <R, A>(fea: IO<R, E, A>) => IO<R, E1, A>;
-/**
- * @tsplus static fncts.io.IOOps mapTryCatch
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare 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>;
+export declare function mapError<E, E1>(f: (e: E) => E1, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R, E1, A>;
 /**
  * Returns an IO with its full cause of failure mapped using
  * the specified function. This can be used to transform errors
@@ -628,7 +611,21 @@ export declare function mapTryCatch<R, E, A, E1, B>(io: IO<R, E, A>, f: (a: A) =
  * @tsplus pipeable fncts.io.IO mapErrorCause
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function mapErrorCause<E, E1>(f: (cause: Cause<E>) => Cause<E1>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R, E1, A>;
+export declare function mapErrorCause<E, E1>(f: (cause: Cause<E>) => Cause<E1>, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R, E1, A>;
+/**
+ * @tsplus static fncts.io.IOOps mapTryCatch
+ * @tsplus pipeable fncts.io.IO mapTryCatch
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function mapTryCatch<A, E1, B>(f: (a: A) => B, onThrow: (u: unknown) => E1, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R, E | E1, B>;
+/**
+ * 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
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function match<E, A, B, C>(onFailure: (e: E) => B, onSuccess: (a: A) => C, __tsplusTrace?: string): <R>(self: IO<R, E, A>) => IO<R, never, B | C>;
 /**
  * A more powerful version of `match_` that allows recovering from any kind of failure except interruptions.
  * @tsplus pipeable fncts.io.IO matchCause
@@ -646,47 +643,71 @@ export declare function matchCauseIO<E, A, R1, E1, A1, R2, E2, A2>(onFailure: (c
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare 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): <R>(self: IO<R, E, A>) => IO<R | R1 | R2, E1 | E2, 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
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function match<E, A, B, C>(onFailure: (e: E) => B, onSuccess: (a: A) => C, __tsplusTrace?: string): <R>(self: IO<R, E, A>) => IO<R, never, B | C>;
 /**
  * A version of `matchIO` that gives you the (optional) trace of the error.
  * @tsplus pipeable fncts.io.IO matchTraceIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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): <R>(ma: IO<R, E, A>) => IO<R | R1 | R2, E1 | E2, A1 | A2>;
+export declare 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): <R>(self: IO<R, E, A>) => IO<R | R1 | R2, E1 | E2, A1 | A2>;
 /**
  * @tsplus getter fncts.io.IO maybe
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function maybe<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): URIO<R, Maybe<A>>;
+export declare function maybe<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): URIO<R, Maybe<A>>;
 /**
  * @tsplus getter fncts.io.IO merge
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function merge<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, A | E>;
+export declare function merge<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, A | E>;
 /**
  * Merges an `Iterable<IO>` to a single IO, working sequentially.
  * @tsplus static fncts.io.IOOps mergeAll
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function mergeAll<R, E, A, B>(fas: Iterable<IO<R, E, A>>, b: B, f: (b: B, a: A) => B, __tsplusTrace?: string): IO<R, E, B>;
+export declare function mergeAll<R, E, A, B>(ios: Iterable<IO<R, E, A>>, b: B, f: (b: B, a: A) => B, __tsplusTrace?: string): IO<R, E, B>;
+/**
+ * @tsplus static fncts.io.IOOps refailCause
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function refailCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): FIO<E, never>;
+/**
+ * @tsplus static fncts.io.IOOps refailCauseNow
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function refailCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E, never>;
+/**
+ * @tsplus static fncts.io.IOOps show
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function show(message: Lazy<unknown>, options?: Partial<ShowOptions>, __tsplusTrace?: string): UIO<void>;
 /**
  * @tsplus static fncts.io.IOOps nothing
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare const nothing: IO<never, never, import("@fncts/base/data/Maybe.js").Maybe<never>>;
+/**
+ * Returns an `IO` that submerges an `Either` into the `IO`.
+ * @tsplus getter fncts.io.IO absolve
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function absolve<R, E, E1, A>(self: IO<R, E, Either<E1, A>>, __tsplusTrace?: string): IO<R, E | E1, A>;
+/**
+ * @tsplus static fncts.io.IOOps attempt
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function attempt<A>(effect: Lazy<A>, __tsplusTrace?: string): FIO<unknown, A>;
+/**
+ * Exposes all parallel errors in a single call
+ * @tsplus pipeable fncts.io.IO concurrentErrors
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function concurrentErrors(__tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R, List<E>, A>;
 /**
  * Converts an option on errors into an option on values.
  * @tsplus getter fncts.io.IO optional
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function optional<R, E, A>(ma: IO<R, Maybe<E>, A>, __tsplusTrace?: string): IO<R, E, Maybe<A>>;
+export declare function optional<R, E, A>(self: IO<R, Maybe<E>, A>, __tsplusTrace?: string): IO<R, E, Maybe<A>>;
 /**
  * Returns the logical disjunction of the `Boolean` value returned by this
  * effect and the `Boolean` value returned by the specified effect. This
@@ -696,12 +717,12 @@ export declare function optional<R, E, A>(ma: IO<R, Maybe<E>, A>, __tsplusTrace?
  * @tsplus pipeable-operator fncts.io.IO ||
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function or<R1, E1>(mb: IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, boolean>) => IO<R | R1, E | E1, boolean>;
+export declare function or<R1, E1>(or: IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(self: IO<R, E, boolean>) => IO<R | R1, E | E1, boolean>;
 /**
  * @tsplus pipeable fncts.io.IO orElse
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orElse<R1, E1, A1>(that: Lazy<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R | R1, E1, A | A1>;
+export declare function orElse<R1, E1, A1>(that: Lazy<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R | R1, E1, A | A1>;
 /**
  * @tsplus pipeable fncts.io.IO orElseEither
  * @tsplus location "@fncts/io/IO/api"
@@ -711,38 +732,32 @@ export declare function orElseEither<R1, E1, A1>(that: Lazy<IO<R1, E1, A1>>, __t
  * @tsplus pipeable fncts.io.IO orElseFail
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orElseFail<E1>(e: Lazy<E1>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, E1, A>;
+export declare function orElseFail<E1>(e: Lazy<E1>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R, E1, A>;
 /**
  * @tsplus pipeable fncts.io.IO orElseMaybe
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orElseMaybe<R1, E1, A1>(that: Lazy<IO<R1, Maybe<E1>, A1>>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, Maybe<E>, A>) => IO<R | R1, Maybe<E | E1>, A | A1>;
+export declare function orElseMaybe<R1, E1, A1>(that: Lazy<IO<R1, Maybe<E1>, A1>>, __tsplusTrace?: string): <R, E, A>(self: IO<R, Maybe<E>, A>) => IO<R | R1, Maybe<E | E1>, A | A1>;
 /**
  * @tsplus pipeable fncts.io.IO orElseSucceed
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orElseSucceed<A1>(a: Lazy<A1>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, E, A | A1>;
+export declare function orElseSucceed<A1>(a: Lazy<A1>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R, E, A | A1>;
 /**
  * @tsplus getter fncts.io.IO orHalt
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orHalt<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, A>;
+export declare function orHalt<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, A>;
 /**
  * @tsplus getter fncts.io.IO orHaltKeep
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orHaltKeep<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, A>;
+export declare function orHaltKeep<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, A>;
 /**
  * @tsplus pipeable fncts.io.IO orHaltWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orHaltWith<E>(f: (e: E) => unknown, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R, never, A>;
-/**
- * Exposes all parallel errors in a single call
- * @tsplus pipeable fncts.io.IO concurrentErrors
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function concurrentErrors(__tsplusTrace?: string): <R, E, A>(io: IO<R, E, A>) => IO<R, List<E>, A>;
+export declare function orHaltWith<E>(f: (e: E) => unknown, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R, never, A>;
 /**
  * Feeds elements of type `A` to a function `f` that returns an IO.
  * Collects all successes and failures in a separated fashion.
@@ -755,21 +770,21 @@ export declare function partition<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO<R
  * @tsplus pipeable fncts.io.IO refineOrHalt
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function refineOrHalt<E, E1>(pf: (e: E) => Maybe<E1>, __tsplusTrace?: string): <R, A>(fa: IO<R, E, A>) => IO<R, E1, A>;
+export declare function refineOrHalt<E, E1>(pf: (e: E) => Maybe<E1>, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R, E1, A>;
 /**
  * Keeps some of the errors, and terminates the fiber with the rest, using
  * the specified function to convert the `E` into a `Throwable`.
  * @tsplus pipeable fncts.io.IO refineOrHaltWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function refineOrHaltWith<E, E1>(pf: (e: E) => Maybe<E1>, f: (e: E) => unknown, __tsplusTrace?: string): <R, A>(fa: IO<R, E, A>) => IO<R, E1, A>;
+export declare function refineOrHaltWith<E, E1>(pf: (e: E) => Maybe<E1>, f: (e: E) => unknown, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R, E1, A>;
 /**
  * Fail with the returned value if the partial function `pf` matches, otherwise
  * continue with the held value.
  * @tsplus pipeable fncts.io.IO reject
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function reject<A, E1>(pf: (a: A) => Maybe<E1>, __tsplusTrace?: string): <R, E>(fa: IO<R, E, A>) => IO<R, E | E1, A>;
+export declare function reject<A, E1>(pf: (a: A) => Maybe<E1>, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R, E | E1, A>;
 /**
  * Continue with the returned computation if the partial function `pf` matches,
  * translating the successful match into a failure, otherwise continue with
@@ -777,95 +792,95 @@ export declare function reject<A, E1>(pf: (a: A) => Maybe<E1>, __tsplusTrace?: s
  * @tsplus pipeable fncts.io.IO rejectIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function rejectIO<A, R1, E1>(pf: (a: A) => Maybe<IO<R1, E1, E1>>, __tsplusTrace?: string): <R, E>(fa: IO<R, E, A>) => IO<R | R1, E | E1, A>;
+export declare function rejectIO<A, R1, E1>(pf: (a: A) => Maybe<IO<R1, E1, E1>>, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R | R1, E | E1, A>;
 /**
  * Repeats this effect the specified number of times.
  * @tsplus pipeable fncts.io.IO repeatN
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function repeatN_(n: number, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, E, A>;
+export declare function repeatN_(n: number, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R, E, A>;
 /**
  * Repeats this effect until its result satisfies the specified predicate.
  * @tsplus pipeable fncts.io.IO repeatUntil
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function repeatUntil<A>(f: (a: A) => boolean, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R, E, A>;
+export declare function repeatUntil<A>(f: (a: A) => boolean, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R, E, A>;
 /**
  * Repeats this effect until its error satisfies the specified effectful predicate.
  * @tsplus pipeable fncts.io.IO repeatUntilIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function repeatUntilIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R | R1, E | E1, A>;
+export declare function repeatUntilIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R | R1, E | E1, A>;
 /**
  * Repeats this effect while its error satisfies the specified predicate.
  * @tsplus pipeable fncts.io.IO repeatWhile
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function repeatWhile<A>(f: (a: A) => boolean, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R, E, A>;
+export declare function repeatWhile<A>(f: (a: A) => boolean, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R, E, A>;
 /**
  * Repeats this effect while its error satisfies the specified effectful predicate.
  * @tsplus pipeable fncts.io.IO repeatWhileIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function repeatWhileIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R | R1, E | E1, A>;
+export declare function repeatWhileIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R | R1, E | E1, A>;
 /**
  * @tsplus pipeable fncts.io.IO replicate
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function replicate(n: number, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => ImmutableArray<IO<R, E, A>>;
+export declare function replicate(n: number, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => ReadonlyArray<IO<R, E, A>>;
 /**
  * @tsplus pipeable fncts.io.IO require
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function require<E>(error: Lazy<E>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, Maybe<A>>) => IO<R, E, A>;
+export declare function require<E>(error: Lazy<E>, __tsplusTrace?: string): <R, A>(self: IO<R, E, Maybe<A>>) => IO<R, E, A>;
 /**
  * Returns an IO that semantically runs the IO on a fiber,
  * producing an `Exit` for the completion value of the fiber.
  * @tsplus getter fncts.io.IO result
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function result<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, Exit<E, A>>;
+export declare function result<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, Exit<E, A>>;
 /**
  * Recover from the unchecked failure of the `IO`. (opposite of `orHalt`)
  * @tsplus getter fncts.io.IO resurrect
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function resurrect<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, unknown, A>;
+export declare function resurrect<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, unknown, A>;
 /**
  * Retries this effect until its error satisfies the specified predicate.
  * @tsplus pipeable fncts.io.IO retryUntil
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function retryUntil<E>(f: (e: E) => boolean, __tsplusTrace?: string): <R, A>(fa: IO<R, E, A>) => IO<R, E, A>;
+export declare function retryUntil<E>(f: (e: E) => boolean, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R, E, A>;
 /**
  * Retries this effect until its error satisfies the specified effectful predicate.
  * @tsplus pipeable fncts.io.IO retryUntilIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function retryUntilIO<E, R1, E1>(f: (e: E) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, A>(fa: IO<R, E, A>) => IO<R | R1, E | E1, A>;
+export declare function retryUntilIO<E, R1, E1>(f: (e: E) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R | R1, E | E1, A>;
 /**
  * Retries this effect while its error satisfies the specified predicate.
  * @tsplus pipeable fncts.io.IO retryWhile
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function retryWhile<E>(f: (e: E) => boolean, __tsplusTrace?: string): <R, A>(fa: IO<R, E, A>) => IO<R, E, A>;
+export declare function retryWhile<E>(f: (e: E) => boolean, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R, E, A>;
 /**
  * Retries this effect while its error satisfies the specified effectful predicate.
  * @tsplus pipeable fncts.io.IO retryWhileIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function retryWhileIO<E, R1, E1>(f: (e: E) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, A>(fa: IO<R, E, A>) => IO<R | R1, E | E1, A>;
+export declare function retryWhileIO<E, R1, E1>(f: (e: E) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R | R1, E | E1, A>;
 /**
  * Exposes the full cause of failure of this effect.
  * @tsplus getter fncts.io.IO sandbox
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function sandbox<R, E, A>(fa: IO<R, E, A>, __tsplusTrace?: string): IO<R, Cause<E>, A>;
+export declare function sandbox<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, Cause<E>, A>;
 /**
  * @tsplus pipeable fncts.io.IO sandboxWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function sandboxWith<R, E, A, E1>(f: (_: IO<R, Cause<E>, A>) => IO<R, Cause<E1>, A>, __tsplusTrace?: string): (ma: IO<R, E, A>) => IO<R, E1, A>;
+export declare function sandboxWith<R, E, A, E1>(f: (_: IO<R, Cause<E>, A>) => IO<R, Cause<E1>, A>, __tsplusTrace?: string): (self: IO<R, E, A>) => IO<R, E1, A>;
 /**
  * @tsplus static fncts.io.IOOps sequenceIterable
  * @tsplus location "@fncts/io/IO/api"
@@ -876,12 +891,6 @@ export declare function sequenceIterable<R, E, A>(as: Iterable<IO<R, E, A>>, __t
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function sequenceIterableDiscard<R, E, A>(as: Iterable<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, void>;
-/**
- * Creates a `IO` that has succeeded with a pure value
- * @tsplus static fncts.io.IOOps succeedNow
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function succeedNow<A>(value: A, __tsplusTrace?: string): IO<never, never, A>;
 /**
  * Imports a total synchronous effect into a pure `IO` value.
  * The effect must not throw any exceptions. If you wonder if the effect
@@ -891,6 +900,12 @@ export declare function succeedNow<A>(value: A, __tsplusTrace?: string): IO<neve
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function succeed<A>(effect: Lazy<A>, __tsplusTrace?: string): UIO<A>;
+/**
+ * Creates a `IO` that has succeeded with a pure value
+ * @tsplus static fncts.io.IOOps succeedNow
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function succeedNow<A>(value: A, __tsplusTrace?: string): IO<never, never, A>;
 /**
  * @tsplus pipeable fncts.io.IO summarized
  * @tsplus location "@fncts/io/IO/api"
@@ -901,36 +916,13 @@ export declare function summarized<R1, E1, B, C>(summary: IO<R1, E1, B>, f: (sta
  * @tsplus getter fncts.io.IO swap
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function swap<R, E, A>(pab: IO<R, E, A>, __tsplusTrace?: string): IO<R, A, E>;
+export declare function swap<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, A, E>;
 /**
  * Swaps the error/value parameters, applies the function `f` and flips the parameters back
  * @tsplus pipeable fncts.io.IO swapWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function swapWith<R, E, A, R1, E1, A1>(f: (ma: IO<R, A, E>) => IO<R1, A1, E1>, __tsplusTrace?: string): (fa: IO<R, E, A>) => IO<R1, E1, A1>;
-/**
- * A more powerful variation of `timed` that allows specifying the clock.
- * @tsplus pipeable fncts.io.IO timedWith
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function timedWith<R1, E1>(msTime: IO<R1, E1, number>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R1 | R, E1 | E, readonly [number, A]>;
-/**
- * @tsplus static fncts.io.IOOps attempt
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function attempt<A>(effect: Lazy<A>, __tsplusTrace?: string): FIO<unknown, A>;
-/**
- * Creates a `IO` that has succeeded with a pure value
- * @tsplus static fncts.io.IOOps tryCatch
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function tryCatch<E, A>(effect: Lazy<A>, onThrow: (error: unknown) => E, __tsplusTrace?: string): FIO<E, A>;
-/**
- * Returns an `IO` that submerges an `Either` into the `IO`.
- * @tsplus getter fncts.io.IO absolve
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function absolve<R, E, E1, A>(ma: IO<R, E, Either<E1, A>>, __tsplusTrace?: string): IO<R, E | E1, A>;
+export declare function swapWith<R, E, A, R1, E1, A1>(f: (ma: IO<R, A, E>) => IO<R1, A1, E1>, __tsplusTrace?: string): (self: IO<R, E, A>) => IO<R1, E1, A1>;
 /**
  * Composes computations in sequence, using the return value of one computation as input for the next
  * and keeping only the result of the first
@@ -946,7 +938,7 @@ export declare function tap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTr
  * @tsplus pipeable fncts.io.IO tapCause
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function tapCause<R, E, E2>(f: (e: Cause<E2>) => IO<R, E, any>, __tsplusTrace?: string): <R2, A2>(ma: IO<R2, E2, A2>) => IO<R2 | R, E | E2, A2>;
+export declare function tapCause<R, E, E2>(f: (e: Cause<E2>) => IO<R, E, any>, __tsplusTrace?: string): <R2, A2>(self: IO<R2, E2, A2>) => IO<R2 | R, E | E2, A2>;
 /**
  * Returns an IO that effectfully "peeks" at the failure of this effect.
  * @tsplus pipeable fncts.io.IO tapError
@@ -960,11 +952,23 @@ export declare function tapError<E, R1, E1>(f: (e: E) => IO<R1, E1, any>, __tspl
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function tapErrorCause<E, R1, E1>(f: (e: Cause<E>) => IO<R1, E1, any>, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R | R1, E | E1, A>;
+/**
+ * A more powerful variation of `timed` that allows specifying the clock.
+ * @tsplus pipeable fncts.io.IO timedWith
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function timedWith<R1, E1>(msTime: IO<R1, E1, number>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E1 | E, readonly [number, A]>;
+/**
+ * Creates a `IO` that has succeeded with a pure value
+ * @tsplus static fncts.io.IOOps tryCatch
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function tryCatch<E, A>(effect: Lazy<A>, onThrow: (error: unknown) => E, __tsplusTrace?: string): FIO<E, A>;
 /**
  * @tsplus pipeable fncts.io.IO tryOrElse
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function tryOrElse<A, R1, E1, A1, R2, E2, A2>(that: Lazy<IO<R1, E1, A1>>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R | R1 | R2, E1 | E2, A1 | A2>;
+export declare function tryOrElse<A, R1, E1, A1, R2, E2, A2>(that: Lazy<IO<R1, E1, A1>>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R | R1 | R2, E1 | E2, A1 | A2>;
 /**
  * @tsplus static fncts.io.IOOps unit
  * @tsplus location "@fncts/io/IO/api"
@@ -982,13 +986,13 @@ export declare function unjust<R, E, A>(self: IO<R, Maybe<E>, A>, __tsplusTrace?
  * @tsplus pipeable fncts.io.IO unrefineWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function unrefineWith<E, E1, E2>(pf: (u: unknown) => Maybe<E1>, f: (e: E) => E2, __tsplusTrace?: string): <R, A>(fa: IO<R, E, A>) => IO<R, E1 | E2, A>;
+export declare function unrefineWith<E, E1, E2>(pf: (u: unknown) => Maybe<E1>, f: (e: E) => E2, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R, E1 | E2, A>;
 /**
  * The inverse operation `sandbox`
  * @tsplus getter fncts.io.IO unsandbox
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function unsandbox<R, E, A>(ma: IO<R, Cause<E>, A>, __tsplusTrace?: string): IO<R, E, A>;
+export declare function unsandbox<R, E, A>(self: IO<R, Cause<E>, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Updates the `FiberRef` values for the fiber running this effect using the
  * specified function
@@ -1001,33 +1005,38 @@ export declare function updateFiberRefs(f: (fiberId: FiberId.Runtime, fiberRefs:
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare const via: typeof pipe;
+/**
+ * @tsplus static fncts.io.IOOps stackTrace
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function stackTrace(__tsplusTrace?: string): UIO<Trace>;
+/**
+ * @tsplus static fncts.io.IOOps updateRuntimeFlags
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function updateRuntimeFlags(patch: RuntimeFlags.Patch, __tsplusTrace?: string): IO<never, never, void>;
 /**
  * @tsplus pipeable fncts.io.IO when
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function when(b: Lazy<boolean>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, E, void>;
+export declare function when(b: Lazy<boolean>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R, E, void>;
 /**
  * The moral equivalent of `if (p) exp` when `p` has side-effects
  * @tsplus pipeable fncts.io.IO whenIO
  * @tsplus static fncts.io.IOOps whenIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function whenIO<R1, E1>(mb: IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R1 | R, E | E1, Maybe<A>>;
-/**
- * @tsplus static fncts.io.IOOps withFiberRuntime
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function withFiberRuntime<R, E, A>(onState: (fiber: FiberRuntime<E, A>, status: Running) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+export declare function whenIO<R1, E1>(mb: IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E | E1, Maybe<A>>;
 /**
- * @tsplus static fncts.io.IOOps updateRuntimeFlags
+ * @tsplus static fncts.io.IOOps whileLoop
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function updateRuntimeFlags(patch: RuntimeFlags.Patch, __tsplusTrace?: string): IO<never, never, void>;
+export declare function whileLoop<R, E, A>(check: Lazy<boolean>, body: Lazy<IO<R, E, A>>, process: (a: A) => any, __tsPlusTrace?: string): IO<R, E, void>;
 /**
- * @tsplus static fncts.io.IOOps stackTrace
+ * @tsplus static fncts.io.IOOps withFiberRuntime
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function stackTrace(__tsplusTrace?: string): UIO<Trace>;
+export declare function withFiberRuntime<R, E, A>(onState: (fiber: FiberRuntime<E, A>, status: Running) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * 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
@@ -1041,11 +1050,28 @@ export declare const yieldNow: UIO<void>;
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function zip<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R | R1, E | E1, readonly [A, B]>;
+/**
+ * @tsplus pipeable fncts.io.IO zipLeft
+ * @tsplus pipeable-operator fncts.io.IO <
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function zipLeft<R1, E1, B>(fb: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E1 | E, A>;
+/**
+ * Combine two effectful actions, keeping only the result of the second
+ * @tsplus pipeable fncts.io.IO zipRight
+ * @tsplus pipeable-operator fncts.io.IO >
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function zipRight<R1, E1, B>(fb: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E1 | E, B>;
 /**
  * @tsplus pipeable fncts.io.IO zipWith
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function zipWith<A, R1, E1, B, C>(that: IO<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R | R1, E | E1, C>;
+/**
+ * @internal
+ */
+export declare const __adapter: (_: any) => any;
 export declare class GenIO<R, E, A> {
     readonly effect: IO<R, E, A>;
     readonly _trace?: string | undefined;
@@ -1055,10 +1081,6 @@ export declare class GenIO<R, E, A> {
     constructor(effect: IO<R, E, A>, _trace?: string | undefined);
     [Symbol.iterator](): Generator<GenIO<R, E, A>, A, any>;
 }
-/**
- * @internal
- */
-export declare const __adapter: (_: any) => any;
 /**
  * @tsplus static fncts.io.IOOps gen
  * @gen