@fncts/io 0.0.21 → 0.0.23

package/_src/Queue/definition.ts

@@ -1,41 +1,207 @@
-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";
+export const EnqueueTypeId = Symbol.for("fncts.io.Queue.Enqueue");
+export type EnqueueTypeId = typeof EnqueueTypeId;
 
-import { Conc } from "@fncts/base/collection/immutable/Conc";
+export const DequeueTypeId = Symbol.for("fncts.io.Queue.Dequeue");
+export type DequeueTypeId = typeof DequeueTypeId;
 
-import {
-  unsafeCompletePromise,
-  unsafeCompleteTakers,
-  unsafeOfferAll,
-  unsafePollAll,
-  unsafePollN,
-  unsafeRemove,
-} from "./internal.js";
+export const QueueVariance = Symbol.for("fncts.io.Queue.Variance");
+export type QueueVariance = typeof QueueVariance;
 
 export const QueueTypeId = Symbol.for("fncts.io.Queue");
 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 const Queue: QueueOps = {};
+
+/**
+ * @optimize remove
+ */
+export 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 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 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 function concrete<RA, RB, EA, EB, A, B>(
+  _: PQueueCommon<RA, RB, EA, EB, A, B>,
+): asserts _ is PQueueCommonInternal<RA, RB, EA, EB, A, B>;
+export function concrete(_: any): asserts _ is QueueInternal<any, any, any, any, any, any> {
+  //
+}
+
+/**
+ * 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 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     = QueueTypeId;
+  readonly [DequeueTypeId]: DequeueTypeId = DequeueTypeId;
+  readonly [EnqueueTypeId]: EnqueueTypeId = EnqueueTypeId;
+  declare [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.
+   */
+  export interface Dequeue<A> extends PDequeue<never, never, never, never, A, A> {}
+
+  /**
+   * A queue that can only be enqueued.
+   */
+  export 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.
    */
@@ -46,21 +212,19 @@ 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
@@ -78,206 +242,23 @@ 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 class Queue<A> implements Enqueue<A>, Dequeue<A> {
-  readonly [QueueTypeId]: typeof QueueTypeId = QueueTypeId;
-  declare _In: (_: A) => void;
-  declare _Out: (_: never) => A;
-  constructor(
-    readonly queue: MutableQueue<A>,
-    readonly takers: MutableQueue<Future<never, A>>,
-    readonly shutdownHook: Future<never, void>,
-    readonly shutdownFlag: AtomicBoolean,
-    readonly strategy: Strategy<A>,
-  ) {}
-
-  offer(this: this, a: A, __tsplusTrace?: string): UIO<boolean> {
-    return IO.defer(() => {
-      if (this.shutdownFlag.get) {
-        return IO.interrupt;
-      } else {
-        const taker = this.takers.dequeue(undefined);
-        if (taker != null) {
-          unsafeCompletePromise(taker, a);
-          return IO.succeedNow(true);
-        } else {
-          const succeeded = this.queue.enqueue(a);
-          if (succeeded) {
-            return IO.succeedNow(true);
-          } else {
-            return this.strategy.handleSurplus(Conc.single(a), this.queue, this.takers, this.shutdownFlag);
-          }
-        }
-      }
-    });
-  }
-
-  offerAll(this: this, as: Iterable<A>, __tsplusTrace?: string): UIO<boolean> {
-    const arr = Conc.from(as);
-    return IO.defer(() => {
-      if (this.shutdownFlag.get) {
-        return IO.interrupt;
-      } else {
-        const pTakers                = this.queue.isEmpty ? unsafePollN(this.takers, arr.length) : Conc.empty<Future<never, A>>();
-        const [forTakers, remaining] = arr.splitAt(pTakers.length);
-        pTakers.zip(forTakers).forEach(([taker, item]) => {
-          unsafeCompletePromise(taker, item);
-        });
-        if (remaining.length === 0) {
-          return IO.succeedNow(true);
-        }
-        const surplus = unsafeOfferAll(this.queue, remaining);
-        unsafeCompleteTakers(this.strategy, this.queue, this.takers);
-        if (surplus.length === 0) {
-          return IO.succeedNow(true);
-        } else {
-          return this.strategy.handleSurplus(surplus, this.queue, this.takers, this.shutdownFlag);
-        }
-      }
-    });
-  }
-
-  get capacity(): number {
-    return this.queue.capacity;
-  }
-
-  size: UIO<number> = IO.defer(() => {
-    if (this.shutdownFlag.get) {
-      return IO.interrupt;
-    } else {
-      return IO.succeedNow(this.queue.size - this.takers.size + this.strategy.surplusSize);
-    }
-  });
-
-  awaitShutdown = this.shutdownHook.await;
-
-  isShutdown: UIO<boolean> = IO(this.shutdownFlag.get);
-
-  shutdown: UIO<void> = IO.deferWith((_, id) => {
-    this.shutdownFlag.set(true);
-    return IO.foreachDiscardC(unsafePollAll(this.takers), (fiber) => fiber.interruptAs(id))
-      .flatMap(() => this.strategy.shutdown)
-      .whenIO(this.shutdownHook.succeed(undefined));
-  }).uninterruptible;
-
-  isFull: UIO<boolean> = this.size.map((size) => size === this.capacity);
-
-  isEmpty: UIO<boolean> = this.size.map((size) => size === 0);
-
-  take: UIO<A> = IO.deferWith((_, fiberId) => {
-    if (this.shutdownFlag.get) {
-      return IO.interrupt;
-    }
-    const item = this.queue.dequeue(undefined);
-    if (item != null) {
-      this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
-      return IO.succeedNow(item);
-    } else {
-      const p = Future.unsafeMake<never, A>(fiberId);
-      return IO.defer(() => {
-        this.takers.enqueue(p);
-        unsafeCompleteTakers(this.strategy, this.queue, this.takers);
-        if (this.shutdownFlag.get) {
-          return IO.interrupt;
-        } else {
-          return p.await;
-        }
-      }).onInterrupt(() => IO.succeed(unsafeRemove(this.takers, p)));
-    }
-  });
-
-  takeAll: UIO<Conc<A>> = IO.defer(() => {
-    if (this.shutdownFlag.get) {
-      return IO.interrupt;
-    } else {
-      return IO.succeed(() => {
-        const as = unsafePollAll(this.queue);
-        this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
-        return as;
-      });
-    }
-  });
-
-  takeUpTo(this: this, max: number, __tsplusTrace?: string): UIO<Conc<A>> {
-    return IO.defer(() => {
-      if (this.shutdownFlag.get) {
-        return IO.interrupt;
-      } else {
-        return IO.succeed(() => {
-          const as = unsafePollN(this.queue, max);
-          this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
-          return as;
-        });
-      }
-    });
-  }
-
-  private takeRemainder(min: number, max: number, acc: Conc<A>, __tsplusTrace?: string): UIO<Conc<A>> {
-    if (max < min) return IO.succeedNow(acc);
-    else {
-      return this.takeUpTo(max).flatMap((bs) => {
-        const remaining = min - bs.length;
-        if (remaining === 1) {
-          return this.take.map((b) => acc.concat(bs).append(b));
-        } else if (remaining > 1) {
-          return this.take.flatMap((b) => this.takeRemainder(remaining - 1, max - bs.length, acc.concat(bs).append(b)));
-        } else {
-          return IO.succeedNow(acc.concat(bs));
-        }
-      });
-    }
-  }
-
-  takeBetween(this: this, min: number, max: number, __tsplusTrace?: string): UIO<Conc<A>> {
-    return this.takeRemainder(min, max, Conc());
-  }
-
-  takeN(this: this, n: number, __tsplusTrace?: string): UIO<Conc<A>> {
-    return this.takeBetween(n, n);
-  }
-
-  poll: UIO<Maybe<A>> = this.takeUpTo(1).map((_) => _.head);
+  takeUpTo(n: number, __tsplusTrace?: string): IO<RB, EB, Conc<B>>;
 }

package/_src/Queue/internal.ts

@@ -1,6 +1,164 @@
 import type { MutableQueue } from "@fncts/io/internal/MutableQueue";
 import type { Strategy } from "@fncts/io/Queue/strategy";
 
+import { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
+import { unbounded } from "@fncts/io/internal/MutableQueue";
+import { QueueInternal } from "@fncts/io/Queue/definition";
+
+class UnsafeQueue<A> extends QueueInternal<never, never, never, never, A, A> {
+  constructor(
+    readonly queue: MutableQueue<A>,
+    readonly takers: MutableQueue<Future<never, A>>,
+    readonly shutdownHook: Future<never, void>,
+    readonly shutdownFlag: AtomicBoolean,
+    readonly strategy: Strategy<A>,
+  ) {
+    super();
+  }
+
+  awaitShutdown: UIO<void> = this.shutdownHook.await;
+
+  capacity: number = this.queue.capacity;
+
+  isShutdown: UIO<boolean> = IO.succeed(this.shutdownFlag.get);
+
+  offer(a: A, __tsplusTrace?: string): IO<never, never, boolean> {
+    return IO.defer(() => {
+      if (this.shutdownFlag.get) {
+        return IO.interrupt;
+      } else {
+        const taker = this.takers.dequeue(undefined);
+
+        if (taker != null) {
+          unsafeCompletePromise(taker, a);
+          return IO.succeedNow(true);
+        } else {
+          const succeeded = this.queue.enqueue(a);
+
+          if (succeeded) {
+            return IO.succeedNow(true);
+          } else {
+            return this.strategy.handleSurplus(Conc.single(a), this.queue, this.takers, this.shutdownFlag);
+          }
+        }
+      }
+    });
+  }
+
+  offerAll(as: Iterable<A>, __tsplusTrace?: string): IO<never, never, boolean> {
+    const arr = Conc.from(as);
+    return IO.defer(() => {
+      if (this.shutdownFlag.get) {
+        return IO.interrupt;
+      } else {
+        const pTakers                = this.queue.isEmpty ? unsafeDequeueN(this.takers, arr.length) : Conc.empty<Future<never, A>>();
+        const [forTakers, remaining] = arr.splitAt(pTakers.length);
+        pTakers.zip(forTakers).forEach(([taker, item]) => {
+          unsafeCompletePromise(taker, item);
+        });
+
+        if (remaining.length === 0) {
+          return IO.succeedNow(true);
+        }
+
+        const surplus = unsafeOfferAll(this.queue, remaining);
+
+        unsafeCompleteTakers(this.strategy, this.queue, this.takers);
+
+        if (surplus.length === 0) {
+          return IO.succeedNow(true);
+        } else {
+          return this.strategy.handleSurplus(surplus, this.queue, this.takers, this.shutdownFlag);
+        }
+      }
+    });
+  }
+
+  shutdown: UIO<void> = IO.fiberId.flatMap((id) => {
+    this.shutdownFlag.set(true);
+
+    return IO.foreachConcurrent(unsafePollAll(this.takers), (fiber) => fiber.interruptAs(id))
+      .flatMap(() => this.strategy.shutdown)
+      .whenIO(this.shutdownHook.succeed(undefined));
+  });
+
+  size: UIO<number> = IO.defer(() => {
+    if (this.shutdownFlag.get) {
+      return IO.interrupt;
+    } else {
+      return IO.succeedNow(this.queue.size - this.takers.size + this.strategy.surplusSize);
+    }
+  });
+
+  take: IO<never, never, A> = IO.fiberId.flatMap((fiberId) =>
+    IO.defer(() => {
+      if (this.shutdownFlag.get) {
+        return IO.interrupt;
+      }
+
+      const item = this.queue.dequeue(undefined);
+
+      if (item != null) {
+        this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
+        return IO.succeedNow(item);
+      } else {
+        const p = Future.unsafeMake<never, A>(fiberId);
+
+        return IO.defer(() => {
+          this.takers.enqueue(p);
+          unsafeCompleteTakers(this.strategy, this.queue, this.takers);
+          if (this.shutdownFlag.get) {
+            return IO.interrupt;
+          } else {
+            return p.await;
+          }
+        }).onInterrupt(() => IO.succeed(unsafeRemove(this.takers, p)));
+      }
+    }),
+  );
+
+  takeAll: IO<never, never, Conc<A>> = IO.defer(() => {
+    if (this.shutdownFlag.get) {
+      return IO.interrupt;
+    } else {
+      return IO.succeed(() => {
+        const as = unsafePollAll(this.queue);
+        this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
+        return as;
+      });
+    }
+  });
+
+  takeUpTo(max: number, __tsplusTrace?: string): IO<never, never, Conc<A>> {
+    return IO.defer(() => {
+      if (this.shutdownFlag.get) {
+        return IO.interrupt;
+      } else {
+        return IO.succeed(() => {
+          const as = unsafeDequeueN(this.queue, max);
+          this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
+          return as;
+        });
+      }
+    });
+  }
+}
+
+function unsafeCreateQueue<A>(
+  queue: MutableQueue<A>,
+  takers: MutableQueue<Future<never, A>>,
+  shutdownHook: Future<never, void>,
+  shutdownFlag: AtomicBoolean,
+  strategy: Strategy<A>,
+): Queue<A> {
+  return new UnsafeQueue(queue, takers, shutdownHook, shutdownFlag, strategy);
+}
+
+export function unsafeMakeQueue<A>(strategy: Strategy<A>): (queue: MutableQueue<A>) => IO<never, never, Queue<A>> {
+  return (queue) =>
+    Future.make<never, void>().map((p) => unsafeCreateQueue(queue, unbounded(), p, new AtomicBoolean(false), strategy));
+}
+
 export function unsafeOfferAll<A>(q: MutableQueue<A>, as: Conc<A>): Conc<A> {
   let bs = as;
   while (bs.length > 0) {
@@ -16,7 +174,6 @@ export function unsafeOfferAll<A>(q: MutableQueue<A>, as: Conc<A>): Conc<A> {
 export function unsafePollAll<A>(q: MutableQueue<A>): Conc<A> {
   let as = Conc.empty<A>();
   while (!q.isEmpty) {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     as = as.append(q.dequeue(undefined)!);
   }
   return as;
@@ -30,7 +187,7 @@ export function unsafeRemove<A>(q: MutableQueue<A>, a: A) {
   return unsafeOfferAll(q, unsafePollAll(q)).filter((b) => a !== b);
 }
 
-export function unsafePollN<A>(q: MutableQueue<A>, max: number): Conc<A> {
+function unsafeDequeueN<A>(q: MutableQueue<A>, max: number): Conc<A> {
   let j  = 0;
   let as = Conc.empty<A>();
   while (j < max) {

package/_src/Queue/strategy.ts

@@ -33,9 +33,9 @@ export class BackPressureStrategy<A> implements Strategy<A> {
     isShutdown: AtomicBoolean,
     __tsplusTrace?: string,
   ): UIO<boolean> {
-    return IO.descriptorWith((d) =>
+    return IO.fiberId.flatMap((fiberId) =>
       IO.defer(() => {
-        const p = Future.unsafeMake<never, boolean>(d.id);
+        const p = Future.unsafeMake<never, boolean>(fiberId);
         return IO.defer(() => {
           this.unsafeOffer(as, p);
           this.unsafeOnQueueEmptySpace(queue, takers);
@@ -95,7 +95,7 @@ export class BackPressureStrategy<A> implements Strategy<A> {
     return Do((_) => {
       const fiberId = _(IO.fiberId);
       const putters = _(IO.succeed(unsafePollAll(self.putters)));
-      _(IO.foreachC(putters, ([, p, lastItem]) => (lastItem ? p.interruptAs(fiberId).asUnit : IO.unit)));
+      _(IO.foreachConcurrent(putters, ([, p, lastItem]) => (lastItem ? p.interruptAs(fiberId).asUnit : IO.unit)));
     });
   }
 

package/_src/Queue.ts

@@ -1,5 +1,7 @@
-// codegen:start { preset: barrel, include: Queue/*.ts, exclude: Queue/internal.ts }
+// codegen:start { preset: barrel, include: Queue/*.ts }
+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";
 // codegen:end