@fncts/io 0.0.20 → 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/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/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>>;

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>;