@fncts/io 0.0.21 → 0.0.23

package/Queue/api/operations.d.ts

@@ -0,0 +1,83 @@
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { PQueue } from "@fncts/io/Queue/definition";
+import type { PDequeue, PEnqueue, PQueueCommon } from "@fncts/io/Queue/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: PQueueCommon<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: PQueueCommon<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: PQueueCommon<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<boolean>;
+/**
+ * Places one value in the queue.
+ * @tsplus pipeable fncts.io.Queue offer
+ * @tsplus location "@fncts/io/Queue/api/operations"
+ */
+export declare function offer<A>(a: A, __tsplusTrace?: string): <RA, RB, EA, EB, B>(queue: PEnqueue<RA, RB, EA, EB, A, B>) => import("../../IO").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 pipeable fncts.io.Queue offerAll
+ * @tsplus location "@fncts/io/Queue/api/operations"
+ */
+export declare function offerAll<A>(as: Iterable<A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(queue: PEnqueue<RA, RB, EA, EB, A, B>) => 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: PQueueCommon<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: PQueueCommon<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: PDequeue<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: PDequeue<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 pipeable fncts.io.Queue takeAllUpTo
+ * @tsplus location "@fncts/io/Queue/api/operations"
+ */
+export declare function takeAllUpTo(n: number, __tsplusTrace?: string): <RA, RB, EA, EB, A, B>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("../../IO").IO<RB, EB, import("@fncts/base/collection/immutable/Conc").Conc<B>>;

package/Queue/api/poll.d.ts

@@ -0,0 +1,9 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import type { PDequeue } from "@fncts/io/Queue/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: PDequeue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<RB, EB, Maybe<B>>;

package/Queue/api/takeBetween.d.ts

@@ -0,0 +1,11 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { PDequeue } from "@fncts/io/Queue/definition";
+/**
+ * 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 pipeable fncts.io.Queue takeBetween
+ * @tsplus location "@fncts/io/Queue/api/takeBetween"
+ */
+export declare function takeBetween(min: number, max: number, __tsplusTrace?: string): <RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A, B>) => import("../../IO").IO<RB, EB, import("@fncts/base/collection/immutable/Conc").Conc<B>>;

package/Queue/api/zipWithIO.d.ts

@@ -0,0 +1,27 @@
+import { IO, UIO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { PQueue } from "@fncts/io/Queue/definition";
+/**
+ * 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 pipeable fncts.io.Queue zipWithIO
+ * @tsplus location "@fncts/io/Queue/api/zipWithIO"
+ */
+export declare function zipWithIO<A, B, RA1, RB1, EA1, EB1, A1 extends A, B1, R3, E3, D>(fb: PQueue<RA1, RB1, EA1, EB1, A1, B1>, f: (b: B, c: B1) => IO<R3, E3, D>, __tsplusTrace?: string): <RA, RB, EA, EB>(fa: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA1 | RA, RB1 | R3 | RB, EA1 | EA, EB1 | E3 | EB, A1, D>;
+/**
+ * Like `zipWithIO`, but uses a pure function.
+ * @tsplus pipeable fncts.io.Queue zipWith
+ * @tsplus location "@fncts/io/Queue/api/zipWithIO"
+ */
+export declare function zipWith<A, B, RA1, RB1, EA1, EB1, A1 extends A, B1, C>(that: PQueue<RA1, RB1, EA1, EB1, A1, B1>, f: (a: B, b: B1) => C, __tsplusTrace?: string): <RA, RB, EA, EB>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA1 | RA, RB1 | RB, EA1 | EA, EB1 | EB, A1, C>;
+/**
+ * Like `zipWith`, but tuples the elements instead of applying a function.
+ * @tsplus pipeable fncts.io.Queue zip
+ * @tsplus location "@fncts/io/Queue/api/zipWithIO"
+ */
+export declare function zip<A, B, RA1, RB1, EA1, EB1, A1 extends A, B1>(that: PQueue<RA1, RB1, EA1, EB1, A1, B1>, __tsplusTrace?: string): <RA, RB, EA, EB>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA1 | RA, RB1 | RB, EA1 | EA, EB1 | EB, A1, readonly [B, B1]>;

package/Queue/api.d.ts

@@ -0,0 +1,7 @@
+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/Queue/constructors.d.ts

@@ -1,6 +1,5 @@
 import { UIO } from "@fncts/io/IO/definition";
-import { Future } from "@fncts/io/Future";
-import { Queue } from "@fncts/io/Queue/definition";
+import type { Queue } from "@fncts/io/Queue/definition";
 /**
  * @tsplus static fncts.io.QueueOps makeSliding
  * @tsplus location "@fncts/io/Queue/constructors"

package/Queue/definition.d.ts

@@ -1,31 +1,186 @@
-import { Future } from "@fncts/io/Future";
-import { IO } from "@fncts/io/IO/definition";
-import type { MutableQueue } from "../internal/MutableQueue.js";
-import type { UIO } from "../IO.js";
-import type { Strategy } from "./strategy.js";
-import type { Maybe } from "@fncts/base/data/Maybe";
-import type { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
+import { UIO, IO } from "@fncts/io/IO/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
+export declare const EnqueueTypeId: unique symbol;
+export type EnqueueTypeId = typeof EnqueueTypeId;
+export declare const DequeueTypeId: unique symbol;
+export type DequeueTypeId = typeof DequeueTypeId;
+export declare const QueueVariance: unique symbol;
+export type QueueVariance = typeof QueueVariance;
 export declare const QueueTypeId: unique symbol;
 export type QueueTypeId = typeof QueueTypeId;
-export interface CommonQueue {
+/**
+ * A `PQueue<RA, RB, EA, EB, A, B>` is a lightweight, asynchronous queue into which values of
+ * type `A` can be enqueued and of which elements of type `B` can be dequeued. The queue's
+ * enqueueing operations may utilize an environment of type `RA` and may fail with errors of
+ * type `EA`. The dequeueing operations may utilize an environment of type `RB` and may fail
+ * with errors of type `EB`.
+ *
+ * @tsplus type fncts.io.Queue
+ */
+export interface PQueue<RA, RB, EA, EB, A, B> extends PEnqueue<RA, RB, EA, EB, A, B>, PDequeue<RA, RB, EA, EB, A, B> {
+}
+/**
+ * @tsplus type fncts.io.Queue
+ */
+export interface PQueueCommon<RA, RB, EA, EB, A, B> {
+    readonly [QueueTypeId]: QueueTypeId;
+    readonly [QueueVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _RB: (_: never) => RB;
+        readonly _EA: (_: never) => EA;
+        readonly _EB: (_: never) => EB;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => B;
+    };
+}
+/**
+ * @tsplus type fncts.io.Queue
+ * @tsplus type fncts.io.Queue.Enqueue
+ */
+export interface PEnqueue<RA, RB, EA, EB, A, B> extends PQueueCommon<RA, RB, EA, EB, A, B> {
+    readonly [EnqueueTypeId]: EnqueueTypeId;
+}
+/**
+ * @tsplus type fncts.io.Queue
+ * @tsplus type fncts.io.Queue.Dequeue
+ */
+export interface PDequeue<RA, RB, EA, EB, A, B> extends PQueueCommon<RA, RB, EA, EB, A, B> {
+    readonly [DequeueTypeId]: DequeueTypeId;
+}
+/**
+ * @tsplus type fncts.io.QueueOps
+ */
+export interface QueueOps {
+}
+export declare const Queue: QueueOps;
+/**
+ * @optimize remove
+ */
+export declare function concrete<RA, RB, EA, EB, A, B>(_: PQueue<RA, RB, EA, EB, A, B>): asserts _ is QueueInternal<RA, RB, EA, EB, A, B>;
+export declare function concrete<RA, RB, EA, EB, A, B>(_: PDequeue<RA, RB, EA, EB, A, B>): asserts _ is PDequeueInternal<RA, RB, EA, EB, A, B>;
+export declare function concrete<RA, RB, EA, EB, A, B>(_: PEnqueue<RA, RB, EA, EB, A, B>): asserts _ is PEnqueueInternal<RA, RB, EA, EB, A, B>;
+export declare function concrete<RA, RB, EA, EB, A, B>(_: PQueueCommon<RA, RB, EA, EB, A, B>): asserts _ is PQueueCommonInternal<RA, RB, EA, EB, A, B>;
+/**
+ * A `Queue<RA, RB, EA, EB, A, B>` is a lightweight, asynchronous queue into which values of
+ * type `A` can be enqueued and of which elements of type `B` can be dequeued. The queue's
+ * enqueueing operations may utilize an environment of type `RA` and may fail with errors of
+ * type `EA`. The dequeueing operations may utilize an environment of type `RB` and may fail
+ * with errors of type `EB`.
+ */
+export declare abstract class QueueInternal<RA, RB, EA, EB, A, B> implements PQueue<RA, RB, EA, EB, A, B>, PEnqueue<RA, RB, EA, EB, A, B>, PDequeue<RA, RB, EA, EB, A, B> {
     readonly [QueueTypeId]: QueueTypeId;
+    readonly [DequeueTypeId]: DequeueTypeId;
+    readonly [EnqueueTypeId]: EnqueueTypeId;
+    [QueueVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _RB: (_: never) => RB;
+        readonly _EA: (_: never) => EA;
+        readonly _EB: (_: never) => EB;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => B;
+    };
+    /**
+     * 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.
+     */
+    abstract readonly awaitShutdown: UIO<void>;
     /**
      * How many elements can hold in the queue
      */
-    get capacity(): number;
+    abstract readonly capacity: number;
+    /**
+     * `true` if `shutdown` has been called.
+     */
+    abstract readonly isShutdown: UIO<boolean>;
+    /**
+     * Places one value in the queue.
+     */
+    abstract offer(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.
+     *
+     */
+    abstract offerAll(as: Iterable<A>, __tsplusTrace?: string): IO<RA, EA, boolean>;
+    /**
+     * Interrupts any fibers that are suspended on `offer` or `take`.
+     * Future calls to `offer*` and `take*` will be interrupted immediately.
+     */
+    abstract readonly shutdown: 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.
      */
-    readonly size: UIO<number>;
+    abstract readonly size: 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.
+     */
+    abstract readonly take: 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.
+     */
+    abstract readonly takeAll: IO<RB, EB, Conc<B>>;
+    /**
+     * Takes up to max number of values in the queue.
+     */
+    abstract takeUpTo(n: number, __tsplusTrace?: string): IO<RB, EB, Conc<B>>;
+}
+/**
+ * A `Queue<A>` is a lightweight, asynchronous queue into which
+ * values of type `A` can be enqueued and dequeued.
+ *
+ * @tsplus type fncts.io.Queue
+ */
+export interface Queue<A> extends PQueue<never, never, never, never, A, A> {
+}
+export declare namespace Queue {
+    /**
+     * A queue that can only be dequeued.
+     */
+    interface Dequeue<A> extends PDequeue<never, never, never, never, A, A> {
+    }
+    /**
+     * A queue that can only be enqueued.
+     */
+    interface Enqueue<A> extends PEnqueue<never, never, never, never, A, A> {
+    }
+}
+export interface PQueueCommonInternal<RA, RB, EA, EB, A, B> {
+    readonly [QueueTypeId]: QueueTypeId;
+    readonly [QueueVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _RB: (_: never) => RB;
+        readonly _EA: (_: never) => EA;
+        readonly _EB: (_: never) => EB;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => B;
+    };
     /**
      * 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.
      */
     readonly awaitShutdown: UIO<void>;
+    /**
+     * How many elements can hold in the queue
+     */
+    readonly capacity: number;
     /**
      * `true` if `shutdown` has been called.
      */
@@ -36,20 +191,18 @@ export interface CommonQueue {
      */
     readonly shutdown: UIO<void>;
     /**
-     * Checks whether the queue is currently full.
-     */
-    readonly isFull: UIO<boolean>;
-    /**
-     * Checks whether the queue is currently empty.
+     * 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.
      */
-    readonly isEmpty: UIO<boolean>;
+    readonly size: UIO<number>;
 }
-export interface Enqueue<in A> extends CommonQueue {
-    readonly _In: (_: A) => void;
+export interface PEnqueueInternal<RA, RB, EA, EB, A, B> extends PQueueCommonInternal<RA, RB, EA, EB, A, B> {
+    readonly [EnqueueTypeId]: EnqueueTypeId;
     /**
      * Places one value in the queue.
      */
-    offer(this: this, a: A, __tsplusTrace?: string): UIO<boolean>;
+    offer(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
@@ -67,72 +220,22 @@ export interface Enqueue<in A> extends CommonQueue {
      * It places the values in the queue but if there is no room it will not enqueue them and return false.
      *
      */
-    offerAll(this: this, as: Iterable<A>, __tsplusTrace?: string): UIO<boolean>;
+    offerAll(as: Iterable<A>, __tsplusTrace?: string): IO<RA, EA, boolean>;
 }
-export interface Dequeue<out A> extends CommonQueue {
-    readonly _Out: (_: never) => A;
+export interface PDequeueInternal<RA, RB, EA, EB, A, B> extends PQueueCommonInternal<RA, RB, EA, EB, A, B> {
+    readonly [DequeueTypeId]: DequeueTypeId;
     /**
      * 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.
      */
-    readonly take: UIO<A>;
+    readonly take: 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.
      */
-    readonly takeAll: UIO<Conc<A>>;
+    readonly takeAll: IO<RB, EB, Conc<B>>;
     /**
      * Takes up to max number of values in the queue.
      */
-    takeUpTo(this: this, max: number, __tsplusTrace?: string): UIO<Conc<A>>;
-    /**
-     * Takes the specified number of elements from the queue. If there are fewer
-     * than the specified number of elements available, it suspends until they
-     * become available.
-     */
-    takeN(this: this, n: number, __tsplusTrace?: string): UIO<Conc<A>>;
-    /**
-     * Takes a number of elements from the queue between the specified minimum and
-     * maximum. If there are fewer than the minimum number of elements available,
-     * suspends until at least the minimum number of elements have been collected.
-     */
-    takeBetween(this: this, min: number, max: number, __tsplusTrace?: string): UIO<Conc<A>>;
-    /**
-     * Take the head option of values in the queue.
-     */
-    readonly poll: UIO<Maybe<A>>;
-}
-/**
- * A `Queue` is a lightweight, asynchronous queue into which values can be
- * enqueued and of which elements can be dequeued.
- *
- * @tsplus type fncts.io.Queue
- * @tsplus companion fncts.io.QueueOps
- */
-export declare class Queue<A> implements Enqueue<A>, Dequeue<A> {
-    readonly queue: MutableQueue<A>;
-    readonly takers: MutableQueue<Future<never, A>>;
-    readonly shutdownHook: Future<never, void>;
-    readonly shutdownFlag: AtomicBoolean;
-    readonly strategy: Strategy<A>;
-    readonly [QueueTypeId]: typeof QueueTypeId;
-    _In: (_: A) => void;
-    _Out: (_: never) => A;
-    constructor(queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>, shutdownHook: Future<never, void>, shutdownFlag: AtomicBoolean, strategy: Strategy<A>);
-    offer(this: this, a: A, __tsplusTrace?: string): UIO<boolean>;
-    offerAll(this: this, as: Iterable<A>, __tsplusTrace?: string): UIO<boolean>;
-    get capacity(): number;
-    size: UIO<number>;
-    awaitShutdown: import("../IO.js").IO<never, never, void>;
-    isShutdown: UIO<boolean>;
-    shutdown: UIO<void>;
-    isFull: UIO<boolean>;
-    isEmpty: UIO<boolean>;
-    take: UIO<A>;
-    takeAll: UIO<Conc<A>>;
-    takeUpTo(this: this, max: number, __tsplusTrace?: string): UIO<Conc<A>>;
-    private takeRemainder;
-    takeBetween(this: this, min: number, max: number, __tsplusTrace?: string): UIO<Conc<A>>;
-    takeN(this: this, n: number, __tsplusTrace?: string): UIO<Conc<A>>;
-    poll: UIO<Maybe<A>>;
+    takeUpTo(n: number, __tsplusTrace?: string): IO<RB, EB, Conc<B>>;
 }

package/Queue/internal.d.ts

@@ -1,10 +1,12 @@
-import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { Future } from "@fncts/io/Future";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Queue } from "@fncts/io/Queue/definition";
 import type { MutableQueue } from "@fncts/io/internal/MutableQueue";
 import type { Strategy } from "@fncts/io/Queue/strategy";
+export declare function unsafeMakeQueue<A>(strategy: Strategy<A>): (queue: MutableQueue<A>) => IO<never, never, Queue<A>>;
 export declare function unsafeOfferAll<A>(q: MutableQueue<A>, as: Conc<A>): Conc<A>;
 export declare function unsafePollAll<A>(q: MutableQueue<A>): Conc<A>;
 export declare function unsafeCompletePromise<A>(p: Future<never, A>, a: A): void;
 export declare function unsafeRemove<A>(q: MutableQueue<A>, a: A): import("@fncts/base/collection/immutable/Conc").Conc<A>;
-export declare function unsafePollN<A>(q: MutableQueue<A>, max: number): Conc<A>;
 export declare function unsafeCompleteTakers<A>(strategy: Strategy<A>, queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>): void;

package/Queue.d.ts

@@ -1,3 +1,5 @@
+export * from "./Queue/api.js";
 export * from "./Queue/constructors.js";
 export * from "./Queue/definition.js";
+export * from "./Queue/internal.js";
 export * from "./Queue/strategy.js";

package/Ref/Atomic.d.ts

@@ -1,15 +1,22 @@
-import { UIO, IO } from "@fncts/io/IO/definition";
-import { Ref } from "./definition.js";
+import { Either } from "@fncts/base/data/Either/definition";
+import { UIO } from "@fncts/io/IO/definition";
+import type { PRef } from "./definition.js";
+import type { AtomicReference } from "@fncts/base/internal/AtomicReference";
+import { RefInternal } from "./definition.js";
+export declare const AtomicTypeId: unique symbol;
+export type AtomicTypeId = typeof AtomicTypeId;
 /**
  * @tsplus type fncts.io.Ref.Atomic
  */
-export declare class Atomic<A> extends Ref<A> {
-    private value;
-    readonly _tag = "Atomic";
-    constructor(value: A);
+export declare class Atomic<A> extends RefInternal<never, never, never, never, A, A> {
+    readonly value: AtomicReference<A>;
+    readonly [AtomicTypeId]: AtomicTypeId;
+    constructor(value: AtomicReference<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: UIO<A>;
+    get get(): UIO<A>;
     set(a: A): UIO<void>;
-    modify<B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): import("../IO.js").UIO<B>;
+    modify<B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string | undefined): UIO<B>;
 }

package/Ref/Derived.d.ts

@@ -0,0 +1,18 @@
+import { Either } from "@fncts/base/data/Either/definition";
+import { FIO } from "@fncts/io/IO/definition";
+import type { Atomic } from "./Atomic.js";
+import type { PRef } from "./definition.js";
+import { IO } from "@fncts/io/IO";
+import { RefInternal } from "./definition.js";
+export declare const DerivedTypeId: unique symbol;
+export type DerivedTypeId = typeof DerivedTypeId;
+export declare class Derived<EA, EB, A, B> extends RefInternal<never, never, EA, EB, A, B> {
+    readonly use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => Either<EA, S>) => X) => X;
+    readonly [DerivedTypeId]: DerivedTypeId;
+    constructor(use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => Either<EA, S>) => X) => X);
+    match<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<never, never, EC, ED, C, D>;
+    matchAll<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<never, never, EC, ED, C, D>;
+    get get(): FIO<EB, B>;
+    set(a: A): FIO<EA, void>;
+    modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): IO<never, EA | EB, C>;
+}

package/Ref/DerivedAll.d.ts

@@ -0,0 +1,18 @@
+import { Either } from "@fncts/base/data/Either/definition";
+import { FIO } from "@fncts/io/IO/definition";
+import type { Atomic } from "./Atomic.js";
+import type { PRef } from "./definition.js";
+import { IO } from "@fncts/io/IO";
+import { RefInternal } from "./definition.js";
+export declare const DerivedAllTypeId: unique symbol;
+export type DerivedAllTypeId = typeof DerivedAllTypeId;
+export declare class DerivedAll<EA, EB, A, B> extends RefInternal<never, never, EA, EB, A, B> {
+    readonly use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => (s: S) => Either<EA, S>) => X) => X;
+    readonly [DerivedAllTypeId]: DerivedAllTypeId;
+    constructor(use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => (s: S) => Either<EA, S>) => X) => X);
+    match<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<never, never, EC, ED, C, D>;
+    matchAll<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<never, never, EC, ED, C, D>;
+    get get(): FIO<EB, B>;
+    set(a: A): FIO<EA, void>;
+    modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): IO<never, EA | EB, C>;
+}