@fncts/io 0.0.20 → 0.0.21

package/global.d.ts

@@ -53,7 +53,7 @@ import { Future } from "@fncts/io/Future";
 /**
  * @tsplus global
  */
-import { Hub, PHub } from "@fncts/io/Hub/definition";
+import { Hub } from "@fncts/io/Hub/definition";
 /**
  * @tsplus global
  */
@@ -81,7 +81,7 @@ import { LogLevel } from "@fncts/io/LogLevel";
 /**
  * @tsplus global
  */
-import { PQueue, Queue } from "@fncts/io/Queue/definition";
+import { Dequeue, Enqueue, Queue } from "@fncts/io/Queue/definition";
 /**
  * @tsplus global
  */
@@ -89,7 +89,7 @@ import { Random } from "@fncts/io/Random/definition";
 /**
  * @tsplus global
  */
-import { PRef, Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref";
 /**
  * @tsplus global
  */
@@ -122,6 +122,10 @@ import { STM, USTM } from "@fncts/io/STM/definition";
  * @tsplus global
  */
 import { Stream } from "@fncts/io/Stream/definition";
+/**
+ * @tsplus global
+ */
+import { SubscriptionRef } from "@fncts/io/SubscriptionRef";
 /**
  * @tsplus global
  */

package/index.d.ts

@@ -23,6 +23,7 @@ export type {} from "./LogSpan.js";
 export type {} from "./Queue.js";
 export type {} from "./Random.js";
 export type {} from "./Ref.js";
+export type {} from "./Reloadable.js";
 export type {} from "./RuntimeConfig.js";
 export type {} from "./Schedule.js";
 export type {} from "./Scope.js";
@@ -31,7 +32,9 @@ export type {} from "./Sink.js";
 export type {} from "./State.js";
 export type {} from "./STM.js";
 export type {} from "./Stream.js";
+export type {} from "./SubscriptionRef.js";
 export type {} from "./Supervisor.js";
+export type {} from "./SupervisorPatch.js";
 export type {} from "./TExit.js";
 export type {} from "./TFuture.js";
 export type {} from "./TReentrantLock.js";

package/internal/Hub.d.ts

@@ -114,8 +114,8 @@ export declare function makeUnbounded<A>(): Hub<A>;
 export declare function unsafePollAll<A>(subscription: SubscriptionInternal<A>): Conc<A>;
 /**
  * Unsafely polls the specified number of values from a subscription.
- * @tsplus fluent fncts.internal.Hub.Subscription unsafePollN
+ * @tsplus pipeable fncts.internal.Hub.Subscription unsafePollN
  * @tsplus location "@fncts/io/internal/Hub"
  */
-export declare function unsafePollN<A>(subscription: SubscriptionInternal<A>, max: number): Conc<A>;
+export declare function unsafePollN(max: number): <A>(subscription: SubscriptionInternal<A>) => import("@fncts/base/collection/immutable/Conc").Conc<A>;
 export {};

package/internal/IsFatal.d.ts

@@ -40,8 +40,8 @@ export declare const empty: IsFatal;
 export declare function makeIsFatal(predicate: Predicate<unknown>): IsFatal;
 /**
  * @tsplus static fncts.io.IsFatalOps both
- * @tsplus fluent fncts.io.IsFatal both
- * @tsplus operator fncts.io.IsFatal |
+ * @tsplus pipeable fncts.io.IsFatal both
+ * @tsplus pipeable-operator fncts.io.IsFatal |
  * @tsplus location "@fncts/io/internal/IsFatal"
  */
-export declare function both(left: IsFatal, right: IsFatal): IsFatal;
+export declare function both(right: IsFatal): (left: IsFatal) => IsFatal;

package/internal/MutableQueue.d.ts

@@ -102,7 +102,7 @@ export declare class RingBufferPow2<A> extends RingBuffer<A> {
     constructor(requestedCapacity: number);
     posToIdx(pos: number, capacity: number): number;
 }
-export declare function mkRingBuffer<A>(requestedCapacity: number): RingBuffer<A>;
+export declare function makeRingBuffer<A>(requestedCapacity: number): RingBuffer<A>;
 /**
  * @tsplus static fncts.internal.MutableQueueOps bounded
  * @tsplus location "@fncts/io/internal/MutableQueue"
@@ -119,7 +119,7 @@ export declare function unbounded<A>(): MutableQueue<A>;
  */
 export declare function unsafeDequeueAll<A>(queue: MutableQueue<A>): Conc<A>;
 /**
- * @tsplus fluent fncts.internal.MutableQueue unsafeRemove
+ * @tsplus pipeable fncts.internal.MutableQueue unsafeRemove
  * @tsplus location "@fncts/io/internal/MutableQueue"
  */
-export declare function unsafeRemove<A>(queue: MutableQueue<A>, a: A): void;
+export declare function unsafeRemove<A>(a: A): (queue: MutableQueue<A>) => void;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@fncts/io",
-  "version": "0.0.20",
+  "version": "0.0.21",
   "dependencies": {
-    "@fncts/base": "0.0.20",
-    "@fncts/transformers": "0.0.2",
+    "@fncts/base": "0.0.21",
+    "@fncts/transformers": "0.0.3",
     "@fncts/typelevel": "0.0.14"
   },
   "exports": {

package/Hub/api.d.ts

@@ -1,190 +0,0 @@
-import { PHub, Hub } from "@fncts/io/Hub/definition";
-import { UIO, IO } from "@fncts/io/IO/definition";
-import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { Scope } from "@fncts/io/Scope/definition";
-/**
- * Waits for the hub to be shut down.
- * @tsplus getter fncts.io.Hub awaitShutdown
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function awaitShutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<void>;
-/**
- * The maximum capacity of the hub.
- * @tsplus getter fncts.io.Hub capacity
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function capacity<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): number;
-/**
- * Transforms messages published to the hub using the specified effectual
- * function.
- * @tsplus fluent fncts.io.Hub contramapIO
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function contramapIO_<RA, RB, RC, EA, EB, EC, A, B, C>(self: PHub<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string): PHub<RC | RA, RB, EA | EC, EB, C, B>;
-/**
- * Transforms messages published to and taken from the hub using the
- * specified functions.
- * @tsplus fluent fncts.io.Hub dimap
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function dimap_<RA, RB, EA, EB, A, B, C, D>(self: PHub<RA, RB, EA, EB, A, B>, f: (c: C) => A, g: (b: B) => D, __tsplusTrace?: string): PHub<RA, RB, EA, EB, C, D>;
-/**
- * Transforms messages published to and taken from the hub using the
- * specified effectual functions.
- * @tsplus fluent fncts.io.Hub dimapIO
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function dimapIO_<RA, RB, RC, RD, EA, EB, EC, ED, A, B, C, D>(source: PHub<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>, __tsplusTrace?: string): PHub<RC | RA, RD | RB, EA | EC, EB | ED, C, D>;
-/**
- * Filters messages published to the hub using the specified effectual
- * function.
- * @tsplus fluent fncts.io.Hub filterInputIO
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function filterInputIO_<RA, RA1, RB, EA, EA1, EB, A, B>(source: PHub<RA, RB, EA, EB, A, B>, f: (a: A) => IO<RA1, EA1, boolean>, __tsplusTrace?: string): PHub<RA | RA1, RB, EA | EA1, EB, A, B>;
-/**
- * Filters messages published to the hub using the specified function.
- * @tsplus fluent fncts.io.Hub filterInput
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function filterInput_<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, f: (a: A) => boolean, __tsplusTrace?: string): import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>;
-/**
- * Filters messages taken from the hub using the specified effectual
- * function.
- * @tsplus fluent fncts.io.Hub filterOutputIO
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function filterOutputIO_<RA, RB, RB1, EA, EB, EB1, A, B>(source: PHub<RA, RB, EA, EB, A, B>, f: (a: B) => IO<RB1, EB1, boolean>, __tsplusTrace?: string): PHub<RA, RB | RB1, EA, EB | EB1, A, B>;
-/**
- * Filters messages taken from the hub using the specified function.
- * @tsplus fluent fncts.io.Hub filterOutput
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function filterOutput_<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, f: (b: B) => boolean, __tsplusTrace?: string): PHub<RA, RB, EA, EB, A, B>;
-/**
- * Checks whether the hub is shut down.
- * @tsplus getter fncts.io.Hub isShutdown
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function isShutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<boolean>;
-/**
- * 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/api"
- */
-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/api"
- */
-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/api"
- */
-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/api"
- */
-export declare function makeUnbounded<A>(__tsplusTrace?: string): UIO<Hub<A>>;
-/**
- * Transforms messages taken from the hub using the specified function.
- * @tsplus fluent fncts.io.Hub map
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function map_<RA, RB, EA, EB, A, B, C>(self: PHub<RA, RB, EA, EB, A, B>, f: (b: B) => C, __tsplusTrace?: string): PHub<RA, RB, EA, EB, A, C>;
-/**
- * Transforms messages taken from the hub using the specified effectual
- * function.
- * @tsplus fluent fncts.io.Hub mapIO
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function mapIO_<RA, RB, RC, EA, EB, EC, A, B, C>(self: PHub<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RC, EC, C>, __tsplusTrace?: string): PHub<RA, RC | RB, EA, EB | EC, A, C>;
-/**
- * Publishes a message to the hub, returning whether the message was
- * published to the hub.
- * @tsplus fluent fncts.io.Hub publish
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function publish_<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, a: A, __tsplusTrace?: string): IO<RA, EA, boolean>;
-/**
- * Publishes all of the specified messages to the hub, returning whether
- * they were published to the hub.
- * @tsplus fluent fncts.io.Hub publishAll
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function publishAll_<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, as: Iterable<A>, __tsplusTrace?: string): IO<RA, EA, boolean>;
-/**
- * Shuts down the hub.
- * @tsplus getter fncts.io.Hub shutdown
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function shutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<void>;
-/**
- * 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.
- * @tsplus getter fncts.io.Hub subscribe
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function subscribe<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<Scope, never, Hub.Dequeue<RB, EB, B>>;
-/**
- * The current number of messages in the hub.
- * @tsplus getter fncts.io.Hub size
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function size<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<number>;
-/**
- * Views the hub as a queue that can only be written to.
- * @tsplus getter fncts.io.Hub toQueue
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function toQueue<RA, RB, EA, EB, A, B>(source: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): Hub.Enqueue<RA, EA, A>;
-/**
- * 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 unsafeMakeBounded
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function unsafeMakeBounded<A>(requestedCapacity: number): 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 unsafeMakeDropping
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function unsafeMakeDropping<A>(requestedCapacity: number): 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 unsafeMakeSliding
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function unsafeMakeSliding<A>(requestedCapacity: number): Hub<A>;
-/**
- * Creates an unbounded hub.
- * @tsplus static fncts.io.HubOps unsafeMakeUnbounded
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function unsafeMakeUnbounded<A>(): Hub<A>;

package/Queue/api/dimapIO.d.ts

@@ -1,41 +0,0 @@
-import { IO, UIO } from "@fncts/io/IO/definition";
-import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { PQueue } from "@fncts/io/Queue/definition";
-/**
- * Transforms elements enqueued into and dequeued from this queue with the
- * specified effectual functions.
- * @tsplus fluent fncts.io.Queue dimap
- * @tsplus location "@fncts/io/Queue/api/dimapIO"
- */
-export declare function dimap_<RA, RB, EA, EB, A, B, C, D>(self: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => A, g: (b: B) => D, __tsplusTrace?: string): import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, C, D>;
-/**
- * Transforms elements enqueued into and dequeued from this queue with the
- * specified effectual functions.
- * @tsplus fluent fncts.io.Queue dimapIO
- * @tsplus location "@fncts/io/Queue/api/dimapIO"
- */
-export declare function dimapIO_<RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>, __tsplusTrace?: string): PQueue<RC | RA, RD | RB, EC | EA, ED | EB, C, D>;
-/**
- * Transforms elements enqueued into this queue with an effectful function.
- * @tsplus fluent fncts.io.Queue contramapIO
- * @tsplus location "@fncts/io/Queue/api/dimapIO"
- */
-export declare function contramapIO_<RA, RB, EA, EB, A, B, RC, EC, C>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string): PQueue<RA | RC, RB, EA | EC, EB, C, B>;
-/**
- * Transforms elements enqueued into this queue with an effectful function.
- * @tsplus fluent fncts.io.Queue contramap
- * @tsplus location "@fncts/io/Queue/api/dimapIO"
- */
-export declare function contramap_<RA, RB, EA, EB, A, B, C>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => A, __tsplusTrace?: string): PQueue<RA, RB, EA, EB, C, B>;
-/**
- * Transforms elements dequeued from this queue with an effectful function.
- * @tsplus fluent fncts.io.Queue mapIO
- * @tsplus location "@fncts/io/Queue/api/dimapIO"
- */
-export declare function mapIO_<RA, RB, EA, EB, A, B, R2, E2, C>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (b: B) => IO<R2, E2, C>, __tsplusTrace?: string): PQueue<RA, R2 | RB, EA, EB | E2, A, C>;
-/**
- * Transforms elements dequeued from this queue with a function.
- * @tsplus fluent fncts.io.Queue map
- * @tsplus location "@fncts/io/Queue/api/dimapIO"
- */
-export declare function map_<RA, RB, EA, EB, A, B, C>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (b: B) => C, __tsplusTrace?: string): PQueue<RA, RB, EA, EB, A, C>;

package/Queue/api/filterInputIO.d.ts

@@ -1,33 +0,0 @@
-import { IO, UIO } from "@fncts/io/IO/definition";
-import { Just, Nothing } from "@fncts/base/data/Maybe/definition";
-import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { PQueue } from "@fncts/io/Queue/definition";
-import { QueueInternal } from "@fncts/io/Queue/definition";
-export declare class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends QueueInternal<RA | R2, RB, EA | E2, EB, A1, B> {
-    readonly queue: QueueInternal<RA, RB, EA, EB, A, B>;
-    readonly f: (_: A1) => IO<R2, E2, boolean>;
-    constructor(queue: QueueInternal<RA, RB, EA, EB, A, B>, f: (_: A1) => IO<R2, E2, boolean>);
-    awaitShutdown: UIO<void>;
-    capacity: number;
-    isShutdown: UIO<boolean>;
-    offer(a: A1): IO<RA | R2, EA | E2, boolean>;
-    offerAll(as: Iterable<A1>): IO<RA | R2, EA | E2, boolean>;
-    shutdown: UIO<void>;
-    size: UIO<number>;
-    take: IO<RB, EB, B>;
-    takeAll: IO<RB, EB, Conc<B>>;
-    takeUpTo(max: number): IO<RB, EB, Conc<B>>;
-}
-/**
- * Like `filterInput`, but uses an effectful function to filter the elements.
- * @tsplus fluent fncts.io.Queue filterInputIO
- * @tsplus location "@fncts/io/Queue/api/filterInputIO"
- */
-export declare function filterInputIO_<RA, RB, EA, EB, B, A, A1 extends A, R2, E2>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (_: A1) => IO<R2, E2, boolean>, __tsplusTrace?: string): PQueue<RA | R2, RB, EA | E2, EB, A1, B>;
-/**
- * Applies a filter to elements enqueued into this queue. Elements that do not
- * pass the filter will be immediately dropped.
- * @tsplus fluent fncts.io.Queue filterInput
- * @tsplus location "@fncts/io/Queue/api/filterInputIO"
- */
-export declare function filterInput_<RA, RB, EA, EB, B, A, A1 extends A>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (_: A1) => boolean, __tsplusTrace?: string): PQueue<RA, RB, EA, EB, A1, B>;

package/Queue/api/filterOutputIO.d.ts

@@ -1,31 +0,0 @@
-import { IO, UIO } from "@fncts/io/IO/definition";
-import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { PQueue } from "@fncts/io/Queue/definition";
-import { Predicate } from "@fncts/base/data/Predicate/definition";
-import { QueueInternal } from "@fncts/io/Queue/definition";
-export declare class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInternal<RA, RB | RB1, EA, EB | EB1, A, B> {
-    readonly queue: QueueInternal<RA, RB, EA, EB, A, B>;
-    readonly f: (b: B) => IO<RB1, EB1, boolean>;
-    constructor(queue: QueueInternal<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RB1, EB1, boolean>);
-    awaitShutdown: UIO<void>;
-    capacity: number;
-    isShutdown: UIO<boolean>;
-    offer(a: A): IO<RA, EA, boolean>;
-    offerAll(as: Iterable<A>): IO<RA, EA, boolean>;
-    shutdown: UIO<void>;
-    size: UIO<number>;
-    take: IO<RB | RB1, EB1 | EB, B>;
-    takeAll: IO<RB | RB1, EB | EB1, Conc<B>>;
-    loop(max: number, acc: Conc<B>): IO<RB | RB1, EB | EB1, Conc<B>>;
-    takeUpTo(n: number): IO<RB | RB1, EB | EB1, Conc<B>>;
-}
-/**
- * @tsplus fluent fncts.io.Queue filterOutputIO
- * @tsplus location "@fncts/io/Queue/api/filterOutputIO"
- */
-export declare function filterOutputIO_<RA, RB, EA, EB, A, B, RB1, EB1>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RB1, EB1, boolean>, __tsplusTrace?: string): PQueue<RA, RB | RB1, EA, EB | EB1, A, B>;
-/**
- * @tsplus fluent fncts.io.Queue filterOutput
- * @tsplus location "@fncts/io/Queue/api/filterOutputIO"
- */
-export declare function filterOutput_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, p: Predicate<B>, __tsplusTrace?: string): PQueue<RA, RB, EA, EB, A, B>;

package/Queue/api/operations.d.ts

@@ -1,82 +0,0 @@
-import { PQueue } from "@fncts/io/Queue/definition";
-import { UIO, IO } from "@fncts/io/IO/definition";
-/**
- * Waits until the queue is shutdown.
- * The `IO` returned by this method will not resume until the queue has been shutdown.
- * If the queue is already shutdown, the `IO` will resume right away.
- * @tsplus getter fncts.io.Queue awaitShutdown
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function awaitShutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<void>;
-/**
- * How many elements can hold in the queue
- * @tsplus getter fncts.io.Queue capacity
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function capacity<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): number;
-/**
- * `true` if `shutdown` has been called.
- * @tsplus getter fncts.io.Queue isShutdown
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function isShutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<boolean>;
-/**
- * Places one value in the queue.
- * @tsplus fluent fncts.io.Queue offer
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function offer_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, a: A, __tsplusTrace?: string): IO<RA, EA, boolean>;
-/**
- * For Bounded Queue: uses the `BackPressure` Strategy, places the values in the queue and always returns true.
- * If the queue has reached capacity, then
- * the fiber performing the `offerAll` will be suspended until there is room in
- * the queue.
- *
- * For Unbounded Queue:
- * Places all values in the queue and returns true.
- *
- * For Sliding Queue: uses `Sliding` Strategy
- * If there is room in the queue, it places the values otherwise it removes the old elements and
- * enqueues the new ones. Always returns true.
- *
- * For Dropping Queue: uses `Dropping` Strategy,
- * It places the values in the queue but if there is no room it will not enqueue them and return false.
- * @tsplus fluent fncts.io.Queue offerAll
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function offerAll_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, as: Iterable<A>, __tsplusTrace?: string): import("../../IO").IO<RA, EA, boolean>;
-/**
- * Interrupts any fibers that are suspended on `offer` or `take`.
- * Future calls to `offer*` and `take*` will be interrupted immediately.
- * @tsplus getter fncts.io.Queue shutdown
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function shutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): import("../../IO").UIO<void>;
-/**
- * Retrieves the size of the queue, which is equal to the number of elements
- * in the queue. This may be negative if fibers are suspended waiting for
- * elements to be added to the queue.
- * @tsplus getter fncts.io.Queue size
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function size<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): import("../../IO").UIO<number>;
-/**
- * Removes the oldest value in the queue. If the queue is empty, this will
- * return a computation that resumes when an item has been added to the queue.
- * @tsplus getter fncts.io.Queue take
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function take<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<RB, EB, B>;
-/**
- * Removes all the values in the queue and returns the list of the values. If the queue
- * is empty returns empty list.
- * @tsplus getter fncts.io.Queue takeAll
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function takeAll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): import("../../IO").IO<RB, EB, import("@fncts/base/collection/immutable/Conc").Conc<B>>;
-/**
- * Takes up to max number of values in the queue.
- * @tsplus fluent fncts.io.Queue takeAllUpTo
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function takeAllUpTo_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, n: number, __tsplusTrace?: string): import("../../IO").IO<RB, EB, import("@fncts/base/collection/immutable/Conc").Conc<B>>;

package/Queue/api/poll.d.ts

@@ -1,9 +0,0 @@
-import { PQueue } from "@fncts/io/Queue/definition";
-import { IO } from "@fncts/io/IO/definition";
-import { Maybe } from "@fncts/base/data/Maybe/definition";
-/**
- * Take the head option of values in the queue.
- * @tsplus getter fncts.io.Queue poll
- * @tsplus location "@fncts/io/Queue/api/poll"
- */
-export declare function poll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<RB, EB, Maybe<B>>;

package/Queue/api/takeBetween.d.ts

@@ -1,11 +0,0 @@
-import { PQueue } from "@fncts/io/Queue/definition";
-import { IO } from "@fncts/io/IO/definition";
-import { Conc } from "@fncts/base/collection/immutable/Conc";
-/**
- * Takes between min and max number of values from the queue. If there
- * is less than min items available, it'll block until the items are
- * collected.
- * @tsplus fluent fncts.io.Queue takeBetween
- * @tsplus location "@fncts/io/Queue/api/takeBetween"
- */
-export declare function takeBetween_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, min: number, max: number, __tsplusTrace?: string): IO<RB, EB, Conc<B>>;

package/Queue/api/zipWithIO.d.ts

@@ -1,44 +0,0 @@
-import { IO, UIO } from "@fncts/io/IO/definition";
-import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { PQueue } from "@fncts/io/Queue/definition";
-import { QueueInternal } from "@fncts/io/Queue/definition";
-export declare class ZipWithIO<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, R3, E3, D, A> extends QueueInternal<RA | RA1, RB | RB1 | R3, EA | EA1, E3 | EB | EB1, A1, D> {
-    readonly fa: QueueInternal<RA, RB, EA, EB, A, B>;
-    readonly fb: QueueInternal<RA1, RB1, EA1, EB1, A1, C>;
-    readonly f: (b: B, c: C) => IO<R3, E3, D>;
-    constructor(fa: QueueInternal<RA, RB, EA, EB, A, B>, fb: QueueInternal<RA1, RB1, EA1, EB1, A1, C>, f: (b: B, c: C) => IO<R3, E3, D>);
-    awaitShutdown: UIO<void>;
-    capacity: number;
-    isShutdown: UIO<boolean>;
-    offer(a: A1): IO<RA | RA1, EA1 | EA, boolean>;
-    offerAll(as: Iterable<A1>): IO<RA | RA1, EA1 | EA, boolean>;
-    shutdown: UIO<void>;
-    size: UIO<number>;
-    take: IO<RB | RB1 | R3, E3 | EB | EB1, D>;
-    takeAll: IO<RB | RB1 | R3, E3 | EB | EB1, Conc<D>>;
-    takeUpTo(max: number): IO<RB | RB1 | R3, E3 | EB | EB1, Conc<D>>;
-}
-/**
- * Creates a new queue from this queue and another. Offering to the composite queue
- * will broadcast the elements to both queues; taking from the composite queue
- * will dequeue elements from both queues and apply the function point-wise.
- *
- * Note that using queues with different strategies may result in surprising behavior.
- * For example, a dropping queue and a bounded queue composed together may apply `f`
- * to different elements.
- * @tsplus fluent fncts.io.Queue zipWithIO
- * @tsplus location "@fncts/io/Queue/api/zipWithIO"
- */
-export declare function zipWithIO_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, R3, E3, D, A>(fa: PQueue<RA, RB, EA, EB, A, B>, fb: PQueue<RA1, RB1, EA1, EB1, A1, C>, f: (b: B, c: C) => IO<R3, E3, D>, __tsplusTrace?: string): PQueue<RA | RA1, RB | RB1 | R3, EA | EA1, E3 | EB | EB1, A1, D>;
-/**
- * Like `zipWithM`, but uses a pure function.
- * @tsplus fluent fncts.io.Queue zipWith
- * @tsplus location "@fncts/io/Queue/api/zipWithIO"
- */
-export declare function zipWith_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, D, A>(queue: PQueue<RA, RB, EA, EB, A, B>, that: PQueue<RA1, RB1, EA1, EB1, A1, C>, f: (b: B, c: C) => D, __tsplusTrace?: string): PQueue<RA | RA1, RB | RB1, EA | EA1, EB | EB1, A1, D>;
-/**
- * Like `zipWith`, but tuples the elements instead of applying a function.
- * @tsplus fluent fncts.io.Queue zip
- * @tsplus location "@fncts/io/Queue/api/zipWithIO"
- */
-export declare function zip_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, A>(queue: PQueue<RA, RB, EA, EB, A, B>, that: PQueue<RA1, RB1, EA1, EB1, A1, C>, __tsplusTrace?: string): PQueue<RA | RA1, RB | RB1, EA | EA1, EB | EB1, A1, readonly [B, C]>;

package/Queue/api.d.ts

@@ -1,7 +0,0 @@
-export * from "./api/dimapIO.js";
-export * from "./api/filterInputIO.js";
-export * from "./api/filterOutputIO.js";
-export * from "./api/operations.js";
-export * from "./api/poll.js";
-export * from "./api/takeBetween.js";
-export * from "./api/zipWithIO.js";

package/Ref/Atomic/Atomic.d.ts

@@ -1,18 +0,0 @@
-import { Either } from "@fncts/base/data/Either/definition";
-import { UIO, IO } from "@fncts/io/IO/definition";
-import type { PRef } from "../definition.js";
-import { RefInternal } from "../definition.js";
-/**
- * @tsplus type fncts.io.Ref.Atomic
- */
-export declare class Atomic<A> extends RefInternal<never, never, never, never, A, A> {
-    private value;
-    readonly _tag = "Atomic";
-    constructor(value: A);
-    match<EC, ED, C, D>(_ea: (_: never) => EC, _eb: (_: never) => ED, ca: (_: C) => Either<EC, A>, bd: (_: A) => Either<ED, D>): PRef<never, never, EC, ED, C, D>;
-    matchAll<EC, ED, C, D>(_ea: (_: never) => EC, _eb: (_: never) => ED, _ec: (_: never) => EC, ca: (_: C) => (_: A) => Either<EC, A>, bd: (_: A) => Either<ED, D>): PRef<never, never, EC, ED, C, D>;
-    get unsafeGet(): A;
-    unsafeSet(a: A): void;
-    get get(): UIO<A>;
-    set(a: A): UIO<void>;
-}

package/Ref/Atomic/api.d.ts

@@ -1,53 +0,0 @@
-import { UIO } from "@fncts/io/IO/definition";
-import { Maybe } from "@fncts/base/data/Maybe/definition";
-import type { Atomic } from "./Atomic.js";
-/**
- * @tsplus fluent fncts.io.Ref.Atomic getAndSet
- * @tsplus location "@fncts/io/Ref/Atomic/api"
- */
-export declare function getAndSet<A>(self: Atomic<A>, a: A, __tsplusTrace?: string): UIO<A>;
-/**
- * @tsplus fluent fncts.io.Ref.Atomic getAndUpdate
- * @tsplus location "@fncts/io/Ref/Atomic/api"
- */
-export declare function getAndUpdate<A>(self: Atomic<A>, f: (a: A) => A, __tsplusTrace?: string): import("../../IO.js").UIO<A>;
-/**
- * @tsplus fluent fncts.io.Ref.Atomic getAndUpdateJust
- * @tsplus location "@fncts/io/Ref/Atomic/api"
- */
-export declare function getAndUpdateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): import("../../IO.js").UIO<A>;
-/**
- * @tsplus fluent fncts.io.Ref.Atomic modify
- * @tsplus location "@fncts/io/Ref/Atomic/api"
- */
-export declare function modify<A, B>(self: Atomic<A>, f: (a: A) => readonly [B, A], __tsplusTrace?: string): import("../../IO.js").UIO<B>;
-/**
- * @tsplus fluent fncts.io.Ref.Atomic modifyJust
- * @tsplus location "@fncts/io/Ref/Atomic/api"
- */
-export declare function modifyJust<A, B>(self: Atomic<A>, def: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): import("../../IO.js").UIO<B>;
-/**
- * @tsplus fluent fncts.io.Ref.Atomic update
- * @tsplus location "@fncts/io/Ref/Atomic/api"
- */
-export declare function update<A>(self: Atomic<A>, f: (a: A) => A, __tsplusTrace?: string): import("../../IO.js").UIO<void>;
-/**
- * @tsplus fluent fncts.io.Ref.Atomic updateAndGet
- * @tsplus location "@fncts/io/Ref/Atomic/api"
- */
-export declare function updateAndGet<A>(self: Atomic<A>, f: (a: A) => A, __tsplusTrace?: string): import("../../IO.js").UIO<A>;
-/**
- * @tsplus fluent fncts.io.Ref.Atomic updateJust
- * @tsplus location "@fncts/io/Ref/Atomic/api"
- */
-export declare function updateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): import("../../IO.js").UIO<void>;
-/**
- * @tsplus fluent fncts.io.Ref.Atomic updateJustAndGet
- * @tsplus location "@fncts/io/Ref/Atomic/api"
- */
-export declare function updateJustAndGet<A>(self: Atomic<A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): import("../../IO.js").UIO<A>;
-/**
- * @tsplus fluent fncts.io.Ref.Atomic unsafeUpdate
- * @tsplus location "@fncts/io/Ref/Atomic/api"
- */
-export declare function unsafeUpdate<A>(self: Atomic<A>, f: (a: A) => A, __tsplusTrace?: string): void;