@fncts/io 0.0.19 → 0.0.21

package/Channel/definition.d.ts

@@ -41,33 +41,47 @@ export declare abstract class Channel<Env, InErr, InElem, InDone, OutErr, OutEle
  */
 export declare function unifyChannel<X extends Channel<any, any, any, any, any, any, any>>(_: X): Channel<[
     X
-] extends [{
-    _Env: () => infer Env;
-}] ? Env : never, [
+] extends [
+    {
+        _Env: () => infer Env;
+    }
+] ? Env : never, [
     X
-] extends [{
-    _InErr: (_: infer InErr) => void;
-}] ? InErr : never, [
+] extends [
+    {
+        _InErr: (_: infer InErr) => void;
+    }
+] ? InErr : never, [
     X
-] extends [{
-    _InElem: (_: infer InElem) => void;
-}] ? InElem : never, [
+] extends [
+    {
+        _InElem: (_: infer InElem) => void;
+    }
+] ? InElem : never, [
     X
-] extends [{
-    _InDone: (_: infer InDone) => void;
-}] ? InDone : never, [
+] extends [
+    {
+        _InDone: (_: infer InDone) => void;
+    }
+] ? InDone : never, [
     X
-] extends [{
-    _OutErr: () => infer OutErr;
-}] ? OutErr : never, [
+] extends [
+    {
+        _OutErr: () => infer OutErr;
+    }
+] ? OutErr : never, [
     X
-] extends [{
-    _OutElem: () => infer OutElem;
-}] ? OutElem : never, [
+] extends [
+    {
+        _OutElem: () => infer OutElem;
+    }
+] ? OutElem : never, [
     X
-] extends [{
-    _OutDone: () => infer OutDone;
-}] ? OutDone : never>;
+] extends [
+    {
+        _OutDone: () => infer OutDone;
+    }
+] ? OutDone : never>;
 export declare abstract class Continuation<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2> {
     readonly _Env: () => Env;
     readonly _InErr: (_: InErr) => void;

package/Differ/api.d.ts

@@ -0,0 +1,24 @@
+import type { Environment } from "@fncts/base/data/Environment";
+import type { Supervisor } from "@fncts/io/Supervisor";
+import { Differ } from "./definition.js";
+/**
+ * Constructs a differ that just diffs two values by returning a function that
+ * sets the value to the new value. This differ does not support combining
+ * multiple updates to the value compositionally and should only be used when
+ * there is no compositional way to update them.
+ * @tsplus static fncts.io.DifferOps update
+ * @tsplus location "@fncts/io/Differ/api"
+ */
+export declare function update<A>(): Differ<A, (_: A) => A>;
+/**
+ * Constructs a differ that knows how to diff `Environment` values.
+ * @tsplus static fncts.io.DifferOps environment
+ * @tsplus location "@fncts/io/Differ/api"
+ */
+export declare function environment<A>(): Differ<Environment<A>, Environment.Patch<A, A>>;
+/**
+ * Constructs a differ that knows how to diff `Supervisor` values.
+ * @tsplus static fncts.io.DifferOps supervisor
+ * @tsplus location "@fncts/io/Differ/api"
+ */
+export declare function supervisor(): Differ<Supervisor<any>, Supervisor.Patch>;

package/Differ/definition.d.ts

@@ -0,0 +1,15 @@
+export declare const DifferTypeId: unique symbol;
+export type DifferTypeId = typeof DifferTypeId;
+/**
+ * @tsplus type fncts.io.Differ
+ * @tsplus companion fncts.io.DifferOps
+ */
+export declare abstract class Differ<Value, Patch> {
+    readonly _typeId: DifferTypeId;
+    _Value: Value;
+    _Patch: Patch;
+    abstract readonly empty: Patch;
+    abstract combine(first: Patch, second: Patch): Patch;
+    abstract diff(oldValue: Value, newValue: Value): Patch;
+    abstract patch(patch: Patch): (oldValue: Value) => Value;
+}

package/Fiber/api/evalOn.d.ts

@@ -1,7 +1,7 @@
-import { Fiber } from "@fncts/io/Fiber/definition";
 import { UIO } from "@fncts/io/IO/definition";
+import { Fiber } from "@fncts/io/Fiber/definition";
 /**
- * @tsplus fluent fncts.io.Fiber evalOn
+ * @tsplus pipeable fncts.io.Fiber evalOn
  * @tsplus location "@fncts/io/Fiber/api/evalOn"
  */
-export declare function evalOn_<E, A>(fiber: Fiber<E, A>, effect: UIO<any>, orElse: UIO<any>, __tsplusTrace?: string): UIO<void>;
+export declare function evalOn(effect: UIO<any>, orElse: UIO<any>, __tsplusTrace?: string): <E, A>(fiber: import("../definition").Fiber<E, A>) => import("../../IO").UIO<void>;

package/Fiber/api/evalOnIO.d.ts

@@ -1,9 +1,9 @@
-import { Fiber } from "@fncts/io/Fiber/definition";
 import { IO } from "@fncts/io/IO/definition";
+import { Fiber } from "@fncts/io/Fiber/definition";
 /**
  * A fully-featured, but much slower version of `evalOn`, which is useful
  * when environment and error are required.
- * @tsplus fluent fncts.io.Fiber evalOnIO
+ * @tsplus pipeable fncts.io.Fiber evalOnIO
  * @tsplus location "@fncts/io/Fiber/api/evalOnIO"
  */
-export declare function evalOnIO_<E, A, R1, E1, B, R2, E2, C>(fiber: Fiber<E, A>, effect: IO<R1, E1, B>, orElse: IO<R2, E2, C>, __tsplusTrace?: string): IO<R1 | R2, E1 | E2, B | C>;
+export declare function evalOnIO<R1, E1, B, R2, E2, C>(effect: IO<R1, E1, B>, orElse: IO<R2, E2, C>, __tsplusTrace?: string): <E, A>(fiber: import("../definition").Fiber<E, A>) => IO<R1 | R2, E1 | E2, B | C>;

package/Fiber/api/interruptAs.d.ts

@@ -1,9 +1,9 @@
-import { Fiber } from "@fncts/io/Fiber/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { Fiber } from "@fncts/io/Fiber/definition";
 import { UIO } from "@fncts/io/IO/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 /**
- * @tsplus fluent fncts.io.Fiber interruptAs
+ * @tsplus pipeable fncts.io.Fiber interruptAs
  * @tsplus location "@fncts/io/Fiber/api/interruptAs"
  */
-export declare function interruptAs<E, A>(self: Fiber<E, A>, fiberId: FiberId, __tsplusTrace?: string): UIO<Exit<E, A>>;
+export declare function interruptAs(fiberId: FiberId, __tsplusTrace?: string): <E, A>(self: import("../definition").Fiber<E, A>) => import("../../IO").UIO<import("@fncts/base/data/Exit").Exit<E, A>>;

package/Fiber/api/interruptAsFork.d.ts

@@ -1,8 +1,8 @@
-import { Fiber } from "@fncts/io/Fiber/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { Fiber } from "@fncts/io/Fiber/definition";
 import { UIO } from "@fncts/io/IO/definition";
 /**
- * @tsplus fluent fncts.io.Fiber interruptAsFork
+ * @tsplus pipeable fncts.io.Fiber interruptAsFork
  * @tsplus location "@fncts/io/Fiber/api/interruptAsFork"
  */
-export declare function interruptAsFork<E, A>(self: Fiber<E, A>, fiberId: FiberId): UIO<void>;
+export declare function interruptAsFork(fiberId: FiberId): <E, A>(self: import("../definition").Fiber<E, A>) => import("../../IO").UIO<void>;

package/Fiber/api/mapFiber.d.ts

@@ -3,7 +3,7 @@ import { UIO } from "@fncts/io/IO/definition";
 /**
  * Passes the success of this fiber to the specified callback, and continues
  * with the fiber that it returns.
- * @tsplus fluent fncts.io.Fiber mapFiber
+ * @tsplus pipeable fncts.io.Fiber mapFiber
  * @tsplus location "@fncts/io/Fiber/api/mapFiber"
  */
-export declare function mapFiber_<A, E, E1, A1>(fiber: Fiber<E, A>, f: (a: A) => Fiber<E1, A1>, __tsplusTrace?: string): UIO<Fiber<E | E1, A1>>;
+export declare function mapFiber<A, E1, A1>(f: (a: A) => Fiber<E1, A1>, __tsplusTrace?: string): <E>(fiber: import("../definition").Fiber<E, A>) => import("../../IO").UIO<import("../definition").Fiber<E1 | E, A1>>;

package/Fiber/api/mapIO.d.ts

@@ -1,14 +1,14 @@
-import { Fiber } from "@fncts/io/Fiber/definition";
 import { FIO } from "@fncts/io/IO/definition";
+import { Fiber } from "@fncts/io/Fiber/definition";
 /**
  * Effectfully maps over the value the fiber computes.
- * @tsplus fluent fncts.io.Fiber mapIO
+ * @tsplus pipeable fncts.io.Fiber mapIO
  * @tsplus location "@fncts/io/Fiber/api/mapIO"
  */
-export declare function mapIO_<E, E1, A, B>(fiber: Fiber<E, A>, f: (a: A) => FIO<E1, B>, __tsplusTrace?: string): Fiber<E | E1, B>;
+export declare function mapIO<E1, A, B>(f: (a: A) => FIO<E1, B>, __tsplusTrace?: string): <E>(fiber: import("@fncts/io/Fiber/definition").Fiber<E, A>) => import("@fncts/io/Fiber/definition").Fiber<E1 | E, B>;
 /**
  * Maps over the value the fiber computes.
- * @tsplus fluent fncts.io.Fiber map
+ * @tsplus pipeable fncts.io.Fiber map
  * @tsplus location "@fncts/io/Fiber/api/mapIO"
  */
-export declare function map_<E, A, B>(fa: Fiber<E, A>, f: (a: A) => B, __tsplusTrace?: string): Fiber<E, B>;
+export declare function map<A, B>(f: (a: A) => B, __tsplusTrace?: string): <E>(fa: import("@fncts/io/Fiber/definition").Fiber<E, A>) => import("@fncts/io/Fiber/definition").Fiber<E, B>;

package/Fiber/api/zipWith.d.ts

@@ -3,7 +3,7 @@ import { Fiber } from "@fncts/io/Fiber/definition";
  * Zips this fiber with the specified fiber, combining their results using
  * the specified combiner function. Both joins and interruptions are performed
  * in sequential order from left to right.
- * @tsplus fluent fncts.io.Fiber zipWith
+ * @tsplus pipeable fncts.io.Fiber zipWith
  * @tsplus location "@fncts/io/Fiber/api/zipWith"
  */
-export declare function zipWith_<E, A, E1, B, C>(self: Fiber<E, A>, that: Fiber<E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): Fiber<E | E1, C>;
+export declare function zipWith<A, E1, B, C>(that: Fiber<E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <E>(self: import("@fncts/io/Fiber/definition").Fiber<E, A>) => import("@fncts/io/Fiber/definition").Fiber<E1 | E, C>;

package/Fiber.d.ts

@@ -13,6 +13,7 @@ export * from "./Fiber/api/inheritRefs.js";
 export * from "./Fiber/api/interrupt.js";
 export * from "./Fiber/api/interruptAll.js";
 export * from "./Fiber/api/interruptAs.js";
+export * from "./Fiber/api/interruptAsFork.js";
 export * from "./Fiber/api/interruptFork.js";
 export * from "./Fiber/api/join.js";
 export * from "./Fiber/api/joinAll.js";

package/FiberRef/api/locallyScoped.d.ts

@@ -2,7 +2,7 @@ import { FiberRef } from "@fncts/io/FiberRef/definition";
 import { IO } from "@fncts/io/IO/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 /**
- * @tsplus fluent fncts.io.FiberRef locallyScoped
+ * @tsplus pipeable fncts.io.FiberRef locallyScoped
  * @tsplus location "@fncts/io/FiberRef/api/locallyScoped"
  */
-export declare function locallyScoped_<A>(ref: FiberRef<A>, a: A, __tsplusTrace?: string): IO<Scope, never, void>;
+export declare function locallyScoped<A>(a: A, __tsplusTrace?: string): (ref: FiberRef<A>) => IO<Scope, never, void>;

package/FiberRef/api/locallyScopedWith.d.ts

@@ -2,7 +2,7 @@ import { FiberRef } from "@fncts/io/FiberRef/definition";
 import { IO } from "@fncts/io/IO/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 /**
- * @tsplus fluent fncts.io.FiberRef locallyScopedWith
+ * @tsplus pipeable fncts.io.FiberRef locallyScopedWith
  * @tsplus location "@fncts/io/FiberRef/api/locallyScopedWith"
  */
-export declare function locallyScopedWith<A>(self: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string): IO<Scope, never, void>;
+export declare function locallyScopedWith<A>(f: (a: A) => A, __tsplusTrace?: string): (self: FiberRef<A>) => IO<Scope, never, void>;

package/FiberRef/api.d.ts

@@ -2,40 +2,40 @@ import { FiberRef } from "@fncts/io/FiberRef/definition";
 import { UIO, IO } from "@fncts/io/IO/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 /**
- * @tsplus fluent fncts.io.FiberRef modify
+ * @tsplus pipeable fncts.io.FiberRef modify
  * @tsplus location "@fncts/io/FiberRef/api"
  */
-export declare function modify_<A, B>(self: FiberRef<A>, f: (a: A) => readonly [B, A], __tsplusTrace?: string): UIO<B>;
+export declare function modify<A, B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): (self: FiberRef<A>) => import("../IO").UIO<B>;
 /**
- * @tsplus fluent fncts.io.FiberRef update
+ * @tsplus pipeable fncts.io.FiberRef update
  * @tsplus location "@fncts/io/FiberRef/api"
  */
-export declare function update_<A>(fiberRef: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string): UIO<void>;
+export declare function update<A>(f: (a: A) => A, __tsplusTrace?: string): (fiberRef: FiberRef<A>) => import("../IO").UIO<void>;
 /**
- * @tsplus fluent fncts.io.FiberRef set
+ * @tsplus pipeable fncts.io.FiberRef set
  * @tsplus location "@fncts/io/FiberRef/api"
  */
-export declare function set_<A>(fiberRef: FiberRef<A>, a: A, __tsplusTrace?: string): UIO<void>;
+export declare function set<A>(a: A, __tsplusTrace?: string): (fiberRef: FiberRef<A>) => import("../IO").UIO<void>;
 /**
  * @tsplus getter fncts.io.FiberRef get
  * @tsplus location "@fncts/io/FiberRef/api"
  */
 export declare function get<A>(fiberRef: FiberRef<A>, __tsplusTrace?: string): UIO<A>;
 /**
- * @tsplus fluent fncts.io.FiberRef getAndSet
+ * @tsplus pipeable fncts.io.FiberRef getAndSet
  * @tsplus location "@fncts/io/FiberRef/api"
  */
-export declare function getAndSet_<A>(fiberRef: FiberRef<A>, a: A, __tsplusTrace?: string): UIO<A>;
+export declare function getAndSet<A>(a: A, __tsplusTrace?: string): (fiberRef: FiberRef<A>) => import("../IO").UIO<A>;
 /**
- * @tsplus fluent fncts.io.FiberRef getAndUpdate
+ * @tsplus pipeable fncts.io.FiberRef getAndUpdate
  * @tsplus location "@fncts/io/FiberRef/api"
  */
-export declare function getAndUpdate_<A>(fiberRef: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string): UIO<A>;
+export declare function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string): (fiberRef: FiberRef<A>) => import("../IO").UIO<A>;
 /**
- * @tsplus fluent fncts.io.FiberRef getAndUpdateJust
+ * @tsplus pipeable fncts.io.FiberRef getAndUpdateJust
  * @tsplus location "@fncts/io/FiberRef/api"
  */
-export declare function getAndUpdateJust_<A>(fiberRef: FiberRef<A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): UIO<A>;
+export declare function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): (fiberRef: FiberRef<A>) => import("../IO").UIO<A>;
 /**
  * Returns an `IO` that runs with `value` bound to the current fiber.
  *
@@ -43,7 +43,7 @@ export declare function getAndUpdateJust_<A>(fiberRef: FiberRef<A>, f: (a: A) =>
  * @tsplus fluent fncts.io.FiberRef locally
  * @tsplus location "@fncts/io/FiberRef/api"
  */
-export declare function locally_<A>(fiberRef: FiberRef<A>, value: A, __tsplusTrace?: string): <R1, E1, B>(use: import("../IO").IO<R1, E1, B>) => import("../IO").IO<R1, E1, B>;
+export declare function locally<A>(fiberRef: FiberRef<A>, value: A, __tsplusTrace?: string): <R1, E1, B>(use: import("../IO").IO<R1, E1, B>) => import("../IO").IO<R1, E1, B>;
 /**
  * Returns an `IO` that runs with `f` applied to the current fiber.
  *
@@ -51,12 +51,12 @@ export declare function locally_<A>(fiberRef: FiberRef<A>, value: A, __tsplusTra
  * @tsplus fluent fncts.io.FiberRef locallyWith
  * @tsplus location "@fncts/io/FiberRef/api"
  */
-export declare function locallyWith_<A>(self: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string): <R1, E1, B>(use: import("../IO").IO<R1, E1, B>) => import("../IO").IO<R1, E1, B>;
+export declare function locallyWith<A>(self: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string): <R1, E1, B>(use: import("../IO").IO<R1, E1, B>) => import("../IO").IO<R1, E1, B>;
 /**
- * @tsplus fluent fncts.io.FiberRef getWith
+ * @tsplus pipeable fncts.io.FiberRef getWith
  * @tsplus location "@fncts/io/FiberRef/api"
  */
-export declare function getWith_<A, R, E, B>(fiberRef: FiberRef<A>, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, B>;
+export declare function getWith<A, R, E, B>(f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): (fiberRef: FiberRef<A>) => IO<R, E, B>;
 /**
  * @tsplus getter fncts.io.FiberRef remove
  * @tsplus location "@fncts/io/FiberRef/api"
@@ -88,7 +88,7 @@ export declare function patch<Value, Patch>(self: FiberRef.WithPatch<Value, Patc
  */
 export declare function fork<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>): Patch;
 /**
- * @tsplus fluent fncts.io.FiberRef join
+ * @tsplus pipeable fncts.io.FiberRef join
  * @tsplus location "@fncts/io/FiberRef/api"
  */
-export declare function join<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>, oldValue: Value, newValue: Value): Value;
+export declare function join<Value>(oldValue: Value, newValue: Value): <Patch>(self: import("@fncts/io/FiberRef/definition").FiberRef.WithPatch<Value, Patch>) => Value;

package/FiberRef/unsafe.d.ts

@@ -1,25 +1,31 @@
 import { FiberRef } from "@fncts/io/FiberRef/definition";
 import { Environment } from "@fncts/base/data/Environment/definition";
+import { Supervisor } from "@fncts/io/Supervisor/definition";
+import { SupervisorPatch } from "@fncts/io/SupervisorPatch";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { FiberScope } from "@fncts/io/FiberScope";
 import { LogLevel } from "@fncts/io/LogLevel";
 import { List } from "@fncts/base/collection/immutable/List/definition";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
-import { Supervisor } from "@fncts/io/Supervisor/definition";
 import type { LogSpan } from "../LogSpan.js";
 import type { Scheduler } from "@fncts/io/internal/Scheduler.js";
-import { Patch } from "@fncts/base/data/Patch";
+import { Differ } from "@fncts/io/Differ/definition";
 import { IsFatal } from "../internal/IsFatal.js";
 /**
  * @tsplus static fncts.io.FiberRefOps unsafeMakePatch
  * @tsplus location "@fncts/io/FiberRef/unsafe"
  */
-export declare function unsafeMakePatch<Value, Patch>(initial: Value, diff: (oldValue: Value, newValue: Value) => Patch, combine: (first: Patch, second: Patch) => Patch, patch: (patch: Patch) => (oldValue: Value) => Value, fork: Patch, join?: (oldValue: Value, newValue: Value) => Value): FiberRef.WithPatch<Value, Patch>;
+export declare function unsafeMakePatch<Value, Patch>(initial: Value, differ: Differ<Value, Patch>, fork: Patch, join?: (oldValue: Value, newValue: Value) => Value): FiberRef.WithPatch<Value, Patch>;
 /**
  * @tsplus static fncts.io.FiberRefOps unsafeMakeEnvironment
  * @tsplus location "@fncts/io/FiberRef/unsafe"
  */
-export declare function unsafeMakeEnvironment<A>(initial: Environment<A>): FiberRef.WithPatch<Environment<A>, Patch<A, A>>;
+export declare function unsafeMakeEnvironment<A>(initial: Environment<A>): FiberRef.WithPatch<Environment<A>, Environment.Patch<A, A>>;
+/**
+ * @tsplus static fncts.io.FiberRefOps unsafeMakeSupervisor
+ * @tsplus location "@fncts/io/FiberRef/unsafe"
+ */
+export declare function unsafeMakeSupervisor(initial: Supervisor<any>): FiberRef.WithPatch<Supervisor<any>, SupervisorPatch>;
 /**
  * @tsplus static fncts.io.FiberRefOps unsafeMake
  * @tsplus location "@fncts/io/FiberRef/unsafe"
@@ -34,7 +40,7 @@ export declare const forkScopeOverride: import("./definition.js").FiberRef.WithP
  * @tsplus static fncts.io.FiberRefOps currentEnvironment
  * @tsplus location "@fncts/io/FiberRef/unsafe"
  */
-export declare const currentEnvironment: import("./definition.js").FiberRef.WithPatch<import("@fncts/base/data/Environment.js").Environment<unknown>, Patch<unknown, unknown>>;
+export declare const currentEnvironment: import("./definition.js").FiberRef.WithPatch<import("@fncts/base/data/Environment.js").Environment<unknown>, import("@fncts/base/data/Environment.js").Environment.Patch<unknown, unknown>>;
 /**
  * @tsplus static fncts.io.FiberRefOps fiberName
  * @tsplus location "@fncts/io/FiberRef/unsafe"
@@ -64,7 +70,7 @@ export declare const currentScheduler: import("./definition.js").FiberRef.WithPa
  * @tsplus static fncts.io.FiberRefOps currentSupervisor
  * @tsplus location "@fncts/io/FiberRef/unsafe"
  */
-export declare const currentSupervisor: import("./definition.js").FiberRef.WithPatch<import("../Supervisor.js").Supervisor<any>, (_: import("../Supervisor.js").Supervisor<any>) => import("../Supervisor.js").Supervisor<any>>;
+export declare const currentSupervisor: import("./definition.js").FiberRef.WithPatch<import("../Supervisor.js").Supervisor<any>, import("../SupervisorPatch.js").SupervisorPatch>;
 /**
  * @tsplus static fncts.io.FiberRefOps currentIsFatal
  * @tsplus location "@fncts/io/FiberRef/unsafe"

package/FiberRefs/api.d.ts

@@ -15,7 +15,7 @@ export declare function fiberRefs(self: FiberRefs): HashSet<FiberRef<unknown>>;
  */
 export declare function make(fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>): FiberRefs;
 /**
- * @tsplus fluent fncts.io.FiberRefs forkAs
+ * @tsplus pipeable fncts.io.FiberRefs forkAs
  * @tsplus location "@fncts/io/FiberRefs/api"
  */
-export declare function forkAs(self: FiberRefs, childId: FiberId.Runtime): FiberRefs;
+export declare function forkAs(childId: FiberId.Runtime): (self: FiberRefs) => FiberRefs;

package/FiberRefs/join.d.ts

@@ -1,9 +1,9 @@
-import { FiberRefs } from "@fncts/io/FiberRefs";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { FiberRefs } from "@fncts/io/FiberRefs";
 import { Cons, List } from "@fncts/base/collection/immutable/List/definition";
 import { FiberRef } from "@fncts/io/FiberRef/definition";
 /**
- * @tsplus fluent fncts.io.FiberRefs join
+ * @tsplus pipeable fncts.io.FiberRefs join
  * @tsplus location "@fncts/io/FiberRefs/join"
  */
-export declare function join(self: FiberRefs, fiberId: FiberId.Runtime, that: FiberRefs): FiberRefs;
+export declare function join(fiberId: FiberId.Runtime, that: FiberRefs): (self: FiberRefs) => FiberRefs;

package/Future/api.d.ts

@@ -1,5 +1,5 @@
-import { Future } from "@fncts/io/Future";
 import { Exit } from "@fncts/base/data/Exit/definition";
+import { Future } from "@fncts/io/Future";
 import { UIO, IO, FIO } from "@fncts/io/IO/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
@@ -7,34 +7,34 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
 /**
  * Exits the future with the specified exit, which will be propagated to all
  * fibers waiting on the value of the future.
- * @tsplus fluent fncts.io.Future done
+ * @tsplus pipeable fncts.io.Future done
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function done_<E, A>(future: Future<E, A>, exit: Exit<E, A>, __tsplusTrace?: string): UIO<boolean>;
+export declare function done<E, A>(exit: Exit<E, A>, __tsplusTrace?: string): (future: Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
 /**
  * Fails the future with the specified error, which will be propagated to all
  * fibers waiting on the value of the future.
- * @tsplus fluent fncts.io.Future fail
+ * @tsplus pipeable fncts.io.Future fail
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function fail_<E, A>(future: Future<E, A>, e: E, __tsplusTrace?: string): UIO<boolean>;
+export declare function fail<E>(e: E, __tsplusTrace?: string): <A>(future: import("@fncts/io/Future/definition").Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
 /**
  * Halts the future with the specified cause, which will be propagated to all
  * fibers waiting on the value of the future.
- * @tsplus fluent fncts.io.Future failCause
+ * @tsplus pipeable fncts.io.Future failCause
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function failCause_<E, A>(future: Future<E, A>, cause: Cause<E>, __tsplusTrace?: string): UIO<boolean>;
+export declare function failCause<E>(cause: Cause<E>, __tsplusTrace?: string): <A>(future: import("@fncts/io/Future/definition").Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
 /**
  * Completes the future with the result of the specified effect. If the
  * future has already been completed, the method will produce false.
  *
  * Note that `Future.completeWith` will be much faster, so consider using
  * that if you do not need to memoize the result of the specified effect.
- * @tsplus fluent fncts.io.Future fulfill
+ * @tsplus pipeable fncts.io.Future fulfill
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function fulfill_<R, E, A>(future: Future<E, A>, io: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, boolean>;
+export declare function fulfill<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): (future: Future<E, A>) => IO<R, never, boolean>;
 /**
  * Completes the future with the specified effect. If the future has
  * already been completed, the method will produce false.
@@ -47,17 +47,17 @@ export declare function fulfill_<R, E, A>(future: Future<E, A>, io: IO<R, E, A>,
  * future can be completed with exactly one effect. For a version that
  * completes the future with the result of an IO see
  * `Future.complete`.
- * @tsplus fluent fncts.io.Future fulfillWith
+ * @tsplus pipeable fncts.io.Future fulfillWith
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function fulfillWith_<E, A>(future: Future<E, A>, io: FIO<E, A>, __tsplusTrace?: string): UIO<boolean>;
+export declare function fulfillWith<E, A>(io: FIO<E, A>, __tsplusTrace?: string): (future: Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
 /**
  * Kills the future with the specified error, which will be propagated to all
  * fibers waiting on the value of the future.
- * @tsplus fluent fncts.io.Future halt
+ * @tsplus pipeable fncts.io.Future halt
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function halt_<E, A>(future: Future<E, A>, defect: unknown, __tsplusTrace?: string): UIO<boolean>;
+export declare function halt(defect: unknown, __tsplusTrace?: string): <E, A>(future: import("@fncts/io/Future/definition").Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
 /**
  * Completes the future with interruption. This will interrupt all fibers
  * waiting on the value of the future as by the fiber calling this method.
@@ -68,10 +68,10 @@ export declare function interrupt<E, A>(future: Future<E, A>, __tsplusTrace?: st
 /**
  * Completes the future with interruption. This will interrupt all fibers
  * waiting on the value of the future as by the specified fiber.
- * @tsplus fluent fncts.io.Future interruptAs
+ * @tsplus pipeable fncts.io.Future interruptAs
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function interruptAs_<E, A>(future: Future<E, A>, id: FiberId, __tsplusTrace?: string): UIO<boolean>;
+export declare function interruptAs(id: FiberId, __tsplusTrace?: string): <E, A>(future: import("@fncts/io/Future/definition").Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
 /**
  * Checks for completion of this Future. Produces true if this future has
  * already been completed with a value or an error and false otherwise.
@@ -88,22 +88,22 @@ export declare function isDone<E, A>(future: Future<E, A>, __tsplusTrace?: strin
 export declare function poll<E, A>(future: Future<E, A>, __tsplusTrace?: string): UIO<Maybe<FIO<E, A>>>;
 /**
  * Completes the future with the specified value.
- * @tsplus fluent fncts.io.Future succeed
+ * @tsplus pipeable fncts.io.Future succeed
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function succeed_<A, E>(future: Future<E, A>, a: A, __tsplusTrace?: string): import("@fncts/io/IO").UIO<boolean>;
+export declare function succeed_<A>(a: A, __tsplusTrace?: string): <E>(future: import("@fncts/io/Future/definition").Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
 /**
  * Retrieves the value of the future, suspending the fiber running the action
  * until the result is available.
- * @tsplus fluent fncts.io.Future unsafeDone
+ * @tsplus pipeable fncts.io.Future unsafeDone
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function unsafeDone_<E, A>(future: Future<E, A>, io: FIO<E, A>, __tsplusTrace?: string): void;
+export declare function unsafeDone<E, A>(io: FIO<E, A>, __tsplusTrace?: string): (future: Future<E, A>) => void;
 /**
- * @tsplus fluent fncts.io.Future unsafeSucceed
+ * @tsplus pipeable fncts.io.Future unsafeSucceed
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function unsafeSucceed_<A>(future: Future<never, A>, a: A, __tsplusTrace?: string): void;
+export declare function unsafeSucceed<A>(a: A, __tsplusTrace?: string): (future: Future<never, A>) => void;
 /**
  * Retrieves the value of the future, suspending the fiber running the action
  * until the result is available.

package/Hub/constructors.d.ts

@@ -0,0 +1,49 @@
+import { UIO } from "@fncts/io/IO/definition";
+import { Future } from "@fncts/io/Future";
+import { Scope } from "@fncts/io/Scope/definition";
+import type { Strategy } from "./internal";
+import type { HashSet } from "@fncts/base/collection/mutable/HashSet";
+import type { HashedPair } from "@fncts/io/internal/HashedPair";
+import type { MutableQueue } from "@fncts/io/internal/MutableQueue";
+import { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
+import { Hub as HubInternal } from "@fncts/io/internal/Hub";
+import { Hub } from "./definition.js";
+/**
+ * Creates a bounded hub with the back pressure strategy. The hub will retain
+ * messages until they have been taken by all subscribers, applying back
+ * pressure to publishers if the hub is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ * @tsplus static fncts.io.HubOps makeBounded
+ * @tsplus location "@fncts/io/Hub/constructors"
+ */
+export declare function makeBounded<A>(requestedCapacity: number, __tsplusTrace?: string): UIO<Hub<A>>;
+/**
+ * Creates a bounded hub with the dropping strategy. The hub will drop new
+ * messages if the hub is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ * @tsplus static fncts.io.HubOps makeDropping
+ * @tsplus location "@fncts/io/Hub/constructors"
+ */
+export declare function makeDropping<A>(requestedCapacity: number, __tsplusTrace?: string): UIO<Hub<A>>;
+/**
+ * Creates a bounded hub with the sliding strategy. The hub will add new
+ * messages and drop old messages if the hub is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ * @tsplus static fncts.io.HubOps makeSliding
+ * @tsplus location "@fncts/io/Hub/constructors"
+ */
+export declare function makeSliding<A>(requestedCapacity: number, __tsplusTrace?: string): UIO<Hub<A>>;
+/**
+ * Creates an unbounded hub.
+ * @tsplus static fncts.io.HubOps makeUnbounded
+ * @tsplus location "@fncts/io/Hub/constructors"
+ */
+export declare function makeUnbounded<A>(__tsplusTrace?: string): UIO<Hub<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 makeHub<A>(hub: HubInternal<A>, strategy: Strategy<A>): UIO<Hub<A>>;