@fncts/io 0.0.1

package/_src/Queue/api/zipWithIO.ts

@@ -0,0 +1,96 @@
+import { tuple } from "@fncts/base/data/function";
+import { concrete, QueueInternal } from "@fncts/io/Queue/definition";
+
+export 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
+> {
+  constructor(
+    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>,
+  ) {
+    super();
+  }
+
+  awaitShutdown: UIO<void> = this.fa.awaitShutdown.flatMap(() => this.fb.awaitShutdown);
+
+  capacity: number = Math.min(this.fa.capacity, this.fb.capacity);
+
+  isShutdown: UIO<boolean> = this.fa.isShutdown;
+
+  offer(a: A1): IO<RA & RA1, EA1 | EA, boolean> {
+    return this.fa.offer(a).zipWithC(this.fb.offer(a), (x, y) => x && y);
+  }
+
+  offerAll(as: Iterable<A1>): IO<RA & RA1, EA1 | EA, boolean> {
+    return this.fa.offerAll(as).zipWithC(this.fb.offerAll(as), (x, y) => x && y);
+  }
+
+  shutdown: UIO<void> = this.fa.shutdown.zipWithC(this.fb.shutdown, () => undefined);
+
+  size: UIO<number> = this.fa.size.zipWithC(this.fb.size, (x, y) => Math.max(x, y));
+
+  take: IO<RB & RB1 & R3, E3 | EB | EB1, D> = this.fa.take.zipC(this.fb.take).flatMap(([b, c]) => this.f(b, c));
+
+  takeAll: IO<RB & RB1 & R3, E3 | EB | EB1, Conc<D>> = this.fa.takeAll
+    .zipC(this.fb.takeAll)
+    .flatMap(([bs, cs]) => IO.foreach(bs.zip(cs), ([b, c]) => this.f(b, c)));
+
+  takeUpTo(max: number): IO<RB & RB1 & R3, E3 | EB | EB1, Conc<D>> {
+    return this.fa
+      .takeUpTo(max)
+      .zipC(this.fb.takeUpTo(max))
+      .flatMap(([bs, cs]) => IO.foreach(bs.zip(cs), ([b, c]) => this.f(b, c)));
+  }
+}
+
+/**
+ * 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
+ */
+export 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>,
+): PQueue<RA & RA1, RB & RB1 & R3, EA | EA1, E3 | EB | EB1, A1, D> {
+  concrete(fa);
+  concrete(fb);
+  return new ZipWithIO(fa, fb, f);
+}
+
+/**
+ * Like `zipWithM`, but uses a pure function.
+ *
+ * @tsplus fluent fncts.io.Queue zipWith
+ */
+export 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,
+): PQueue<RA & RA1, RB & RB1, EA | EA1, EB | EB1, A1, D> {
+  return zipWithIO_(queue, that, (b, c) => IO.succeedNow(f(b, c)));
+}
+
+/**
+ * Like `zipWith`, but tuples the elements instead of applying a function.
+ *
+ * @tsplus fluent fncts.io.Queue zip
+ */
+export 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>,
+): PQueue<RA & RA1, RB & RB1, EA | EA1, EB | EB1, A1, readonly [B, C]> {
+  return zipWith_(queue, that, tuple);
+}

package/_src/Queue/api.ts

@@ -0,0 +1,9 @@
+// codegen:start { preset: barrel, include: api/*.ts }
+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";
+// codegen:end

package/_src/Queue/constructors.ts

@@ -0,0 +1,33 @@
+import type { Queue } from "@fncts/io/Queue/definition";
+
+import { bounded, unbounded } from "@fncts/io/internal/MutableQueue";
+import { _makeQueue } from "@fncts/io/Queue/internal";
+import { BackPressureStrategy, DroppingStrategy, SlidingStrategy } from "@fncts/io/Queue/strategy";
+
+/**
+ * @tsplus static fncts.io.QueueOps makeSliding
+ */
+export function makeSliding<A>(capacity: number): UIO<Queue<A>> {
+  return IO.succeed(bounded<A>(capacity)).flatMap(_makeQueue(new SlidingStrategy()));
+}
+
+/**
+ * @tsplus static fncts.io.QueueOps makeUnbounded
+ */
+export function makeUnbounded<A>(): UIO<Queue<A>> {
+  return IO.succeed(unbounded<A>()).flatMap(_makeQueue(new DroppingStrategy()));
+}
+
+/**
+ * @tsplus static fncts.io.QueueOps makeDropping
+ */
+export function makeDropping<A>(capacity: number): UIO<Queue<A>> {
+  return IO.succeed(bounded<A>(capacity)).flatMap(_makeQueue(new DroppingStrategy()));
+}
+
+/**
+ * @tsplus static fncts.io.QueueOps makeBounded
+ */
+export function makeBounded<A>(capacity: number): UIO<Queue<A>> {
+  return IO.succeed(bounded<A>(capacity)).flatMap(_makeQueue(new BackPressureStrategy()));
+}

package/_src/Queue/definition.ts

@@ -0,0 +1,134 @@
+/**
+ * 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> {
+  readonly _RA: (_: RA) => void;
+  readonly _RB: (_: RB) => void;
+  readonly _EA: () => EA;
+  readonly _EB: () => EB;
+  readonly _A: (_: A) => void;
+  readonly _B: () => B;
+}
+
+/**
+ * @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> {
+  //
+}
+
+/**
+ * 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> {
+  readonly _RA!: (_: RA) => void;
+  readonly _RB!: (_: RB) => void;
+  readonly _EA!: () => EA;
+  readonly _EB!: () => EB;
+  readonly _A!: (_: A) => void;
+  readonly _B!: () => 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
+   */
+  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): 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>): 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.
+   */
+  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): 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<unknown, unknown, never, never, A, A> {}
+
+export declare namespace Queue {
+  /**
+   * A queue that can only be dequeued.
+   *
+   * @tsplus type fncts.io.Queue
+   */
+  export interface Dequeue<A> extends PQueue<never, unknown, unknown, never, never, A> {}
+
+  /**
+   * A queue that can only be enqueued.
+   *
+   * @tsplus type fncts.io.Queue
+   */
+  export interface Enqueue<A> extends PQueue<unknown, never, never, unknown, A, any> {}
+}

package/_src/Queue/internal.ts

@@ -0,0 +1,240 @@
+import type { MutableQueue } from "@fncts/io/internal/MutableQueue";
+import type { Queue } from "@fncts/io/Queue/definition";
+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<unknown, unknown, 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): IO<unknown, 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>): IO<unknown, never, 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);
+        }
+      }
+    });
+  }
+
+  shutdown: UIO<void> = IO.deferWith((_, id) => {
+    this.shutdownFlag.set(true);
+
+    return IO.foreachC(_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<unknown, never, A> = IO.deferWith((_, 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<unknown, 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): IO<unknown, never, 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;
+        });
+      }
+    });
+  }
+}
+
+function _unsafeQueue<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 _makeQueue<A>(strategy: Strategy<A>): (queue: MutableQueue<A>) => IO<unknown, never, Queue<A>> {
+  return (queue) =>
+    Future.make<never, void>().map((p) => _unsafeQueue(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) {
+    if (!q.enqueue(bs.unsafeGet(0))) {
+      return bs;
+    } else {
+      bs = bs.drop(1);
+    }
+  }
+
+  return bs;
+}
+
+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;
+}
+
+export function _unsafeCompletePromise<A>(p: Future<never, A>, a: A) {
+  return p.unsafeDone(IO.succeedNow(a));
+}
+
+export function _unsafeRemove<A>(q: MutableQueue<A>, a: A) {
+  return _unsafeOfferAll(q, _unsafePollAll(q)).filter((b) => a !== b);
+}
+
+function _unsafePollN<A>(q: MutableQueue<A>, max: number): Conc<A> {
+  let j  = 0;
+  let as = Conc.empty<A>();
+
+  while (j < max) {
+    const p = q.dequeue(undefined);
+
+    if (p != null) {
+      as = as.append(p);
+    } else {
+      return as;
+    }
+
+    j += 1;
+  }
+
+  return as;
+}
+
+export function _unsafeCompleteTakers<A>(
+  strategy: Strategy<A>,
+  queue: MutableQueue<A>,
+  takers: MutableQueue<Future<never, A>>,
+): void {
+  let keepPolling = true;
+
+  while (keepPolling && !queue.isEmpty) {
+    const taker = takers.dequeue(undefined);
+
+    if (taker != null) {
+      const element = queue.dequeue(undefined);
+
+      if (element != null) {
+        _unsafeCompletePromise(taker, element);
+        strategy.unsafeOnQueueEmptySpace(queue, takers);
+      } else {
+        _unsafeOfferAll(takers, _unsafePollAll(takers).prepend(taker));
+      }
+
+      keepPolling = true;
+    } else {
+      keepPolling = false;
+    }
+  }
+}

package/_src/Queue/strategy.ts

@@ -0,0 +1,177 @@
+import type { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
+import type { MutableQueue } from "@fncts/io/internal/MutableQueue";
+
+import { unbounded } from "@fncts/io/internal/MutableQueue";
+import {
+  _unsafeCompletePromise,
+  _unsafeCompleteTakers,
+  _unsafeOfferAll,
+  _unsafePollAll,
+} from "@fncts/io/Queue/internal";
+
+export interface Strategy<A> {
+  readonly handleSurplus: (
+    as: Conc<A>,
+    queue: MutableQueue<A>,
+    takers: MutableQueue<Future<never, A>>,
+    isShutdown: AtomicBoolean,
+  ) => UIO<boolean>;
+
+  readonly unsafeOnQueueEmptySpace: (queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>) => void;
+
+  readonly surplusSize: number;
+
+  readonly shutdown: UIO<void>;
+}
+
+export class BackPressureStrategy<A> implements Strategy<A> {
+  private putters = unbounded<[A, Future<never, boolean>, boolean]>();
+
+  handleSurplus(
+    as: Conc<A>,
+    queue: MutableQueue<A>,
+    takers: MutableQueue<Future<never, A>>,
+    isShutdown: AtomicBoolean,
+  ): UIO<boolean> {
+    return IO.descriptorWith((d) =>
+      IO.defer(() => {
+        const p = Future.unsafeMake<never, boolean>(d.id);
+
+        return IO.defer(() => {
+          this.unsafeOffer(as, p);
+          this.unsafeOnQueueEmptySpace(queue, takers);
+          _unsafeCompleteTakers(this, queue, takers);
+          if (isShutdown.get) {
+            return IO.interrupt;
+          } else {
+            return p.await;
+          }
+        }).onInterrupt(() => IO.succeed(() => this.unsafeRemove(p)));
+      }),
+    );
+  }
+
+  unsafeRemove(p: Future<never, boolean>) {
+    _unsafeOfferAll(
+      this.putters,
+      _unsafePollAll(this.putters).filter(([_, __]) => __ !== p),
+    );
+  }
+
+  unsafeOffer(as: Conc<A>, p: Future<never, boolean>) {
+    let bs = as;
+
+    while (bs.length > 0) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const head = bs.unsafeGet(0);
+      bs         = bs.drop(1);
+
+      if (bs.length === 0) {
+        this.putters.enqueue([head, p, true]);
+      } else {
+        this.putters.enqueue([head, p, false]);
+      }
+    }
+  }
+
+  unsafeOnQueueEmptySpace(queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>) {
+    let keepPolling = true;
+
+    while (keepPolling && !queue.isFull) {
+      const putter = this.putters.dequeue(undefined);
+
+      if (putter != null) {
+        const offered = queue.enqueue(putter[0]);
+
+        if (offered && putter[2]) {
+          _unsafeCompletePromise(putter[1], true);
+        } else if (!offered) {
+          _unsafeOfferAll(this.putters, _unsafePollAll(this.putters).prepend(putter));
+        }
+        _unsafeCompleteTakers(this, queue, takers);
+      } else {
+        keepPolling = false;
+      }
+    }
+  }
+
+  get shutdown(): UIO<void> {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+    return IO.gen(function* (_) {
+      const fiberId = yield* _(IO.fiberId);
+      const putters = yield* _(IO.succeed(_unsafePollAll(self.putters)));
+      yield* _(IO.foreachC(putters, ([, p, lastItem]) => (lastItem ? p.interruptAs(fiberId).asUnit : IO.unit)));
+    });
+  }
+
+  get surplusSize(): number {
+    return this.putters.size;
+  }
+}
+
+export class DroppingStrategy<A> implements Strategy<A> {
+  handleSurplus(
+    _as: Conc<A>,
+    _queue: MutableQueue<A>,
+    _takers: MutableQueue<Future<never, A>>,
+    _isShutdown: AtomicBoolean,
+  ): UIO<boolean> {
+    return IO.succeedNow(false);
+  }
+
+  unsafeOnQueueEmptySpace(_queue: MutableQueue<A>) {
+    //
+  }
+
+  get shutdown(): UIO<void> {
+    return IO.unit;
+  }
+
+  get surplusSize(): number {
+    return 0;
+  }
+}
+
+export class SlidingStrategy<A> implements Strategy<A> {
+  handleSurplus(
+    as: Conc<A>,
+    queue: MutableQueue<A>,
+    takers: MutableQueue<Future<never, A>>,
+    _isShutdown: AtomicBoolean,
+  ): UIO<boolean> {
+    return IO.succeed(() => {
+      this.unsafeSlidingOffer(queue, as);
+      _unsafeCompleteTakers(this, queue, takers);
+      return true;
+    });
+  }
+
+  unsafeOnQueueEmptySpace(_queue: MutableQueue<A>) {
+    //
+  }
+
+  get shutdown(): UIO<void> {
+    return IO.unit;
+  }
+
+  get surplusSize(): number {
+    return 0;
+  }
+
+  private unsafeSlidingOffer(queue: MutableQueue<A>, as: Conc<A>) {
+    let bs = as;
+
+    while (bs.length > 0) {
+      if (queue.capacity === 0) {
+        return;
+      }
+      // poll 1 and retry
+      queue.dequeue(undefined);
+
+      if (queue.enqueue(bs.unsafeGet(0))) {
+        bs = bs.drop(1);
+      }
+    }
+  }
+}

package/_src/Queue.ts

@@ -0,0 +1,7 @@
+// 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