@fncts/io 0.0.19 → 0.0.21

package/Hub/definition.d.ts

@@ -1,88 +1,44 @@
-import { PQueue } from "@fncts/io/Queue/definition";
-import { UIO, IO } from "@fncts/io/IO/definition";
+import { Future } from "@fncts/io/Future";
 import { Scope } from "@fncts/io/Scope/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Exit } from "@fncts/base/data/Exit/definition";
+import type { HashedPair } from "../internal/HashedPair.js";
+import type { MutableQueue } from "../internal/MutableQueue.js";
+import type { UIO } from "../IO.js";
+import type { Dequeue, Enqueue } from "../Queue/definition.js";
+import type { Strategy } from "./internal.js";
+import type { HashSet } from "@fncts/base/collection/mutable/HashSet";
+import type { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
+import type { Hub as HubInternal } from "@fncts/io/internal/Hub";
+import { QueueTypeId } from "../Queue/definition.js";
 export declare const HubTypeId: unique symbol;
 export type HubTypeId = typeof HubTypeId;
 /**
- * A `Hub<RA, RB, EA, EB, A, B>` is an asynchronous message hub. Publishers
- * can publish messages of type `A` to the hub and subscribers can subscribe to
- * take messages of type `B` from the hub. Publishing messages can require an
- * environment of type `RA` and fail with an error of type `EA`. Taking
- * messages can require an environment of type `RB` and fail with an error of
- * type `EB`.
- *
  * @tsplus type fncts.io.Hub
+ * @tsplus companion fncts.io.HubOps
  */
-export interface PHub<RA, RB, EA, EB, A, B> {
-    readonly _typeId: HubTypeId;
-    readonly _RA: () => RA;
-    readonly _RB: () => RB;
-    readonly _EA: () => EA;
-    readonly _EB: () => EB;
-    readonly _A: (_: A) => void;
-    readonly _B: () => B;
+export declare class Hub<A> implements Enqueue<A> {
+    readonly hub: HubInternal<A>;
+    readonly subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>;
+    readonly scope: Scope.Closeable;
+    readonly shutdownHook: Future<never, void>;
+    readonly shutdownFlag: AtomicBoolean;
+    readonly strategy: Strategy<A>;
+    readonly [QueueTypeId]: QueueTypeId;
+    readonly [HubTypeId]: HubTypeId;
+    _In: (_: A) => void;
+    constructor(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>, scope: Scope.Closeable, shutdownHook: Future<never, void>, shutdownFlag: AtomicBoolean, strategy: Strategy<A>);
+    awaitShutdown: UIO<void>;
+    get capacity(): number;
+    isShutdown: UIO<boolean>;
+    publish(this: this, a: A, __tsplusTrace?: string): UIO<boolean>;
+    publishAll(this: this, as: Iterable<A>, __tsplusTrace?: string): UIO<boolean>;
+    shutdown: UIO<void>;
+    size: UIO<number>;
+    subscribe: IO<Scope, never, Dequeue<A>>;
+    isEmpty: UIO<boolean>;
+    isFull: UIO<boolean>;
+    offer(this: this, a: A, __tsplusTrace?: string | undefined): UIO<boolean>;
+    offerAll(this: this, as: Iterable<A>, __tsplusTrace?: string | undefined): UIO<boolean>;
 }
-/**
- * @tsplus type fncts.io.Hub
- */
-export interface Hub<A> extends PHub<never, never, never, never, A, A> {
-}
-/**
- * @tsplus type fncts.io.HubOps
- */
-export interface HubOps {
-}
-export declare const Hub: HubOps;
-export declare namespace Hub {
-    type Dequeue<R, E, A> = PQueue<never, R, unknown, E, never, A>;
-    type Enqueue<R, E, A> = PQueue<R, never, E, unknown, A, never>;
-}
-export declare abstract class PHubInternal<RA, RB, EA, EB, A, B> implements PHub<RA, RB, EA, EB, A, B> {
-    _typeId: HubTypeId;
-    readonly _RA: () => RA;
-    readonly _RB: () => RB;
-    readonly _EA: () => EA;
-    readonly _EB: () => EB;
-    readonly _A: (_: A) => void;
-    readonly _B: () => B;
-    /**
-     * Waits for the hub to be shut down.
-     */
-    abstract awaitShutdown: UIO<void>;
-    /**
-     * The maximum capacity of the hub.
-     */
-    abstract capacity: number;
-    /**
-     * Checks whether the hub is shut down.
-     */
-    abstract isShutdown: UIO<boolean>;
-    /**
-     * Publishes a message to the hub, returning whether the message was
-     * published to the hub.
-     */
-    abstract publish(a: A): IO<RA, EA, boolean>;
-    /**
-     * Publishes all of the specified messages to the hub, returning whether
-     * they were published to the hub.
-     */
-    abstract publishAll(as: Iterable<A>): IO<RA, EA, boolean>;
-    /**
-     * Shuts down the hub.
-     */
-    abstract shutdown: UIO<void>;
-    /**
-     * The current number of messages in the hub.
-     */
-    abstract size: UIO<number>;
-    /**
-     * Subscribes to receive messages from the hub. The resulting subscription
-     * can be evaluated multiple times within the scope of the managed to take a
-     * message from the hub each time.
-     */
-    abstract subscribe: IO<Scope, never, Hub.Dequeue<RB, EB, B>>;
-}
-/**
- * @tsplus macro remove
- */
-export declare function concrete<RA, RB, EA, EB, A, B>(_: PHub<RA, RB, EA, EB, A, B>): asserts _ is PHubInternal<RA, RB, EA, EB, A, B>;

package/Hub/internal.d.ts

@@ -1,11 +1,9 @@
 import { Future } from "@fncts/io/Future";
 import { UIO, IO } from "@fncts/io/IO/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { Queue } from "@fncts/io/Queue/definition";
-import { Scope } from "@fncts/io/Scope/definition";
-import { Exit } from "@fncts/base/data/Exit/definition";
-import { Hub } from "@fncts/io/Hub/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 import type { Hub as HubInternal } from "@fncts/io/internal/Hub";
+import type { Dequeue } from "@fncts/io/Queue";
 import { HashSet } from "@fncts/base/collection/mutable/HashSet";
 import { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
 import { HashedPair } from "@fncts/io/internal/HashedPair";
@@ -85,14 +83,9 @@ export declare class Sliding<A> extends Strategy<A> {
 /**
  * Creates a subscription with the specified strategy.
  */
-export declare function makeSubscription<A>(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>, strategy: Strategy<A>): UIO<Queue.Dequeue<A>>;
+export declare function makeSubscription<A>(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>, strategy: Strategy<A>): UIO<Dequeue<A>>;
 /**
  * Unsafely creates a subscription with the specified strategy.
  */
-export declare function unsafeMakeSubscription<A>(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>, subscription: HubInternal.Subscription<A>, pollers: MutableQueue<Future<never, A>>, shutdownHook: Future<never, void>, shutdownFlag: AtomicBoolean, strategy: Strategy<A>): Queue.Dequeue<A>;
+export declare function unsafeMakeSubscription<A>(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>, subscription: HubInternal.Subscription<A>, pollers: MutableQueue<Future<never, A>>, shutdownHook: Future<never, void>, shutdownFlag: AtomicBoolean, strategy: Strategy<A>): Dequeue<A>;
 export declare function subscribersHashSet<A>(): HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>;
-/**
- * Unsafely creates a hub with the specified strategy.
- */
-export declare function unsafeMakeHub<A>(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>, scope: Scope.Closeable, shutdownHook: Future<never, void>, shutdownFlag: AtomicBoolean, strategy: Strategy<A>): Hub<A>;
-export declare function makeHubInternal<A>(hub: HubInternal<A>, strategy: Strategy<A>): UIO<Hub<A>>;

package/Hub.d.ts

@@ -1,2 +1,2 @@
-export * from "./Hub/api.js";
+export * from "./Hub/constructors.js";
 export * from "./Hub/definition.js";

package/IO/api/acquireRelease.d.ts

@@ -6,4 +6,4 @@ import { Scope } from "@fncts/io/Scope/definition";
  * @tsplus fluent fncts.io.IO acquireRelease
  * @tsplus location "@fncts/io/IO/api/acquireRelease"
  */
-export declare function acquireRelease<R, E, A, R1>(acquire: Lazy<IO<R, E, A>>, release: (a: A) => IO<R1, never, any>, __tsplusTrace?: string): IO<R | R1 | Scope, E, A>;
+export declare function acquireRelease<R, E, A, R1>(acquire: Lazy<IO<R, E, A>>, release: (a: A) => IO<R1, never, any>, __tsplusTrace?: string): IO<Scope | R | R1, E, A>;

package/IO/api/acquireReleaseExit.d.ts

@@ -7,4 +7,4 @@ import { Scope } from "@fncts/io/Scope/definition";
  * @tsplus fluent fncts.io.IO acquireReleaseExit
  * @tsplus location "@fncts/io/IO/api/acquireReleaseExit"
  */
-export declare function acquireReleaseExit<R, E, A, R1>(acquire: Lazy<IO<R, E, A>>, release: (a: A, exit: Exit<any, any>) => IO<R1, never, any>, __tsplusTrace?: string): IO<R | R1 | Scope, E, A>;
+export declare function acquireReleaseExit<R, E, A, R1>(acquire: Lazy<IO<R, E, A>>, release: (a: A, exit: Exit<any, any>) => IO<R1, never, any>, __tsplusTrace?: string): IO<Scope | R | R1, E, A>;

package/IO/api/bracket.d.ts

@@ -23,4 +23,4 @@ import { IO } from "@fncts/io/IO/definition";
  * @tsplus static fncts.io.IOOps bracket
  * @tsplus location "@fncts/io/IO/api/bracket"
  */
-export declare function bracket_<R, E, A, R1, E1, A1, R2, E2, A2>(acquire: Lazy<IO<R, E, A>>, use: (a: A) => IO<R1, E1, A1>, release: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): IO<R | R1 | R2, E | E1 | E2, A1>;
+export declare function bracket<R, E, A, R1, E1, A1, R2, E2, A2>(acquire: Lazy<IO<R, E, A>>, use: (a: A) => IO<R1, E1, A1>, release: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): IO<R | R1 | R2, E | E1 | E2, A1>;

package/IO/api/bracketExit.d.ts

@@ -11,4 +11,4 @@ import { Exit } from "@fncts/base/data/Exit/definition";
  * @tsplus static fncts.io.IOOps bracketExit
  * @tsplus location "@fncts/io/IO/api/bracketExit"
  */
-export declare function bracketExit_<R, E, A, E1, R1, A1, R2, E2>(acquire: Lazy<IO<R, E, A>>, use: (a: A) => IO<R1, E1, A1>, release: (a: A, e: Exit<E1, A1>) => IO<R2, E2, any>, __tsplusTrace?: string): IO<R | R1 | R2, E | E1 | E2, A1>;
+export declare function bracketExit<R, E, A, E1, R1, A1, R2, E2>(acquire: Lazy<IO<R, E, A>>, use: (a: A) => IO<R1, E1, A1>, release: (a: A, e: Exit<E1, A1>) => IO<R2, E2, any>, __tsplusTrace?: string): IO<R | R1 | R2, E | E1 | E2, A1>;

package/IO/api/concurrency.d.ts

@@ -22,10 +22,10 @@ export declare function concurrencyWith<R, E, A>(f: (concurrency: Maybe<number>)
 /**
  * Runs the specified effect with the specified maximum number of fibers for
  * concurrent operators.
- * @tsplus fluent fncts.io.IO withConcurrency
+ * @tsplus pipeable fncts.io.IO withConcurrency
  * @tsplus location "@fncts/io/IO/api/concurrency"
  */
-export declare function withConcurrency_<R, E, A>(ma: IO<R, E, A>, n: number, __tsplusTrace?: string): IO<R, E, A>;
+export declare function withConcurrency(n: number, __tsplusTrace?: string): <R, E, A>(ma: import("../definition").IO<R, E, A>) => import("../definition").IO<R, E, A>;
 /**
  * Runs the specified effect with an unbounded maximum number of fibers for
  * concurrent operators.

package/IO/api/core-scope.d.ts

@@ -35,14 +35,14 @@ export declare class ForkScopeRestore {
  * @tsplus static fncts.io.IOOps forkScopeMask
  * @tsplus location "@fncts/io/IO/api/core-scope"
  */
-export declare function forkScopeMask_<R, E, A>(newScope: FiberScope, f: (restore: ForkScopeRestore) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+export declare function forkScopeMask<R, E, A>(newScope: FiberScope, f: (restore: ForkScopeRestore) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Returns an effect that races this effect with the specified effect, calling
  * the specified finisher as soon as one result or the other has been computed.
- * @tsplus fluent fncts.io.IO raceWith
+ * @tsplus pipeable fncts.io.IO raceWith
  * @tsplus location "@fncts/io/IO/api/core-scope"
  */
-export declare function raceWith_<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(left: IO<R, E, A>, right: Lazy<IO<R1, E1, A1>>, leftWins: (exit: Exit<E, A>, fiber: Fiber<E1, A1>) => IO<R2, E2, A2>, rightWins: (exit: Exit<E1, A1>, fiber: Fiber<E, A>) => IO<R3, E3, A3>, __tsplusTrace?: string): IO<R | R1 | R2 | R3, E2 | E3, A2 | A3>;
+export declare function raceWith<E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(right: Lazy<IO<R1, E1, A1>>, leftWins: (exit: Exit<E, A>, fiber: Fiber<E1, A1>) => IO<R2, E2, A2>, rightWins: (exit: Exit<E1, A1>, fiber: Fiber<E, A>) => IO<R3, E3, A3>, __tsplusTrace?: string): <R>(left: IO<R, E, A>) => IO<R1 | R2 | R3 | R, E2 | E3, A2 | A3>;
 export type Grafter = <R, E, A>(effect: IO<R, E, A>) => IO<R, E, A>;
 /**
  * Transplants specified effects so that when those effects fork other
@@ -66,10 +66,10 @@ export declare function forkDaemon<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: str
 /**
  * Returns a new effect that will utilize the specified scope to supervise
  * any fibers forked within the original effect.
- * @tsplus fluent fncts.io.IO overrideForkScope
+ * @tsplus pipeable fncts.io.IO overrideForkScope
  * @tsplus location "@fncts/io/IO/api/core-scope"
  */
-export declare function overrideForkScope_<R, E, A>(ma: IO<R, E, A>, scope: FiberScope, __tsplusTrace?: string): IO<R, E, A>;
+export declare function overrideForkScope(scope: FiberScope, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, E, A>;
 /**
  * Returns a new effect that will utilize the default scope (fiber scope) to
  * supervise any fibers forked within the original effect.

package/IO/api/ensuringChildren.d.ts

@@ -1,8 +1,8 @@
-import { IO } from "@fncts/io/IO/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { Fiber } from "@fncts/io/Fiber/definition";
+import { IO } from "@fncts/io/IO/definition";
 /**
- * @tsplus fluent fncts.io.IO ensuringChildren
+ * @tsplus pipeable fncts.io.IO ensuringChildren
  * @tsplus location "@fncts/io/IO/api/ensuringChildren"
  */
-export declare function ensuringChildren<R, E, A, R1>(self: IO<R, E, A>, children: (_: Conc<Fiber.Runtime<any, any>>) => IO<R1, never, void>, __tsplusTrace?: string): IO<R | R1, E, A>;
+export declare function ensuringChildren<R1>(children: (_: Conc<Fiber.Runtime<any, any>>) => IO<R1, never, void>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R1 | R, E, A>;

package/IO/api/environment.d.ts

@@ -1,13 +1,13 @@
-import { IO, URIO, FIO } from "@fncts/io/IO/definition";
 import { Environment } from "@fncts/base/data/Environment/definition";
+import { IO, URIO, FIO } from "@fncts/io/IO/definition";
 import { Tag } from "@fncts/base/data/Tag/definition";
 /**
  * Provides some of the environment required to run this `IO`,
  * leaving the remainder `R0`.
- * @tsplus fluent fncts.io.IO contramapEnvironment
+ * @tsplus pipeable fncts.io.IO contramapEnvironment
  * @tsplus location "@fncts/io/IO/api/environment"
  */
-export declare function contramapEnvironment_<R0, R, E, A>(self: IO<R, E, A>, f: (r0: Environment<R0>) => Environment<R>, __tsplusTrace?: string): IO<R0, E, A>;
+export declare function contramapEnvironment<R0, R>(f: (r0: Environment<R0>) => Environment<R>, __tsplusTrace?: string): <E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R0, E, A>;
 /**
  * Accesses the environment provided to an `IO`
  * @tsplus static fncts.io.IOOps environment
@@ -31,30 +31,26 @@ export declare function environmentWithIO<R0, R, E, A>(f: (r: Environment<R0>) =
  *
  * Provides the `IO` with its required environment, which eliminates
  * its dependency on `R`.
- * @tsplus fluent fncts.io.IO provideEnvironment
- * @tsplus location "@fncts/io/IO/api/environment"
- */
-export declare function provideEnvironment_<R, E, A>(self: IO<R, E, A>, r: Environment<R>, __tsplusTrace?: string): FIO<E, A>;
-/**
- * @tsplus fluent fncts.io.IO provideSomeEnvironment
+ * @tsplus pipeable fncts.io.IO provideEnvironment
  * @tsplus location "@fncts/io/IO/api/environment"
  */
-export declare function provideSomeEnvironment_<R, E, A, R0>(self: IO<R, E, A>, environment: Environment<R0>, __tsplusTrace?: string): IO<Exclude<R, R0>, E, A>;
+export declare function provideEnvironment<R>(r: Environment<R>, __tsplusTrace?: string): <E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").FIO<E, A>;
 /**
- * @tsplus fluent fncts.io.IO provideService
+ * @tsplus pipeable fncts.io.IO provideSomeEnvironment
  * @tsplus location "@fncts/io/IO/api/environment"
  */
-export declare function provideService_<E, A, T>(self: IO<T, E, A>, service: T, tag: Tag<T>, __tsplusTrace?: string): FIO<E, A>;
+export declare function provideSomeEnvironment<R0>(environment: Environment<R0>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<Exclude<R, R0>, E, A>;
 /**
- * @tsplus fluent fncts.io.IO provideSomeService
+ * @tsplus pipeable fncts.io.IO provideService
  * @tsplus location "@fncts/io/IO/api/environment"
  */
-export declare function provideSomeService_<R, E, A, T>(self: IO<R, E, A>, service: T, tag: Tag<T>, __tsplusTrace?: string): IO<Exclude<R, T>, E, A>;
+export declare function provideService<T>(service: T, tag: Tag<T>, __tsplusTrace?: string): <E, A>(self: import("../definition").IO<T, E, A>) => import("../definition").FIO<E, A>;
 /**
+ * @tsplus pipeable fncts.io.IO provideSomeService
  * @tsplus static fncts.io.IOAspects provideSomeService
  * @tsplus location "@fncts/io/IO/api/environment"
  */
-export declare function provideSomeService<T>(service: T, tag: Tag<T>, __tsplusTrace?: string): <R, E, A>(io: import("../definition").IO<T | R, E, A>) => import("../definition").IO<R, E, A>;
+export declare function provideSomeService<T>(service: T, tag: Tag<T>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<Exclude<R, T>, E, A>;
 /**
  * @tsplus static fncts.io.IOOps service
  * @tsplus location "@fncts/io/IO/api/environment"

package/IO/api/foreachC.d.ts

@@ -16,7 +16,7 @@ import { Queue } from "@fncts/io/Queue/definition";
  * @tsplus fluent fncts.Iterable traverseIODiscardC
  * @tsplus location "@fncts/io/IO/api/foreachC"
  */
-export declare function foreachDiscardC_<R, E, A>(as: Iterable<A>, f: (a: A) => IO<R, E, any>, __tsplusTrace?: string): IO<R, E, void>;
+export declare function foreachDiscardC<R, E, A>(as: Iterable<A>, f: (a: A) => IO<R, E, any>, __tsplusTrace?: string): IO<R, E, void>;
 /**
  * Applies the function `f` to each element of the `Iterable<A>` in parallel,
  * and returns the results in a `Conc<B>`.
@@ -26,4 +26,4 @@ export declare function foreachDiscardC_<R, E, A>(as: Iterable<A>, f: (a: A) =>
  * @tsplus fluent fncts.Iterable traverseIOC
  * @tsplus location "@fncts/io/IO/api/foreachC"
  */
-export declare function foreachC_<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, Conc<B>>;
+export declare function foreachC<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, Conc<B>>;

package/IO/api/foreachExec.d.ts

@@ -9,4 +9,4 @@ import { Conc } from "@fncts/base/collection/immutable/Conc";
  * @tsplus static fncts.io.IOOps foreachExec
  * @tsplus location "@fncts/io/IO/api/foreachExec"
  */
-export declare function foreachExec_<R, E, A, B>(as: Iterable<A>, es: ExecutionStrategy, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, Conc<B>>;
+export declare function foreachExec<R, E, A, B>(as: Iterable<A>, es: ExecutionStrategy, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, Conc<B>>;

package/IO/api/forkIn.d.ts

@@ -1,10 +1,10 @@
-import { IO, URIO } from "@fncts/io/IO/definition";
 import { Scope } from "@fncts/io/Scope/definition";
+import { IO, URIO } from "@fncts/io/IO/definition";
 import { Fiber } from "@fncts/io/Fiber/definition";
 /**
  * Forks the workflow in the specified scope. The fiber will be interrupted
  * when the scope is closed.
- * @tsplus fluent fncts.io.IO forkIn
+ * @tsplus pipeable fncts.io.IO forkIn
  * @tsplus location "@fncts/io/IO/api/forkIn"
  */
-export declare function forkIn_<R, E, A>(self: IO<R, E, A>, scope: Scope, __tsplusTrace?: string): URIO<R, Fiber.Runtime<E, A>>;
+export declare function forkIn(scope: Scope, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").URIO<R, import("../../Fiber").Fiber.Runtime<E, A>>;

package/IO/api/fulfill.d.ts

@@ -1,10 +1,10 @@
-import { IO } from "@fncts/io/IO/definition";
 import { Future } from "@fncts/io/Future";
+import { IO } from "@fncts/io/IO/definition";
 /**
  * Returns an IO that keeps or breaks a promise based on the result of
  * this effect. Synchronizes interruption, so if this effect is interrupted,
  * the specified promise will be interrupted, too.
- * @tsplus fluent fncts.io.IO fulfill
+ * @tsplus pipeable fncts.io.IO fulfill
  * @tsplus location "@fncts/io/IO/api/fulfill"
  */
-export declare function fulfill_<R, E, A>(effect: IO<R, E, A>, p: Future<E, A>, __tsplusTrace?: string): IO<R, never, boolean>;
+export declare function fulfill<E, A>(p: Future<E, A>, __tsplusTrace?: string): <R>(effect: import("../definition").IO<R, E, A>) => import("../definition").IO<R, never, boolean>;

package/IO/api/interrupt.d.ts

@@ -21,10 +21,10 @@ export declare const interrupt: IO<never, never, never>;
  * effect becomes interruptible (the default), while if `false` is used, then
  * the effect becomes uninterruptible. These changes are compositional, so
  * they only affect regions of the effect.
- * @tsplus fluent fncts.io.IO setInterruptStatus
+ * @tsplus pipeable fncts.io.IO setInterruptStatus
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function setInterruptStatus_<R, E, A>(self: IO<R, E, A>, flag: InterruptStatus, __tsplusTrace?: string): IO<R, E, A>;
+export declare function setInterruptStatus(flag: InterruptStatus, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R, E, A>;
 /**
  * Returns a new effect that performs the same operations as this effect, but
  * interruptibly, even if composed inside of an uninterruptible region.
@@ -71,17 +71,17 @@ export declare function interruptibleMask<R, E, A>(k: (restore: InterruptStatusR
 /**
  * Calls the specified function, and runs the effect it returns, if this
  * effect is interrupted.
- * @tsplus fluent fncts.io.IO onInterrupt
+ * @tsplus pipeable fncts.io.IO onInterrupt
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function onInterrupt_<R, E, A, R1>(ma: IO<R, E, A>, cleanup: (interruptors: HashSet<FiberId>) => IO<R1, never, any>, __tsplusTrace?: string): IO<R | R1, E, A>;
+export declare function onInterrupt_<R1>(cleanup: (interruptors: HashSet<FiberId>) => IO<R1, never, any>, __tsplusTrace?: string): <R, E, A>(ma: import("../definition").IO<R, E, A>) => import("../definition").IO<R1 | R, E, A>;
 /**
  * Calls the specified function, and runs the effect it returns, if this
  * effect is interrupted (allows for expanding error).
- * @tsplus fluent fncts.io.IO onInterruptExtended
+ * @tsplus pipeable fncts.io.IO onInterruptExtended
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function onInterruptExtended_<R, E, A, R2, E2>(self: IO<R, E, A>, cleanup: Lazy<IO<R2, E2, any>>, __tsplusTrace?: string): IO<R | R2, E | E2, A>;
+export declare function onInterruptExtended_<R2, E2>(cleanup: Lazy<IO<R2, E2, any>>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R2 | R, E2 | E, A>;
 /**
  * Returns an IO whose interruption will be disconnected from the
  * fiber's own interruption, being performed in the background without

package/IO/api/onExit.d.ts

@@ -1,7 +1,7 @@
-import { IO } from "@fncts/io/IO/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
+import { IO } from "@fncts/io/IO/definition";
 /**
- * @tsplus fluent fncts.io.IO onExit
+ * @tsplus pipeable fncts.io.IO onExit
  * @tsplus location "@fncts/io/IO/api/onExit"
  */
-export declare function onExit_<R, E, A, R1, E1>(self: IO<R, E, A>, cleanup: (exit: Exit<E, A>) => IO<R1, E1, any>, __tsplusTrace?: string): IO<R | R1, E | E1, A>;
+export declare function onExit<E, A, R1, E1>(cleanup: (exit: Exit<E, A>) => IO<R1, E1, any>, __tsplusTrace?: string): <R>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R1 | R, E | E1, A>;

package/IO/api/onTermination.d.ts

@@ -1,9 +1,9 @@
-import { Lazy } from "@fncts/base/data/function/definition";
-import { IO, URIO } from "@fncts/io/IO/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
+import { URIO, IO } from "@fncts/io/IO/definition";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 /**
- * @tsplus fluent fncts.io.IO onTermination
+ * @tsplus pipeable fncts.io.IO onTermination
  * @tsplus location "@fncts/io/IO/api/onTermination"
  */
-export declare function onTermination<R, E, A, R1>(self: Lazy<IO<R, E, A>>, cleanup: (cause: Cause<never>) => URIO<R1, any>, __tsplusTrace?: string): IO<R | R1, E, A>;
+export declare function onTermination<R1>(cleanup: (cause: Cause<never>) => URIO<R1, any>, __tsplusTrace?: string): <R, E, A>(self: import("@fncts/base/data/function").Lazy<import("../definition").IO<R, E, A>>) => import("../definition").IO<R1 | R, E, A>;

package/IO/api/provideLayer.d.ts

@@ -1,7 +1,7 @@
-import { IO } from "@fncts/io/IO/definition";
 import { Layer } from "@fncts/io/Layer";
+import { IO } from "@fncts/io/IO/definition";
 /**
- * @tsplus fluent fncts.io.IO provideLayer
+ * @tsplus pipeable fncts.io.IO provideLayer
  * @tsplus location "@fncts/io/IO/api/provideLayer"
  */
-export declare function provideLayer_<RIn, E, ROut, E1, A>(self: IO<ROut, E1, A>, layer: Layer<RIn, E, ROut>, __tsplusTrace?: string): IO<RIn, E | E1, A>;
+export declare function provideLayer<RIn, E, ROut>(layer: Layer<RIn, E, ROut>, __tsplusTrace?: string): <E1, A>(self: import("../definition").IO<ROut, E1, A>) => import("../definition").IO<RIn, E | E1, A>;

package/IO/api/provideSomeLayer.d.ts

@@ -1,13 +1,9 @@
-import { IO } from "@fncts/io/IO/definition";
 import { Layer } from "@fncts/io/Layer";
+import { IO } from "@fncts/io/IO/definition";
 import type { Erase } from "@fncts/typelevel/Intersection";
-/**
- * @tsplus fluent fncts.io.IO provideSomeLayer
- * @tsplus location "@fncts/io/IO/api/provideSomeLayer"
- */
-export declare function provideSomeLayer_<R, E, A, RIn, E1, ROut>(self: IO<R, E, A>, layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): IO<RIn & Erase<R, ROut>, E | E1, A>;
 /**
  * @tsplus static fncts.io.IOAspects provideSomeLayer
+ * @tsplus pipeable fncts.io.IO provideSomeLayer
  * @tsplus location "@fncts/io/IO/api/provideSomeLayer"
  */
-export declare function provideSomeLayer<RIn, E1, ROut>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<ROut | R, E, A>) => import("../definition").IO<RIn | R, E1 | E, A>;
+export declare function provideSomeLayer<RIn, E1, ROut>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<RIn & Erase<R, ROut>, E1 | E, A>;

package/IO/api/race.d.ts

@@ -7,7 +7,7 @@ import { IO } from "@fncts/io/IO/definition";
  *
  * WARNING: The raced effect will safely interrupt the "loser", but will not
  * resume until the loser has been cleanly terminated.
- * @tsplus fluent fncts.io.IO race
+ * @tsplus pipeable fncts.io.IO race
  * @tsplus location "@fncts/io/IO/api/race"
  */
-export declare function race_<R, E, A, R1, E1, A1>(io: IO<R, E, A>, that: IO<R1, E1, A1>, __tsplusTrace?: string): IO<R | R1, E | E1, A | A1>;
+export declare function race<R1, E1, A1>(that: IO<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(io: import("../definition").IO<R, E, A>) => import("../definition").IO<R1 | R, E1 | E, A1 | A>;

package/IO/api/raceFirst.d.ts

@@ -10,7 +10,7 @@ import { IO } from "@fncts/io/IO/definition";
  * `l.disconnect raceFirst r.disconnect`, which disconnects left and right
  * interrupt signal, allowing a fast return, with interruption performed
  * in the background.
- * @tsplus fluent fncts.io.IO raceFirst
+ * @tsplus pipeable fncts.io.IO raceFirst
  * @tsplus location "@fncts/io/IO/api/raceFirst"
  */
-export declare function raceFirst_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, that: IO<R1, E1, A1>, __tsplusTrace?: string): IO<R | R1, E | E1, A | A1>;
+export declare function raceFirst<R1, E1, A1>(that: IO<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(ma: import("../definition").IO<R, E, A>) => import("../definition").IO<R1 | R, E1 | E, A1 | A>;

package/IO/api/repeat.d.ts

@@ -7,14 +7,14 @@ import { Either } from "@fncts/base/data/Either/definition";
  * @tsplus getter fncts.io.IO repeat
  * @tsplus location "@fncts/io/IO/api/repeat"
  */
-export declare function repeat_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): <R1, B>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, A, B>>, __tsplusTrace?: string) => import("../definition").IO<R | R1, E, B>;
+export declare function repeat<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): <R1, B>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, A, B>>, __tsplusTrace?: string) => import("../definition").IO<R | R1, E, B>;
 /**
  * @tsplus getter fncts.io.IO repeatOrElse
  * @tsplus location "@fncts/io/IO/api/repeat"
  */
-export declare function repeatOrElse_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): <R1, B, R2, E2>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, A, B>>, orElse: (e: E, out: import("@fncts/base/data/Maybe").Maybe<B>) => import("../definition").IO<R2, E2, B>, __tsplusTrace?: string) => import("../definition").IO<R | R1 | R2, E2, B>;
+export declare function repeatOrElse<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): <R1, B, R2, E2>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, A, B>>, orElse: (e: E, out: import("@fncts/base/data/Maybe").Maybe<B>) => import("../definition").IO<R2, E2, B>, __tsplusTrace?: string) => import("../definition").IO<R | R1 | R2, E2, B>;
 /**
  * @tsplus getter fncts.io.IO repeatOrElseEither
  * @tsplus location "@fncts/io/IO/api/repeat"
  */
-export declare function repeatOrElseEither_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): <R1, B, R2, E2, C>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, A, B>>, orElse: (e: E, out: import("@fncts/base/data/Maybe").Maybe<B>) => import("../definition").IO<R2, E2, C>, __tsplusTrace?: string) => import("../definition").IO<R | R1 | R2, E2, import("@fncts/base/data/Either").Either<C, B>>;
+export declare function repeatOrElseEither<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): <R1, B, R2, E2, C>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, A, B>>, orElse: (e: E, out: import("@fncts/base/data/Maybe").Maybe<B>) => import("../definition").IO<R2, E2, C>, __tsplusTrace?: string) => import("../definition").IO<R | R1 | R2, E2, import("@fncts/base/data/Either").Either<C, B>>;

package/IO/api/retry.d.ts

@@ -1,19 +1,19 @@
-import { IO } from "@fncts/io/IO/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Schedule } from "@fncts/io/Schedule/definition";
+import { IO } from "@fncts/io/IO/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 /**
- * @tsplus getter fncts.io.IO retry
+ * @tsplus pipeable fncts.io.IO retry
  * @tsplus location "@fncts/io/IO/api/retry"
  */
-export declare function retry<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): <R1, O>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, E, O>>, __tsplusTrace?: string) => import("../definition").IO<R | R1, E, A>;
+export declare function retry<R1, E, O>(schedule0: Lazy<Schedule<R1, E, O>>, __tsplusTrace?: string): <R, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R1 | R, E, A>;
 /**
- * @tsplus getter fncts.io.IO retryOrElse
+ * @tsplus pipeable fncts.io.IO retryOrElse
  * @tsplus location "@fncts/io/IO/api/retry"
  */
-export declare function retryOrElse<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): <R1, O, R2, E2>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, E, O>>, orElse: (e: E, out: O) => import("../definition").IO<R2, E2, A>, __tsplusTrace?: string) => import("../definition").IO<R | R1 | R2, E2, A>;
+export declare function retryOrElse<E, A, R1, O, R2, E2>(schedule0: Lazy<Schedule<R1, E, O>>, orElse: (e: E, out: O) => IO<R2, E2, A>, __tsplusTrace?: string): <R>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R1 | R2 | R, E2, A>;
 /**
- * @tsplus getter fncts.io.IO retryOrElseEither
+ * @tsplus pipeable fncts.io.IO retryOrElseEither
  * @tsplus location "@fncts/io/IO/api/retry"
  */
-export declare function retryOrElseEither_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): <R1, O, R2, E2, B>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, E, O>>, orElse: (e: E, out: O) => import("../definition").IO<R2, E2, B>, __tsplusTrace?: string) => import("../definition").IO<R | R1 | R2, E2, import("@fncts/base/data/Either").Either<B, A>>;
+export declare function retryOrElseEither<E, R1, O, R2, E2, B>(schedule0: Lazy<Schedule<R1, E, O>>, orElse: (e: E, out: O) => IO<R2, E2, B>, __tsplusTrace?: string): <R, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R1 | R2 | R, E2, import("@fncts/base/data/Either").Either<B, A>>;

package/IO/api/schedule.d.ts

@@ -1,13 +1,13 @@
-import { IO } from "@fncts/io/IO/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Schedule } from "@fncts/io/Schedule/definition";
+import { IO } from "@fncts/io/IO/definition";
 /**
- * @tsplus fluent fncts.io.IO scheduleFrom
+ * @tsplus pipeable fncts.io.IO scheduleFrom
  * @tsplus location "@fncts/io/IO/api/schedule"
  */
-export declare function scheduleFrom<R, E, A extends A1, R1, A1, B>(self: IO<R, E, A>, a: Lazy<A>, schedule0: Lazy<Schedule<R1, A1, B>>, __tsplusTrace?: string): IO<R | R1, E, B>;
+export declare function scheduleFrom<A extends A1, R1, A1, B>(a: Lazy<A>, schedule0: Lazy<Schedule<R1, A1, B>>, __tsplusTrace?: string): <R, E>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R1 | R, E, B>;
 /**
- * @tsplus fluent fncts.io.IO schedule
+ * @tsplus pipeable fncts.io.IO schedule
  * @tsplus location "@fncts/io/IO/api/schedule"
  */
-export declare function schedule<R, E, A, R1, B>(io: IO<R, E, A>, schedule: Lazy<Schedule<R1, any, B>>, __tsplusTrace?: string): IO<R | R1, E, B>;
+export declare function schedule<R1, B>(schedule: Lazy<Schedule<R1, any, B>>, __tsplusTrace?: string): <R, E, A>(io: import("../definition").IO<R, E, A>) => import("../definition").IO<R1 | R, E, B>;

package/IO/api/scoped.d.ts

@@ -5,9 +5,9 @@ import { Scope } from "@fncts/io/Scope/definition";
  * @tsplus static fncts.io.IOOps scoped
  * @tsplus location "@fncts/io/IO/api/scoped"
  */
-export declare function scoped<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, A>;
+export declare function scoped_<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, A>;
 /**
  * @tsplus getter fncts.io.IO scoped
  * @tsplus location "@fncts/io/IO/api/scoped"
  */
-export declare function scoped_<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, A>;
+export declare function scoped<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, A>;

package/IO/api/supervised.d.ts

@@ -1,10 +1,10 @@
-import { IO } from "@fncts/io/IO/definition";
 import { Supervisor } from "@fncts/io/Supervisor/definition";
+import { IO } from "@fncts/io/IO/definition";
 /**
  *
  * Returns an IO with the behavior of this one, but where all child
  * fibers forked in the effect are reported to the specified supervisor.
- * @tsplus fluent fncts.io.IO supervised
+ * @tsplus pipeable fncts.io.IO supervised
  * @tsplus location "@fncts/io/IO/api/supervised"
  */
-export declare function supervised_<R, E, A>(fa: IO<R, E, A>, supervisor: Supervisor<any>, __tsplusTrace?: string): IO<R, E, A>;
+export declare function supervised(supervisor: Supervisor<any>, __tsplusTrace?: string): <R, E, A>(fa: import("../definition").IO<R, E, A>) => import("../definition").IO<R, E, A>;