@fncts/io 0.0.11 → 0.0.14

package/_src/Queue/api/operations.ts

@@ -7,7 +7,10 @@ import { concrete } from "@fncts/io/Queue/definition";
  *
  * @tsplus getter fncts.io.Queue awaitShutdown
  */
-export function awaitShutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): UIO<void> {
+export function awaitShutdown<RA, RB, EA, EB, A, B>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  __tsplusTrace?: string,
+): UIO<void> {
   concrete(queue);
   return queue.awaitShutdown;
 }
@@ -17,7 +20,7 @@ export function awaitShutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB
  *
  * @tsplus getter fncts.io.Queue capacity
  */
-export function capacity<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): number {
+export function capacity<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): number {
   concrete(queue);
   return queue.capacity;
 }
@@ -27,7 +30,10 @@ export function capacity<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A,
  *
  * @tsplus getter fncts.io.Queue isShutdown
  */
-export function isShutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): UIO<boolean> {
+export function isShutdown<RA, RB, EA, EB, A, B>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  __tsplusTrace?: string,
+): UIO<boolean> {
   concrete(queue);
   return queue.isShutdown;
 }
@@ -37,7 +43,11 @@ export function isShutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A
  *
  * @tsplus fluent fncts.io.Queue offer
  */
-export function offer_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, a: A): IO<RA, EA, boolean> {
+export function offer_<RA, RB, EA, EB, A, B>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  a: A,
+  __tsplusTrace?: string,
+): IO<RA, EA, boolean> {
   concrete(queue);
   return queue.offer(a);
 }
@@ -60,7 +70,11 @@ export function offer_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>
  *
  * @tsplus fluent fncts.io.Queue offerAll
  */
-export function offerAll_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, as: Iterable<A>) {
+export function offerAll_<RA, RB, EA, EB, A, B>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  as: Iterable<A>,
+  __tsplusTrace?: string,
+) {
   concrete(queue);
   return queue.offerAll(as);
 }
@@ -71,7 +85,7 @@ export function offerAll_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A,
  *
  * @tsplus getter fncts.io.Queue shutdown
  */
-export function shutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>) {
+export function shutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string) {
   concrete(queue);
   return queue.shutdown;
 }
@@ -83,7 +97,7 @@ export function shutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A,
  *
  * @tsplus getter fncts.io.Queue size
  */
-export function size<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>) {
+export function size<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string) {
   concrete(queue);
   return queue.size;
 }
@@ -94,7 +108,7 @@ export function size<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>)
  *
  * @tsplus getter fncts.io.Queue take
  */
-export function take<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): IO<RB, EB, B> {
+export function take<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<RB, EB, B> {
   concrete(queue);
   return queue.take;
 }
@@ -105,7 +119,7 @@ export function take<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>):
  *
  * @tsplus getter fncts.io.Queue takeAll
  */
-export function takeAll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>) {
+export function takeAll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string) {
   concrete(queue);
   return queue.takeAll;
 }
@@ -115,7 +129,11 @@ export function takeAll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B
  *
  * @tsplus fluent fncts.io.Queue takeAllUpTo
  */
-export function takeAllUpTo_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, n: number) {
+export function takeAllUpTo_<RA, RB, EA, EB, A, B>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  n: number,
+  __tsplusTrace?: string,
+) {
   concrete(queue);
   return queue.takeUpTo(n);
 }

package/_src/Queue/api/poll.ts

@@ -5,7 +5,10 @@ import { concrete } from "@fncts/io/Queue/definition";
  *
  * @tsplus getter fncts.io.Queue poll
  */
-export function poll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): IO<RB, EB, Maybe<B>> {
+export function poll<RA, RB, EA, EB, A, B>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  __tsplusTrace?: string,
+): IO<RB, EB, Maybe<B>> {
   concrete(queue);
   return queue.takeUpTo(1).map((bs) => bs.head);
 }

package/_src/Queue/api/takeBetween.ts

@@ -1,6 +1,10 @@
 import { concrete } from "@fncts/io/Queue/definition";
 
-function takeRemainderLoop<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, n: number): IO<RB, EB, Conc<B>> {
+function takeRemainderLoop<RA, RB, EA, EB, A, B>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  n: number,
+  __tsplusTrace?: string,
+): IO<RB, EB, Conc<B>> {
   concrete(queue);
   if (n <= 0) {
     return IO.succeedNow(Conc.empty());
@@ -20,6 +24,7 @@ export 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>> {
   concrete(queue);
   if (max < min) {

package/_src/Queue/api/zipWithIO.ts

@@ -2,8 +2,8 @@ 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,
+  RA | RA1,
+  RB | RB1 | R3,
   EA | EA1,
   E3 | EB | EB1,
   A1,
@@ -23,11 +23,11 @@ export class ZipWithIO<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, R
 
   isShutdown: UIO<boolean> = this.fa.isShutdown;
 
-  offer(a: A1): IO<RA & RA1, EA1 | EA, boolean> {
+  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> {
+  offerAll(as: Iterable<A1>): IO<RA | RA1, EA1 | EA, boolean> {
     return this.fa.offerAll(as).zipWithC(this.fb.offerAll(as), (x, y) => x && y);
   }
 
@@ -35,13 +35,13 @@ export class ZipWithIO<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, R
 
   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));
+  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
+  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>> {
+  takeUpTo(max: number): IO<RB | RB1 | R3, E3 | EB | EB1, Conc<D>> {
     return this.fa
       .takeUpTo(max)
       .zipC(this.fb.takeUpTo(max))
@@ -64,7 +64,8 @@ export function zipWithIO_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C,
   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> {
+  __tsplusTrace?: string,
+): PQueue<RA | RA1, RB | RB1 | R3, EA | EA1, E3 | EB | EB1, A1, D> {
   concrete(fa);
   concrete(fb);
   return new ZipWithIO(fa, fb, f);
@@ -79,7 +80,8 @@ export function zipWith_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B,
   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> {
+  __tsplusTrace?: string,
+): PQueue<RA | RA1, RB | RB1, EA | EA1, EB | EB1, A1, D> {
   return zipWithIO_(queue, that, (b, c) => IO.succeedNow(f(b, c)));
 }
 
@@ -91,6 +93,7 @@ export function zipWith_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B,
 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]> {
+  __tsplusTrace?: string,
+): PQueue<RA | RA1, RB | RB1, EA | EA1, EB | EB1, A1, readonly [B, C]> {
   return zipWith_(queue, that, tuple);
 }

package/_src/Queue/constructors.ts

@@ -7,27 +7,27 @@ import { BackPressureStrategy, DroppingStrategy, SlidingStrategy } from "@fncts/
 /**
  * @tsplus static fncts.io.QueueOps makeSliding
  */
-export function makeSliding<A>(capacity: number): UIO<Queue<A>> {
+export function makeSliding<A>(capacity: number, __tsplusTrace?: string): 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>> {
+export function makeUnbounded<A>(__tsplusTrace?: string): 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>> {
+export function makeDropping<A>(capacity: number, __tsplusTrace?: string): 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>> {
+export function makeBounded<A>(capacity: number, __tsplusTrace?: string): UIO<Queue<A>> {
   return IO.succeed(bounded<A>(capacity)).flatMap(_makeQueue(new BackPressureStrategy()));
 }

package/_src/Queue/definition.ts

@@ -8,8 +8,8 @@
  * @tsplus type fncts.io.Queue
  */
 export interface PQueue<RA, RB, EA, EB, A, B> {
-  readonly _RA: (_: RA) => void;
-  readonly _RB: (_: RB) => void;
+  readonly _RA: () => RA;
+  readonly _RB: () => RB;
   readonly _EA: () => EA;
   readonly _EB: () => EB;
   readonly _A: (_: A) => void;
@@ -40,8 +40,8 @@ export function concrete<RA, RB, EA, EB, A, B>(
  * 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 _RA!: () => RA;
+  readonly _RB!: () => RB;
   readonly _EA!: () => EA;
   readonly _EB!: () => EB;
   readonly _A!: (_: A) => void;
@@ -63,7 +63,7 @@ export abstract class QueueInternal<RA, RB, EA, EB, A, B> implements PQueue<RA,
   /**
    * Places one value in the queue.
    */
-  abstract offer(a: A): IO<RA, EA, boolean>;
+  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
@@ -81,7 +81,7 @@ export abstract class QueueInternal<RA, RB, EA, EB, A, B> implements PQueue<RA,
    * 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>;
+  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.
@@ -106,7 +106,7 @@ export abstract class QueueInternal<RA, RB, EA, EB, A, B> implements PQueue<RA,
   /**
    * Takes up to max number of values in the queue.
    */
-  abstract takeUpTo(n: number): IO<RB, EB, Conc<B>>;
+  abstract takeUpTo(n: number, __tsplusTrace?: string): IO<RB, EB, Conc<B>>;
 }
 
 /**
@@ -115,7 +115,7 @@ export abstract class QueueInternal<RA, RB, EA, EB, A, B> implements PQueue<RA,
  *
  * @tsplus type fncts.io.Queue
  */
-export interface Queue<A> extends PQueue<unknown, unknown, never, never, A, A> {}
+export interface Queue<A> extends PQueue<never, never, never, never, A, A> {}
 
 export declare namespace Queue {
   /**
@@ -123,12 +123,12 @@ export declare namespace Queue {
    *
    * @tsplus type fncts.io.Queue
    */
-  export interface Dequeue<A> extends PQueue<never, unknown, unknown, never, never, A> {}
+  export interface Dequeue<A> extends PQueue<never, never, 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> {}
+  export interface Enqueue<A> extends PQueue<never, never, never, unknown, A, any> {}
 }

package/_src/Queue/internal.ts

@@ -6,7 +6,7 @@ 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> {
+class UnsafeQueue<A> extends QueueInternal<never, never, never, never, A, A> {
   constructor(
     readonly queue: MutableQueue<A>,
     readonly takers: MutableQueue<Future<never, A>>,
@@ -23,7 +23,7 @@ class UnsafeQueue<A> extends QueueInternal<unknown, unknown, never, never, A, A>
 
   isShutdown: UIO<boolean> = IO.succeed(this.shutdownFlag.get);
 
-  offer(a: A): IO<unknown, never, boolean> {
+  offer(a: A, __tsplusTrace?: string): IO<never, never, boolean> {
     return IO.defer(() => {
       if (this.shutdownFlag.get) {
         return IO.interrupt;
@@ -46,7 +46,7 @@ class UnsafeQueue<A> extends QueueInternal<unknown, unknown, never, never, A, A>
     });
   }
 
-  offerAll(as: Iterable<A>): IO<unknown, never, boolean> {
+  offerAll(as: Iterable<A>, __tsplusTrace?: string): IO<never, never, boolean> {
     const arr = Conc.from(as);
     return IO.defer(() => {
       if (this.shutdownFlag.get) {
@@ -91,7 +91,7 @@ class UnsafeQueue<A> extends QueueInternal<unknown, unknown, never, never, A, A>
     }
   });
 
-  take: IO<unknown, never, A> = IO.deferWith((_, fiberId) =>
+  take: IO<never, never, A> = IO.deferWith((_, fiberId) =>
     IO.defer(() => {
       if (this.shutdownFlag.get) {
         return IO.interrupt;
@@ -118,7 +118,7 @@ class UnsafeQueue<A> extends QueueInternal<unknown, unknown, never, never, A, A>
     }),
   );
 
-  takeAll: IO<unknown, never, Conc<A>> = IO.defer(() => {
+  takeAll: IO<never, never, Conc<A>> = IO.defer(() => {
     if (this.shutdownFlag.get) {
       return IO.interrupt;
     } else {
@@ -130,7 +130,7 @@ class UnsafeQueue<A> extends QueueInternal<unknown, unknown, never, never, A, A>
     }
   });
 
-  takeUpTo(max: number): IO<unknown, never, Conc<A>> {
+  takeUpTo(max: number, __tsplusTrace?: string): IO<never, never, Conc<A>> {
     return IO.defer(() => {
       if (this.shutdownFlag.get) {
         return IO.interrupt;
@@ -155,7 +155,7 @@ function _unsafeQueue<A>(
   return new UnsafeQueue(queue, takers, shutdownHook, shutdownFlag, strategy);
 }
 
-export function _makeQueue<A>(strategy: Strategy<A>): (queue: MutableQueue<A>) => IO<unknown, never, Queue<A>> {
+export function _makeQueue<A>(strategy: Strategy<A>): (queue: MutableQueue<A>) => IO<never, never, Queue<A>> {
   return (queue) =>
     Future.make<never, void>().map((p) => _unsafeQueue(queue, unbounded(), p, new AtomicBoolean(false), strategy));
 }

package/_src/Queue/strategy.ts

@@ -15,9 +15,14 @@ export interface Strategy<A> {
     queue: MutableQueue<A>,
     takers: MutableQueue<Future<never, A>>,
     isShutdown: AtomicBoolean,
+    __tsplusTrace?: string,
   ) => UIO<boolean>;
 
-  readonly unsafeOnQueueEmptySpace: (queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>) => void;
+  readonly unsafeOnQueueEmptySpace: (
+    queue: MutableQueue<A>,
+    takers: MutableQueue<Future<never, A>>,
+    __tsplusTrace?: string,
+  ) => void;
 
   readonly surplusSize: number;
 
@@ -32,6 +37,7 @@ export class BackPressureStrategy<A> implements Strategy<A> {
     queue: MutableQueue<A>,
     takers: MutableQueue<Future<never, A>>,
     isShutdown: AtomicBoolean,
+    __tsplusTrace?: string,
   ): UIO<boolean> {
     return IO.descriptorWith((d) =>
       IO.defer(() => {
@@ -51,14 +57,14 @@ export class BackPressureStrategy<A> implements Strategy<A> {
     );
   }
 
-  unsafeRemove(p: Future<never, boolean>) {
+  unsafeRemove(p: Future<never, boolean>, __tsplusTrace?: string) {
     _unsafeOfferAll(
       this.putters,
       _unsafePollAll(this.putters).filter(([_, __]) => __ !== p),
     );
   }
 
-  unsafeOffer(as: Conc<A>, p: Future<never, boolean>) {
+  unsafeOffer(as: Conc<A>, p: Future<never, boolean>, __tsplusTrace?: string) {
     let bs = as;
 
     while (bs.length > 0) {
@@ -74,7 +80,7 @@ export class BackPressureStrategy<A> implements Strategy<A> {
     }
   }
 
-  unsafeOnQueueEmptySpace(queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>) {
+  unsafeOnQueueEmptySpace(queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>, __tsplusTrace?: string) {
     let keepPolling = true;
 
     while (keepPolling && !queue.isFull) {
@@ -98,10 +104,10 @@ export class BackPressureStrategy<A> implements Strategy<A> {
   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)));
+    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)));
     });
   }
 
@@ -116,11 +122,12 @@ export class DroppingStrategy<A> implements Strategy<A> {
     _queue: MutableQueue<A>,
     _takers: MutableQueue<Future<never, A>>,
     _isShutdown: AtomicBoolean,
+    __tsplusTrace?: string,
   ): UIO<boolean> {
     return IO.succeedNow(false);
   }
 
-  unsafeOnQueueEmptySpace(_queue: MutableQueue<A>) {
+  unsafeOnQueueEmptySpace(_queue: MutableQueue<A>, _takers: MutableQueue<Future<never, A>>, __tsplusTrace?: string) {
     //
   }
 
@@ -139,6 +146,7 @@ export class SlidingStrategy<A> implements Strategy<A> {
     queue: MutableQueue<A>,
     takers: MutableQueue<Future<never, A>>,
     _isShutdown: AtomicBoolean,
+    __tsplusTrace?: string,
   ): UIO<boolean> {
     return IO.succeed(() => {
       this.unsafeSlidingOffer(queue, as);
@@ -147,7 +155,7 @@ export class SlidingStrategy<A> implements Strategy<A> {
     });
   }
 
-  unsafeOnQueueEmptySpace(_queue: MutableQueue<A>) {
+  unsafeOnQueueEmptySpace(_queue: MutableQueue<A>, _takers: MutableQueue<Future<never, A>>, __tsplusTrace?: string) {
     //
   }
 

package/_src/Random/api.ts

@@ -18,34 +18,34 @@ export const nextInt = IO.randomWith((random) => random.nextInt);
 /**
  * @tsplus static fncts.io.RandomOps nextRange
  */
-export function nextRange(low: number, high: number): IO<unknown, never, number> {
+export function nextRange(low: number, high: number, __tsplusTrace?: string): IO<never, never, number> {
   return IO.randomWith((random) => random.nextRange(low, high));
 }
 
 /**
  * @tsplus static fncts.io.RandomOps nextIntBetween
  */
-export function nextIntBetween(low: number, high: number): UIO<number> {
+export function nextIntBetween(low: number, high: number, __tsplusTrace?: string): UIO<number> {
   return IO.randomWith((random) => random.nextIntBetween(low, high));
 }
 
 /**
  * @tsplus static fncts.io.RandomOps nextBigIntBetween
  */
-export function nextBigIntBetween(low: bigint, high: bigint): UIO<bigint> {
+export function nextBigIntBetween(low: bigint, high: bigint, __tsplusTrace?: string): UIO<bigint> {
   return IO.randomWith((random) => random.nextBigIntBetween(low, high));
 }
 
 /**
  * @tsplus static fncts.io.RandomOps nextArrayIntBetween
  */
-export function nextArrayIntBetween(low: ArrayInt, high: ArrayInt): UIO<ArrayInt> {
+export function nextArrayIntBetween(low: ArrayInt, high: ArrayInt, __tsplusTrace?: string): UIO<ArrayInt> {
   return IO.randomWith((random) => random.nextArrayIntBetween(low, high));
 }
 
 /**
  * @tsplus static fncts.io.RandomOps setSeed
  */
-export function setSeed(seed: number): UIO<void> {
+export function setSeed(seed: number, __tsplusTrace?: string): UIO<void> {
   return IO.randomWith((random) => random.setSeed(seed));
 }

package/_src/Random/definition.ts

@@ -13,9 +13,9 @@ export abstract class Random {
   abstract readonly nextDouble: UIO<number>;
   abstract readonly nextBoolean: UIO<boolean>;
   abstract readonly nextInt: UIO<number>;
-  abstract nextRange(low: number, high: number): UIO<number>;
-  abstract nextIntBetween(low: number, high: number): UIO<number>;
-  abstract nextBigIntBetween(low: bigint, high: bigint): UIO<bigint>;
-  abstract nextArrayIntBetween(low: ArrayInt, high: ArrayInt): UIO<ArrayInt>;
-  abstract setSeed(seed: number): UIO<void>;
+  abstract nextRange(low: number, high: number, __tsplusTrace?: string): UIO<number>;
+  abstract nextIntBetween(low: number, high: number, __tsplusTrace?: string): UIO<number>;
+  abstract nextBigIntBetween(low: bigint, high: bigint, __tsplusTrace?: string): UIO<bigint>;
+  abstract nextArrayIntBetween(low: ArrayInt, high: ArrayInt, __tsplusTrace?: string): UIO<ArrayInt>;
+  abstract setSeed(seed: number, __tsplusTrace?: string): UIO<void>;
 }

package/_src/Random/live.ts

@@ -16,16 +16,16 @@ export class LiveRandom implements Random {
   nextDouble  = IO.succeed(() => this.prng.nextDouble());
   nextInt     = IO.succeed(() => this.prng.nextInt());
   nextBoolean = this.nextDouble.flatMap((n) => IO.succeedNow(n > 0.5));
-  nextRange(low: number, high: number): UIO<number> {
+  nextRange(low: number, high: number, __tsplusTrace?: string): UIO<number> {
     return this.nextDouble.flatMap((n) => IO.succeedNow((high - low) * n + low));
   }
-  nextIntBetween(low: number, high: number): UIO<number> {
+  nextIntBetween(low: number, high: number, __tsplusTrace?: string): UIO<number> {
     return IO.succeed(this.prng.nextInt(low, high));
   }
-  nextBigIntBetween(low: bigint, high: bigint): UIO<bigint> {
+  nextBigIntBetween(low: bigint, high: bigint, __tsplusTrace?: string): UIO<bigint> {
     return IO.succeed(this.prng.nextBigInt(low, high));
   }
-  nextArrayIntBetween(low: ArrayInt, high: ArrayInt): UIO<ArrayInt> {
+  nextArrayIntBetween(low: ArrayInt, high: ArrayInt, __tsplusTrace?: string): UIO<ArrayInt> {
     return IO.succeed(this.prng.nextArrayInt(low, high));
   }
 }

package/_src/Ref/Atomic/Atomic.ts

@@ -7,7 +7,7 @@ import { DerivedAll } from "../DerivedAll.js";
 /**
  * @tsplus type fncts.io.Ref.Atomic
  */
-export class Atomic<A> extends RefInternal<unknown, unknown, never, never, A, A> {
+export class Atomic<A> extends RefInternal<never, never, never, never, A, A> {
   readonly _tag = "Atomic";
 
   constructor(private value: A) {
@@ -22,7 +22,7 @@ export class Atomic<A> extends RefInternal<unknown, unknown, never, never, A, A>
     _eb: (_: never) => ED,
     ca: (_: C) => Either<EC, A>,
     bd: (_: A) => Either<ED, D>,
-  ): PRef<unknown, unknown, EC, ED, C, D> {
+  ): PRef<never, never, EC, ED, C, D> {
     return new Derived<EC, ED, C, D>((f) => f(this, bd, ca));
   }
 
@@ -32,7 +32,7 @@ export class Atomic<A> extends RefInternal<unknown, unknown, never, never, A, A>
     _ec: (_: never) => EC,
     ca: (_: C) => (_: A) => Either<EC, A>,
     bd: (_: A) => Either<ED, D>,
-  ): PRef<unknown, unknown, EC, ED, C, D> {
+  ): PRef<never, never, EC, ED, C, D> {
     return new DerivedAll<EC, ED, C, D>((f) => f(this, bd, ca));
   }
 

package/_src/Ref/Atomic/api.ts

@@ -3,7 +3,7 @@ import type { Atomic } from "./Atomic.js";
 /**
  * @tsplus fluent fncts.io.Ref.Atomic getAndSet
  */
-export function getAndSet<A>(self: Atomic<A>, a: A): UIO<A> {
+export function getAndSet<A>(self: Atomic<A>, a: A, __tsplusTrace?: string): UIO<A> {
   return IO.succeed(() => {
     const v = self.unsafeGet;
     self.unsafeSet(a);
@@ -14,7 +14,7 @@ export function getAndSet<A>(self: Atomic<A>, a: A): UIO<A> {
 /**
  * @tsplus fluent fncts.io.Ref.Atomic getAndUpdate
  */
-export function getAndUpdate<A>(self: Atomic<A>, f: (a: A) => A) {
+export function getAndUpdate<A>(self: Atomic<A>, f: (a: A) => A, __tsplusTrace?: string) {
   return IO.succeed(() => {
     const v = self.unsafeGet;
     self.unsafeSet(f(v));
@@ -25,7 +25,7 @@ export function getAndUpdate<A>(self: Atomic<A>, f: (a: A) => A) {
 /**
  * @tsplus fluent fncts.io.Ref.Atomic getAndUpdateJust
  */
-export function getAndUpdateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>) {
+export function getAndUpdateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string) {
   return IO.succeed(() => {
     const v = self.unsafeGet;
     const o = f(v);
@@ -40,7 +40,7 @@ export function getAndUpdateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>) {
 /**
  * @tsplus fluent fncts.io.Ref.Atomic modify
  */
-export function modify<A, B>(self: Atomic<A>, f: (a: A) => readonly [B, A]) {
+export function modify<A, B>(self: Atomic<A>, f: (a: A) => readonly [B, A], __tsplusTrace?: string) {
   return IO.succeed(() => {
     const v = self.unsafeGet;
     const o = f(v);
@@ -52,7 +52,7 @@ export function modify<A, B>(self: Atomic<A>, f: (a: A) => readonly [B, A]) {
 /**
  * @tsplus fluent fncts.io.Ref.Atomic modifyJust
  */
-export function modifyJust<A, B>(self: Atomic<A>, def: B, f: (a: A) => Maybe<readonly [B, A]>) {
+export function modifyJust<A, B>(self: Atomic<A>, def: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string) {
   return IO.succeed(() => {
     const v = self.unsafeGet;
     const o = f(v);
@@ -70,7 +70,7 @@ export function modifyJust<A, B>(self: Atomic<A>, def: B, f: (a: A) => Maybe<rea
 /**
  * @tsplus fluent fncts.io.Ref.Atomic update
  */
-export function update<A>(self: Atomic<A>, f: (a: A) => A) {
+export function update<A>(self: Atomic<A>, f: (a: A) => A, __tsplusTrace?: string) {
   return IO.succeed(() => {
     self.unsafeSet(f(self.unsafeGet));
   });
@@ -79,7 +79,7 @@ export function update<A>(self: Atomic<A>, f: (a: A) => A) {
 /**
  * @tsplus fluent fncts.io.Ref.Atomic updateAndGet
  */
-export function updateAndGet<A>(self: Atomic<A>, f: (a: A) => A) {
+export function updateAndGet<A>(self: Atomic<A>, f: (a: A) => A, __tsplusTrace?: string) {
   return IO.succeed(() => {
     self.unsafeSet(f(self.unsafeGet));
     return self.unsafeGet;
@@ -89,7 +89,7 @@ export function updateAndGet<A>(self: Atomic<A>, f: (a: A) => A) {
 /**
  * @tsplus fluent fncts.io.Ref.Atomic updateJust
  */
-export function updateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>) {
+export function updateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string) {
   return IO.succeed(() => {
     const o = f(self.unsafeGet);
 
@@ -103,7 +103,7 @@ export function updateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>) {
 /**
  * @tsplus fluent fncts.io.Ref.Atomic updateJustAndGet
  */
-export function updateJustAndGet<A>(self: Atomic<A>, f: (a: A) => Maybe<A>) {
+export function updateJustAndGet<A>(self: Atomic<A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string) {
   return IO.succeed(() => {
     const o = f(self.unsafeGet);
 
@@ -119,6 +119,6 @@ export function updateJustAndGet<A>(self: Atomic<A>, f: (a: A) => Maybe<A>) {
 /**
  * @tsplus fluent fncts.io.Ref.Atomic unsafeUpdate
  */
-export function unsafeUpdate<A>(self: Atomic<A>, f: (a: A) => A) {
+export function unsafeUpdate<A>(self: Atomic<A>, f: (a: A) => A, __tsplusTrace?: string) {
   return self.unsafeSet(f(self.unsafeGet));
 }