@fncts/io 0.0.19 → 0.0.21

package/IO/api.d.ts

@@ -61,28 +61,28 @@ export declare function asyncInterrupt<R, E, A>(register: (cb: (resolve: IO<R, E
 /**
  * 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
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function absorbWith_<R, E, A>(ma: IO<R, E, A>, f: (e: E) => unknown, __tsplusTrace?: string): IO<R, unknown, A>;
+export declare function absorbWith<R, E, A>(f: (e: E) => unknown, __tsplusTrace?: string): (ma: IO<R, E, A>) => IO<R, unknown, A>;
 /**
- * @tsplus fluent fncts.io.IO apFirst
- * @tsplus operator fncts.io.IO <
+ * @tsplus pipeable fncts.io.IO apFirst
+ * @tsplus pipeable-operator fncts.io.IO <
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+export declare function apFirst<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 fluent fncts.io.IO apSecond
- * @tsplus operator fncts.io.IO >
+ * @tsplus pipeable fncts.io.IO apSecond
+ * @tsplus pipeable-operator fncts.io.IO >
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+export declare function apSecond<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 fluent fncts.io.IO as
+ * @tsplus pipeable fncts.io.IO as
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function as_<R, E, A, B>(self: IO<R, E, A>, b: Lazy<B>, __tsplusTrace?: string): IO<R, E, B>;
+export declare function as<B>(b: Lazy<B>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R, E, B>;
 /**
  * Maps the success value of this effect to an optional value.
  * @tsplus getter fncts.io.IO asJust
@@ -103,52 +103,50 @@ export declare function asUnit<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: strin
 /**
  * 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
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+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>;
 /**
  * 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
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function bitap_<R, E, A, R1, E1, R2, E2>(self: IO<R, E, A>, onFailure: (e: E) => IO<R1, E1, any>, onSuccess: (a: A) => IO<R2, E2, any>, __tsplusTrace?: string): IO<R | R1 | R2, E | E1 | E2, A>;
+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<R1 | R2 | R, E | E1 | E2, A>;
 /**
  * Recovers from the specified error
- * @tsplus fluent fncts.io.IO catch
+ * @tsplus pipeable fncts.io.IO catch
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function catch_<N extends keyof E, K extends E[N] & string, R, E, A, R1, E1, A1>(ma: IO<R, E, A>, tag: N, k: K, f: (e: Extract<E, {
+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): IO<R | R1, Exclude<E, {
-    [n in N]: K;
-}> | E1, A | A1>;
+}>) => IO<R1, E1, A1>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R1 | R, E1 | Exclude<E, { [n in N]: K; }>, A1 | A>;
 /**
  * Recovers from all errors
- * @tsplus fluent fncts.io.IO catchAll
+ * @tsplus pipeable fncts.io.IO catchAll
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+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<R1 | R, E1, A1 | A>;
 /**
  *
  * Recovers from all errors with provided cause.
- * @tsplus fluent fncts.io.IO catchAllCause
+ * @tsplus pipeable fncts.io.IO catchAllCause
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function catchAllCause_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, f: (_: Cause<E>) => IO<R1, E1, A1>, __tsplusTrace?: string): IO<R | R1, E1, A | A1>;
+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>;
 /**
  * Recovers from some or all of the error cases.
- * @tsplus fluent fncts.io.IO catchJust
+ * @tsplus pipeable fncts.io.IO catchJust
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+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<R1 | R, E | E1, A1 | A>;
 /**
  * Recovers from some or all of the error cases with provided cause.
- * @tsplus fluent fncts.io.IO catchJustCause
+ * @tsplus pipeable fncts.io.IO catchJustCause
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+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<R1 | R, E | E1, A1 | A>;
 /**
  * Recovers from some or all of the defects with provided partial function.
  *
@@ -156,45 +154,45 @@ export declare function catchJustCause_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, f:
  * method should be used only at the boundary between IO and an external
  * system, to transmit information on a defect for diagnostic or explanatory
  * purposes.
- * @tsplus fluent fncts.io.IO catchJustDefect
+ * @tsplus pipeable fncts.io.IO catchJustDefect
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+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<R1 | R, E1 | E, A1 | A>;
 /**
  * Recovers from the specified error
- * @tsplus fluent IO catchTag
+ * @tsplus pipeable IO catchTag
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function catchTag_<K extends E["_tag"] & string, R, E extends {
+export declare function catchTag<K extends E["_tag"] & string, E extends {
     _tag: string;
-}, A, R1, E1, A1>(ma: IO<R, E, A>, k: K, f: (e: Extract<E, {
+}, R1, E1, A1>(k: K, f: (e: Extract<E, {
     _tag: K;
-}>) => IO<R1, E1, A1>, __tsplusTrace?: string): IO<R | R1, Exclude<E, {
+}>) => IO<R1, E1, A1>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R1 | R, E1 | Exclude<E, {
     _tag: K;
-}> | E1, A | A1>;
+}>, A1 | A>;
 /**
  * @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>>;
 /**
- * @tsplus fluent fncts.io.IO causeAsError
+ * @tsplus pipeable fncts.io.IO causeAsError
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function causeAsError<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, Cause<E>, A>;
+export declare function causeAsError(__tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, import("@fncts/base/data/Cause.js").Cause<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 fluent fncts.io.IO flatMap
+ * @tsplus pipeable fncts.io.IO flatMap
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function flatMap_<R, E, A, R1, E1, B>(ma: IO<R, E, A>, f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): IO<R | R1, E | E1, B>;
+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<R1 | R, E1 | E, B>;
 /**
- * @tsplus fluent fncts.io.IO flatMapError
+ * @tsplus pipeable fncts.io.IO flatMapError
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+export declare function flatMapError<R1, E, E1>(f: (e: E) => IO<R1, never, E1>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R1 | R, E1, A>;
 /**
  * Checks the interrupt status, and produces the IO returned by the
  * specified callback.
@@ -203,20 +201,20 @@ export declare function flatMapError_<R, R1, E, E1, A>(ma: IO<R, E, A>, f: (e: E
  */
 export declare function checkInterruptible<R, E, A>(f: (i: InterruptStatus) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
- * @tsplus fluent fncts.io.IO collect
+ * @tsplus pipeable fncts.io.IO collect
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+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, E1 | E, A1>;
 /**
- * @tsplus fluent fncts.io.IO collectIO
+ * @tsplus pipeable fncts.io.IO collectIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+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<R1 | R, E1 | E2 | E, A1>;
 /**
  * @tsplus static fncts.io.IOOps condIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function condIO_<R, R1, E, A>(b: boolean, onTrue: URIO<R, A>, onFalse: URIO<R1, E>, __tsplusTrace?: string): IO<R | R1, E, A>;
+export declare function condIO<R, R1, E, A>(b: boolean, onTrue: URIO<R, A>, onFalse: URIO<R1, E>, __tsplusTrace?: string): IO<R | R1, E, A>;
 /**
  * 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)
@@ -286,25 +284,25 @@ export declare function descriptorWith<R, E, A>(f: (d: FiberDescriptor) => IO<R,
  */
 export declare function either<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R, Either<E, A>>;
 /**
- * @tsplus fluent fncts.io.IO ensuring
+ * @tsplus pipeable fncts.io.IO ensuring
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function ensuring_<R, E, A, R1>(self: IO<R, E, A>, finalizer: IO<R1, never, any>, __tsplusTrace?: string): IO<R | R1, E, A>;
+export declare function ensuring<R1>(finalizer: IO<R1, never, any>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E, A>;
 /**
- * @tsplus fluent fncts.io.IO errorAsCause
+ * @tsplus pipeable fncts.io.IO errorAsCause
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function errorAsCause<R, E, A>(ma: IO<R, Cause<E>, A>, __tsplusTrace?: string): IO<R, E, A>;
+export declare function errorAsCause(__tsplusTrace?: string): <R, E, A>(ma: IO<R, import("@fncts/base/data/Cause.js").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>;
 /**
- * @tsplus fluent fncts.io.IO extend
+ * @tsplus pipeable fncts.io.IO extend
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function extend_<R, E, A, B>(wa: IO<R, E, A>, f: (wa: IO<R, E, A>) => B, __tsplusTrace?: string): IO<R, E, B>;
+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>;
 /**
  * @tsplus static fncts.io.IOOps fail
  * @tsplus location "@fncts/io/IO/api"
@@ -338,38 +336,38 @@ export declare const fiberId: IO<never, never, FiberId>;
  * @tsplus static fncts.io.IOOps filter
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function filter_<A, R, E>(as: Iterable<A>, f: (a: A) => IO<R, E, boolean>, __tsplusTrace?: string): IO<R, E, Conc<A>>;
+export declare function filter<A, R, E>(as: Iterable<A>, f: (a: A) => IO<R, E, boolean>, __tsplusTrace?: string): IO<R, E, Conc<A>>;
 /**
  * @tsplus static fncts.io.IOOps filterMap
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function filterMap_<A, R, E, B>(as: Iterable<A>, f: (a: A) => IO<R, E, Maybe<B>>, __tsplusTrace?: string): IO<R, E, Conc<B>>;
+export declare function filterMap<A, R, E, B>(as: Iterable<A>, f: (a: A) => IO<R, E, Maybe<B>>, __tsplusTrace?: string): IO<R, E, Conc<B>>;
 /**
  * @tsplus static fncts.io.IOOps filterMapWithIndex
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function filterMapWithIndex_<A, R, E, B>(as: Iterable<A>, f: (i: number, a: A) => IO<R, E, Maybe<B>>, __tsplusTrace?: string): IO<R, E, Conc<B>>;
+export declare function filterMapWithIndex<A, R, E, B>(as: Iterable<A>, f: (i: number, a: A) => IO<R, E, Maybe<B>>, __tsplusTrace?: string): IO<R, E, Conc<B>>;
 /**
  * Filters the collection using the specified effectual predicate, removing
  * all elements that satisfy the predicate.
  * @tsplus static fncts.io.IOOps filterNot
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function filterNot_<A, R, E>(as: Iterable<A>, f: (a: A) => IO<R, E, boolean>, __tsplusTrace?: string): IO<R, E, Conc<A>>;
+export declare function filterNot<A, R, E>(as: Iterable<A>, f: (a: A) => IO<R, E, boolean>, __tsplusTrace?: string): IO<R, E, Conc<A>>;
 /**
  * Applies `or` if the predicate fails.
- * @tsplus fluent fncts.io.IO filterOrElse
+ * @tsplus pipeable fncts.io.IO filterOrElse
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function filterOrElse_<R, E, A, B extends A, R1, E1, A1>(fa: IO<R, E, A>, refinement: Refinement<A, B>, or: (a: Exclude<A, B>) => IO<R1, E1, A1>, __tsplusTrace?: string): IO<R | R1, E | E1, B | A1>;
-export declare function filterOrElse_<R, E, A, R1, E1, A1>(fa: IO<R, E, A>, predicate: Predicate<A>, or: (a: A) => IO<R1, E1, A1>, __tsplusTrace?: string): IO<R | R1, E | E1, A | A1>;
+export declare function filterOrElse<A, B extends A, R1, E1, A1>(refinement: Refinement<A, B>, or: (a: Exclude<A, B>) => IO<R1, E1, A1>, __tsplusTrace?: string): <R, E>(fa: IO<R, E, A>) => IO<R | R1, E | E1, B | A1>;
+export declare function filterOrElse<A, R1, E1, A1>(predicate: Predicate<A>, or: (a: A) => IO<R1, E1, A1>, __tsplusTrace?: string): <R, E>(fa: IO<R, E, A>) => IO<R | R1, E | E1, A | A1>;
 /**
  * Fails with `failWith` if the predicate fails.
- * @tsplus fluent fncts.io.IO filterOrFail
+ * @tsplus pipeable fncts.io.IO filterOrFail
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function filterOrFail_<R, E, A, B extends A, E1>(fa: IO<R, E, A>, refinement: Refinement<A, B>, failWith: (a: Exclude<A, B>) => E1): IO<R, E | E1, B>;
-export declare function filterOrFail_<R, E, A, E1>(fa: IO<R, E, A>, predicate: Predicate<A>, failWith: (a: A) => E1): IO<R, E | E1, A>;
+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>;
 /**
  * Returns an `IO` that yields the value of the first
  * `IO` to succeed.
@@ -379,11 +377,11 @@ export declare function filterOrFail_<R, E, A, E1>(fa: IO<R, E, A>, predicate: P
 export declare function firstSuccess<R, E, A>(mas: NonEmptyArray<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Halts with specified `unknown` if the predicate fails.
- * @tsplus fluent fncts.io.IO filterOrHalt
+ * @tsplus pipeable fncts.io.IO filterOrHalt
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function filterOrHalt_<R, E, A, B extends A>(fa: IO<R, E, A>, refinement: Refinement<A, B>, haltWith: (a: Exclude<A, B>) => unknown, __tsplusTrace?: string): IO<R, E, A>;
-export declare function filterOrHalt_<R, E, A>(fa: IO<R, E, A>, predicate: Predicate<A>, haltWith: (a: A) => unknown, __tsplusTrace?: string): IO<R, E, A>;
+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>;
 /**
  * @tsplus getter fncts.io.IO flatten
  * @tsplus location "@fncts/io/IO/api"
@@ -394,20 +392,20 @@ export declare function flatten<R, E, R1, E1, A>(self: IO<R, E, IO<R1, E1, A>>,
  * @tsplus static fncts.io.IOOps foldLeft
  * @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>;
+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 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>(as: 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 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>;
+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>;
 /**
  * Applies the function `f` to each element of the `Iterable<A>` and
  * returns the results in a new `Conc<B>`.
@@ -417,7 +415,7 @@ export declare function foldRight_<A, B, R, E>(as: Iterable<A>, b: UIO<B>, f: (a
  * @tsplus static fncts.io.IOOps foreach
  * @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>>;
+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
  * returns the results in a new `Conc<B>`.
@@ -427,19 +425,19 @@ export declare function foreach_<A, R, E, B>(as: Iterable<A>, f: (a: A) => IO<R,
  * @tsplus static fncts.io.IOOps foreachWithIndex
  * @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>>;
+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 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>;
+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>;
+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
@@ -455,7 +453,7 @@ export declare function forever<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string
  * 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.
+ * `zipC`, 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
@@ -480,12 +478,14 @@ export declare function fromEither<E, A>(either: Lazy<Either<E, A>>, __tsplusTra
 /**
  * Lifts an `Either` into an `IO`
  * @tsplus static fncts.io.IOOps fromEitherNow
+ * @tsplus getter fncts.Either toIO
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function fromEitherNow<E, A>(either: Either<E, A>, __tsplusTrace?: string): IO<never, E, A>;
 /**
  * Lifts an `Eval` into an `IO`
  * @tsplus static fncts.io.IOOps fromEval
+ * @tsplus getter fncts.Eval toIO
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function fromEval<A>(computation: Eval<A>, __tsplusTrace?: string): IO<never, never, A>;
@@ -498,6 +498,7 @@ export declare function fromExit<E, A>(exit: Lazy<Exit<E, A>>, __tsplusTrace?: s
 /**
  * Creates a `IO` from an exit value
  * @tsplus static fncts.io.IOOps fromExitNow
+ * @tsplus getter fncts.Exit toIO
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function fromExitNow<E, A>(exit: Exit<E, A>, __tsplusTrace?: string): FIO<E, A>;
@@ -510,6 +511,7 @@ export declare function fromExitNow<E, A>(exit: Exit<E, A>, __tsplusTrace?: stri
 export declare function fromMaybe<A>(maybe: Lazy<Maybe<A>>, __tsplusTrace?: string): FIO<Maybe<never>, A>;
 /**
  * @tsplus static fncts.io.IOOps fromMaybeNow
+ * @tsplus getter fncts.Maybe toIO
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function fromMaybeNow<A = never>(maybe: Maybe<A>, __tsplusTrace?: string): IO<unknown, Maybe<never>, A>;
@@ -541,22 +543,22 @@ export declare function fromPromiseHalt<A>(promise: Lazy<Promise<A>>, __tsplusTr
 export declare function get<R, E, A>(ma: IO<R, E, Maybe<A>>, __tsplusTrace?: string): IO<R, Maybe<E>, A>;
 /**
  * Extracts the optional value, or returns the given 'orElse'.
- * @tsplus fluent fncts.io.IO getOrElse
+ * @tsplus pipeable fncts.io.IO getOrElse
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function getOrElse_<R, E, A, B>(ma: IO<R, E, Maybe<A>>, orElse: Lazy<B>, __tsplusTrace?: string): IO<R, E, A | B>;
+export declare function getOrElse<B>(orElse: Lazy<B>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, import("@fncts/base/data/Maybe.js").Maybe<A>>) => IO<R, E, B | A>;
 /**
  * Extracts the optional value, or executes the effect 'orElse'.
- * @tsplus fluent fncts.io.IO getOrElseIO
+ * @tsplus pipeable fncts.io.IO getOrElseIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+export declare function getOrElseIO<R1, E1, B>(orElse: Lazy<IO<R1, E1, B>>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, import("@fncts/base/data/Maybe.js").Maybe<A>>) => IO<R1 | R, E1 | E, B | A>;
 /**
  * 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>;
+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
@@ -580,15 +582,15 @@ export declare function halt(e: Lazy<unknown>, __tsplusTrace?: string): UIO<neve
  */
 export declare function haltNow(e: unknown, __tsplusTrace?: string): UIO<never>;
 /**
- * @tsplus fluent fncts.io.IO ifIO
+ * @tsplus pipeable fncts.io.IO ifIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function ifIO_<R, E, R1, E1, B, R2, E2, C>(self: IO<R, E, boolean>, onFalse: Lazy<IO<R1, E1, B>>, onTrue: Lazy<IO<R2, E2, C>>, __tsplusTrace?: string): IO<R | R1 | R2, E | E1 | E2, B | C>;
+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<R1 | R2 | R, E1 | E2 | E, B | C>;
 /**
  * @tsplus static fncts.io.IOOps if
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function if_<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>;
+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"
@@ -621,7 +623,7 @@ export declare function isSuccess<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: stri
  * @tsplus static fncts.io.IOOps iterate
  * @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>;
+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
@@ -651,7 +653,7 @@ export declare function log(message: Lazy<string>, __tsplusTrace?: string): UIO<
  * @tsplus static fncts.io.IOOps loop
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function loop_<A, R, E, B>(initial: A, cont: (a: A) => boolean, inc: (b: A) => A, body: (b: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, Conc<B>>;
+export declare function loop<A, R, E, B>(initial: A, cont: (a: A) => boolean, inc: (b: A) => A, body: (b: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, Conc<B>>;
 /**
  * Loops with the specified effectual function purely for its effects. The
  * moral equivalent of:
@@ -667,67 +669,67 @@ export declare function loop_<A, R, E, B>(initial: A, cont: (a: A) => boolean, i
  * @tsplus static fncts.io.IOOps loopUnit
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function loopUnit_<A, R, E>(initial: A, cont: (a: A) => boolean, inc: (a: A) => A, body: (a: A) => IO<R, E, any>, __tsplusTrace?: string): IO<R, E, void>;
+export declare function loopUnit<A, R, E>(initial: A, cont: (a: A) => boolean, inc: (a: A) => A, body: (a: A) => IO<R, E, any>, __tsplusTrace?: string): IO<R, E, void>;
 /**
  * Returns an `IO` whose success is mapped by the specified function `f`.
- * @tsplus fluent fncts.io.IO map
+ * @tsplus pipeable fncts.io.IO map
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function map_<R, E, A, B>(fa: IO<R, E, A>, f: (a: A) => B, __tsplusTrace?: string): IO<R, E, B>;
+export declare function map<A, B>(f: (a: A) => B, __tsplusTrace?: string): <R, E>(fa: IO<R, E, A>) => IO<R, E, B>;
 /**
  * Map covariantly over the first argument.
  *
  * Returns an IO with its error channel mapped using the specified
  * 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
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function mapError_<R, E, A, E1>(fea: IO<R, E, A>, f: (e: E) => E1, __tsplusTrace?: string): IO<R, E1, A>;
+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 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>;
 /**
  * Returns an IO with its full cause of failure mapped using
  * 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
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function mapErrorCause_<R, E, A, E1>(ma: IO<R, E, A>, f: (cause: Cause<E>) => Cause<E1>, __tsplusTrace?: string): IO<R, E1, A>;
+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>;
 /**
  * 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
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function matchCause_<R, E, A, A1, A2>(self: IO<R, E, A>, onFailure: (cause: Cause<E>) => A1, onSuccess: (a: A) => A2, __tsplusTrace?: string): IO<R, never, A1 | A2>;
+export declare function matchCause<E, A, A1, A2>(onFailure: (cause: Cause<E>) => A1, onSuccess: (a: A) => A2, __tsplusTrace?: string): <R>(self: IO<R, E, A>) => IO<R, never, A1 | A2>;
 /**
  * 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
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function matchCauseIO_<R, E, A, R1, E1, A1, R2, E2, A2>(self: IO<R, E, A>, 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>;
+export declare 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): <R>(self: IO<R, E, A>) => IO<R1 | R2 | R, E1 | E2, A1 | A2>;
 /**
- * @tsplus fluent fncts.io.IO matchIO
+ * @tsplus pipeable fncts.io.IO matchIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function matchIO_<R, R1, R2, E, E1, E2, A, A1, A2>(self: IO<R, E, A>, onFailure: (e: E) => IO<R1, E1, A1>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): IO<R | R1 | R2, E1 | E2, A1 | A2>;
+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<R1 | R2 | R, 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 fluent fncts.io.IO match
+ * @tsplus pipeable fncts.io.IO match
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+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 fluent fncts.io.IO matchTraceIO
+ * @tsplus pipeable fncts.io.IO matchTraceIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function matchTraceIO_<R, E, A, R1, E1, A1, R2, E2, A2>(ma: IO<R, E, A>, 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>;
+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<R1 | R2 | R, E1 | E2, A1 | A2>;
 /**
  * @tsplus getter fncts.io.IO maybe
  * @tsplus location "@fncts/io/IO/api"
@@ -743,7 +745,7 @@ export declare function merge<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string):
  * @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>(fas: Iterable<IO<R, E, A>>, b: B, f: (b: B, a: A) => B, __tsplusTrace?: string): IO<R, E, B>;
 /**
  * Returns a `IO` that will never produce anything. The moral equivalent of
  * `while(true) {}`, only without the wasted CPU cycles.
@@ -762,35 +764,36 @@ export declare function optional<R, E, A>(ma: IO<R, Maybe<E>, A>, __tsplusTrace?
  * effect and the `Boolean` value returned by the specified effect. This
  * 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 ||
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function or_<R, E, R1, E1>(ma: IO<R, E, boolean>, mb: IO<R1, E1, boolean>, __tsplusTrace?: string): IO<R | R1, E | E1, boolean>;
+export declare function or<R1, E1>(mb: IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, boolean>) => IO<R1 | R, E1 | E, boolean>;
 /**
- * @tsplus fluent fncts.io.IO orElse
+ * @tsplus pipeable fncts.io.IO orElse
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+export declare function orElse<R1, E1, A1>(that: Lazy<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R1 | R, E1, A1 | A>;
 /**
- * @tsplus fluent fncts.io.IO orElseEither
+ * @tsplus pipeable fncts.io.IO orElseEither
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>>;
+export declare function orElseEither<R1, E1, A1>(that: Lazy<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E1, import("@fncts/base/data/Either.js").Either<A, A1>>;
 /**
- * @tsplus fluent fncts.io.IO orElseFail
+ * @tsplus pipeable fncts.io.IO orElseFail
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orElseFail_<R, E, A, E1>(ma: IO<R, E, A>, e: Lazy<E1>, __tsplusTrace?: string): IO<R, E1, A>;
+export declare function orElseFail<E1>(e: Lazy<E1>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, E1, A>;
 /**
- * @tsplus fluent fncts.io.IO orElseMaybe
+ * @tsplus pipeable fncts.io.IO orElseMaybe
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+export declare function orElseMaybe<R1, E1, A1>(that: Lazy<IO<R1, Maybe<E1>, A1>>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, import("@fncts/base/data/Maybe.js").Maybe<E>, A>) => IO<R1 | R, import("@fncts/base/data/Maybe.js").Maybe<E1 | E>, A1 | A>;
 /**
- * @tsplus fluent fncts.io.IO orElseSucceed
+ * @tsplus pipeable fncts.io.IO orElseSucceed
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orElseSucceed_<R, E, A, A1>(ma: IO<R, E, A>, a: Lazy<A1>, __tsplusTrace?: string): IO<R, E, A | A1>;
+export declare function orElseSucceed<A1>(a: Lazy<A1>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, E, A1 | A>;
 /**
  * @tsplus getter fncts.io.IO orHalt
  * @tsplus location "@fncts/io/IO/api"
@@ -802,91 +805,91 @@ export declare function orHalt<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string)
  */
 export declare function orHaltKeep<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, A>;
 /**
- * @tsplus fluent fncts.io.IO orHaltWith
+ * @tsplus pipeable fncts.io.IO orHaltWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orHaltWith_<R, E, A>(ma: IO<R, E, A>, f: (e: E) => unknown, __tsplusTrace?: string): IO<R, never, A>;
+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 fluent fncts.io.IO parallelErrors
+ * @tsplus pipeable fncts.io.IO concurrentErrors
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function parallelErrors<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, List<E>, A>;
+export declare function concurrentErrors(__tsplusTrace?: string): <R, E, A>(io: IO<R, E, A>) => IO<R, import("@fncts/base/collection/immutable/List.js").List<E>, A>;
 /**
  * Feeds elements of type `A` to a function `f` that returns an IO.
  * Collects all successes and failures in a separated fashion.
  * @tsplus static fncts.io.IOOps partition
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function partition_<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, never, readonly [Conc<E>, Conc<B>]>;
+export declare function partition<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, never, readonly [Conc<E>, Conc<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
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function refineOrHalt_<R, E, A, E1>(fa: IO<R, E, A>, pf: (e: E) => Maybe<E1>, __tsplusTrace?: string): IO<R, E1, A>;
+export declare function refineOrHalt<E, E1>(pf: (e: E) => Maybe<E1>, __tsplusTrace?: string): <R, A>(fa: 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 fluent fncts.io.IO refineOrHaltWith
+ * @tsplus pipeable fncts.io.IO refineOrHaltWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+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>;
 /**
  * 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
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function reject_<R, E, A, E1>(fa: IO<R, E, A>, pf: (a: A) => Maybe<E1>, __tsplusTrace?: string): IO<R, E | E1, A>;
+export declare function reject<A, E1>(pf: (a: A) => Maybe<E1>, __tsplusTrace?: string): <R, E>(fa: IO<R, E, A>) => IO<R, E1 | E, A>;
 /**
  * Continue with the returned computation if the partial function `pf` matches,
  * 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
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+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<R1 | R, E1 | E, A>;
 /**
  * Repeats this effect the specified number of times.
- * @tsplus fluent fncts.io.IO repeatN
+ * @tsplus pipeable fncts.io.IO repeatN
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function repeatN_<R, E, A>(ma: IO<R, E, A>, n: number, __tsplusTrace?: string): IO<R, E, A>;
+export declare function repeatN_(n: number, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, E, A>;
 /**
  * Repeats this effect until its result satisfies the specified predicate.
- * @tsplus fluent fncts.io.IO repeatUntil
+ * @tsplus pipeable fncts.io.IO repeatUntil
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function repeatUntil_<R, E, A>(ma: IO<R, E, A>, f: (a: A) => boolean, __tsplusTrace?: string): IO<R, E, A>;
+export declare function repeatUntil<A>(f: (a: A) => boolean, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R, E, A>;
 /**
  * Repeats this effect until its error satisfies the specified effectful predicate.
- * @tsplus fluent fncts.io.IO repeatUntilIO
+ * @tsplus pipeable fncts.io.IO repeatUntilIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+export declare function repeatUntilIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R1 | R, E1 | E, A>;
 /**
  * Repeats this effect while its error satisfies the specified predicate.
- * @tsplus fluent fncts.io.IO repeatWhile
+ * @tsplus pipeable fncts.io.IO repeatWhile
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function repeatWhile_<R, E, A>(ma: IO<R, E, A>, f: (a: A) => boolean, __tsplusTrace?: string): IO<R, E, A>;
+export declare function repeatWhile<A>(f: (a: A) => boolean, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R, E, A>;
 /**
  * Repeats this effect while its error satisfies the specified effectful predicate.
- * @tsplus fluent fncts.io.IO repeatWhileIO
+ * @tsplus pipeable fncts.io.IO repeatWhileIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+export declare function repeatWhileIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R1 | R, E1 | E, A>;
 /**
- * @tsplus fluent fncts.io.IO replicate
+ * @tsplus pipeable fncts.io.IO replicate
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function replicate_<R, E, A>(self: IO<R, E, A>, n: number, __tsplusTrace?: string): ImmutableArray<IO<R, E, A>>;
+export declare function replicate(n: number, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => import("@fncts/base/collection/immutable/ImmutableArray.js").ImmutableArray<IO<R, E, A>>;
 /**
- * @tsplus fluent fncts.io.IO require
+ * @tsplus pipeable fncts.io.IO require
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function require_<R, E, A>(ma: IO<R, E, Maybe<A>>, error: Lazy<E>, __tsplusTrace?: string): IO<R, E, A>;
+export declare function require<E>(error: Lazy<E>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, import("@fncts/base/data/Maybe.js").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.
@@ -902,28 +905,28 @@ export declare function result<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string)
 export declare function resurrect<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, unknown, A>;
 /**
  * Retries this effect until its error satisfies the specified predicate.
- * @tsplus fluent fncts.io.IO retryUntil
+ * @tsplus pipeable fncts.io.IO retryUntil
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function retryUntil_<R, E, A>(fa: IO<R, E, A>, f: (e: E) => boolean, __tsplusTrace?: string): IO<R, E, A>;
+export declare function retryUntil<E>(f: (e: E) => boolean, __tsplusTrace?: string): <R, A>(fa: IO<R, E, A>) => IO<R, E, A>;
 /**
  * Retries this effect until its error satisfies the specified effectful predicate.
- * @tsplus fluent fncts.io.IO retryUntilIO
+ * @tsplus pipeable fncts.io.IO retryUntilIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+export declare function retryUntilIO<E, R1, E1>(f: (e: E) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, A>(fa: IO<R, E, A>) => IO<R1 | R, E | E1, A>;
 /**
  * Retries this effect while its error satisfies the specified predicate.
- * @tsplus fluent fncts.io.IO retryWhile
+ * @tsplus pipeable fncts.io.IO retryWhile
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function retryWhile_<R, E, A>(fa: IO<R, E, A>, f: (e: E) => boolean, __tsplusTrace?: string): IO<R, E, A>;
+export declare function retryWhile<E>(f: (e: E) => boolean, __tsplusTrace?: string): <R, A>(fa: IO<R, E, A>) => IO<R, E, A>;
 /**
  * Retries this effect while its error satisfies the specified effectful predicate.
- * @tsplus fluent fncts.io.IO retryWhileIO
+ * @tsplus pipeable fncts.io.IO retryWhileIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+export declare function retryWhileIO<E, R1, E1>(f: (e: E) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, A>(fa: IO<R, E, A>) => IO<R1 | R, E | E1, A>;
 /**
  * Retrieves the runtimeConfig that this effect is running on.
  * @tsplus static fncts.io.IOOps runtimeConfig
@@ -937,10 +940,10 @@ export declare const runtimeConfig: UIO<RuntimeConfig>;
  */
 export declare function sandbox<R, E, A>(fa: IO<R, E, A>, __tsplusTrace?: string): IO<R, Cause<E>, A>;
 /**
- * @tsplus fluent fncts.io.IO sandboxWith
+ * @tsplus pipeable fncts.io.IO sandboxWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+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>;
 /**
  * Sets the runtime configuration to the specified value.
  * @tsplus static fncts.io.IOOps setRuntimeConfig
@@ -973,10 +976,10 @@ export declare function succeedNow<A>(value: A, __tsplusTrace?: string): IO<neve
  */
 export declare function succeed<A>(effect: Lazy<A>, __tsplusTrace?: string): UIO<A>;
 /**
- * @tsplus fluent fncts.io.IO summarized
+ * @tsplus pipeable fncts.io.IO summarized
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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]>;
+export declare function summarized<R1, E1, B, C>(summary: IO<R1, E1, B>, f: (start: B, end: B) => C, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R1 | R, E1 | E, readonly [C, A]>;
 /**
  * Swaps the positions of a Bifunctor's arguments
  * @tsplus getter fncts.io.IO swap
@@ -985,16 +988,16 @@ export declare function summarized_<R, E, A, R1, E1, B, C>(ma: IO<R, E, A>, summ
 export declare function swap<R, E, A>(pab: 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 fluent fncts.io.IO swapWith
+ * @tsplus pipeable fncts.io.IO swapWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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): IO<R1, E1, A1>;
+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 fluent fncts.io.IO timedWith
+ * @tsplus pipeable fncts.io.IO timedWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function timedWith_<R, E, A, R1, E1>(ma: IO<R, E, A>, msTime: IO<R1, E1, number>, __tsplusTrace?: string): IO<R | R1, E | E1, readonly [number, A]>;
+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]>;
 /**
  * Creates a `IO` that has succeeded with a pure value
  * @tsplus static fncts.io.IOOps tryCatch
@@ -1012,35 +1015,35 @@ export declare function absolve<R, E, E1, A>(ma: IO<R, E, Either<E1, A>>, __tspl
  * and keeping only the result of the first
  *
  * Returns an IO that effectfully "peeks" at the success of this effect.
- * @tsplus fluent fncts.io.IO tap
+ * @tsplus pipeable fncts.io.IO tap
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+export declare function tap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R1 | R, E1 | E, 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
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+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<R | R2, E | E2, A2>;
 /**
  * Returns an IO that effectfully "peeks" at the failure of this effect.
- * @tsplus fluent fncts.io.IO tapError
+ * @tsplus pipeable fncts.io.IO tapError
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function tapError_<R, E, A, R1, E1>(self: IO<R, E, A>, f: (e: E) => IO<R1, E1, any>, __tsplusTrace?: string): IO<R | R1, E | E1, A>;
+export declare function tapError<E, R1, E1>(f: (e: E) => IO<R1, E1, any>, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R1 | R, E | E1, A>;
 /**
  * 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
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+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<R1 | R, E | E1, A>;
 /**
- * @tsplus fluent fncts.io.IO tryOrElse
+ * @tsplus pipeable fncts.io.IO tryOrElse
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function tryOrElse_<R, E, A, R1, E1, A1, R2, E2, A2>(ma: IO<R, E, A>, that: Lazy<IO<R1, E1, A1>>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): 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>(ma: IO<R, E, A>) => IO<R1 | R2 | R, E1 | E2, A1 | A2>;
 /**
  * @tsplus static fncts.io.IOOps unit
  * @tsplus location "@fncts/io/IO/api"
@@ -1055,10 +1058,10 @@ export declare function unjust<R, E, A>(self: IO<R, Maybe<E>, A>, __tsplusTrace?
 /**
  * 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
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+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>;
 /**
  * The inverse operation `sandbox`
  * @tsplus getter fncts.io.IO unsandbox
@@ -1083,16 +1086,16 @@ export declare function withFiberContext<R, E, A>(onState: (fiber: FiberContext<
  */
 export declare const via: typeof pipe;
 /**
- * @tsplus fluent fncts.io.IO when
+ * @tsplus pipeable fncts.io.IO when
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function when_<R, E, A>(ma: IO<R, E, A>, b: Lazy<boolean>, __tsplusTrace?: string): IO<R, E, void>;
+export declare function when(b: Lazy<boolean>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, E, void>;
 /**
  * The moral equivalent of `if (p) exp` when `p` has side-effects
- * @tsplus fluent fncts.io.IO whenIO
+ * @tsplus pipeable fncts.io.IO whenIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function whenIO_<R, E, A, R1, E1>(ma: IO<R, E, A>, mb: IO<R1, E1, boolean>, __tsplusTrace?: string): IO<R1 | R, E | E1, void>;
+export declare function whenIO<R1, E1>(mb: IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R1 | R, E1 | E, void>;
 /**
  * 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
@@ -1102,15 +1105,15 @@ export declare function whenIO_<R, E, A, R1, E1>(ma: IO<R, E, A>, mb: IO<R1, E1,
  */
 export declare const yieldNow: UIO<void>;
 /**
- * @tsplus fluent fncts.io.IO zip
+ * @tsplus pipeable fncts.io.IO zip
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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]>;
+export declare function zip<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E1 | E, readonly [A, B]>;
 /**
- * @tsplus fluent fncts.io.IO zipWith
+ * @tsplus pipeable fncts.io.IO zipWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare 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>;
+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<R1 | R, E1 | E, C>;
 export declare class GenIO<R, E, A> {
     readonly effect: IO<R, E, A>;
     readonly _trace?: string | undefined;