@fncts/io 0.0.13 → 0.0.16

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

@@ -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>>;
 }
 
 /**

package/_src/Queue/internal.ts

@@ -23,7 +23,7 @@ class UnsafeQueue<A> extends QueueInternal<never, never, never, never, A, A> {
 
   isShutdown: UIO<boolean> = IO.succeed(this.shutdownFlag.get);
 
-  offer(a: A): IO<never, 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<never, never, never, never, A, A> {
     });
   }
 
-  offerAll(as: Iterable<A>): IO<never, never, boolean> {
+  offerAll(as: Iterable<A>, __tsplusTrace?: string): IO<never, never, boolean> {
     const arr = Conc.from(as);
     return IO.defer(() => {
       if (this.shutdownFlag.get) {
@@ -130,7 +130,7 @@ class UnsafeQueue<A> extends QueueInternal<never, never, never, never, A, A> {
     }
   });
 
-  takeUpTo(max: number): IO<never, never, Conc<A>> {
+  takeUpTo(max: number, __tsplusTrace?: string): IO<never, never, Conc<A>> {
     return IO.defer(() => {
       if (this.shutdownFlag.get) {
         return IO.interrupt;

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) {
@@ -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<never, 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

@@ -3,7 +3,7 @@ import type { ArrayInt } from "@fncts/base/util/rand";
 /**
  * @tsplus static fncts.io.RandomOps Tag
  */
-export const RandomTag = Tag<Random>();
+export const RandomTag = Tag<Random>("fncts.io.Random");
 
 /**
  * @tsplus type fncts.io.Random
@@ -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/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));
 }

package/_src/Ref/Synchronized/api.ts

@@ -15,6 +15,7 @@ import { concreteSynchronized } from "./definition.js";
 export function collectIO_<RA, RB, EA, EB, A, B, RC, EC, C>(
   ref: PRef.Synchronized<RA, RB, EA, EB, A, B>,
   f: (b: B) => Maybe<IO<RC, EC, C>>,
+  __tsplusTrace?: string,
 ): PRef.Synchronized<RA, RB | RC, EA, Maybe<EB | EC>, A, C> {
   return ref.matchIO(
     identity,
@@ -36,6 +37,7 @@ export function collectIO_<RA, RB, EA, EB, A, B, RC, EC, C>(
 export function contramapIO_<RA, RB, EA, EB, B, A, RC, EC, C>(
   ref: PRef.Synchronized<RA, RB, EA, EB, A, B>,
   f: (c: C) => IO<RC, EC, A>,
+  __tsplusTrace?: string,
 ): PRef.Synchronized<RA | RC, RB, EC | EA, EB, C, B> {
   return ref.dimapIO(f, IO.succeedNow);
 }
@@ -50,6 +52,7 @@ export function dimapIO_<RA, RB, EA, EB, B, RC, EC, A, RD, ED, C = A, D = B>(
   ref: PRef.Synchronized<RA, RB, EA, EB, A, B>,
   f: (c: C) => IO<RC, EC, A>,
   g: (b: B) => IO<RD, ED, D>,
+  __tsplusTrace?: string,
 ): PRef.Synchronized<RA | RC, RB | RD, EA | EC, EB | ED, C, D> {
   return ref.matchIO(
     (ea: EA | EC) => ea,
@@ -69,9 +72,10 @@ export function dimapIO_<RA, RB, EA, EB, B, RC, EC, A, RD, ED, C = A, D = B>(
 export function filterInputIO_<RA, RB, EA, EB, B, A, RC, EC, A1 extends A = A>(
   ref: PRef.Synchronized<RA, RB, EA, EB, A, B>,
   f: (a: A1) => IO<RC, EC, boolean>,
+  __tsplusTrace?: string,
 ): PRef.Synchronized<RA | RC, RB, Maybe<EC | EA>, EB, A1, B> {
   return ref.matchIO(
-    (ea) => Just(ea),
+    (ea): Maybe<EC | EA> => Just(ea),
     identity,
     (a) => f(a).asJustError.ifIO(IO.failNow(Nothing()), IO.succeedNow(a)),
     IO.succeedNow,
@@ -88,9 +92,13 @@ export function filterInputIO_<RA, RB, EA, EB, B, A, RC, EC, A1 extends A = A>(
 export function filterOutputIO_<RA, RB, EA, EB, A, B, RC, EC>(
   ref: PRef.Synchronized<RA, RB, EA, EB, A, B>,
   f: (b: B) => IO<RC, EC, boolean>,
+  __tsplusTrace?: string,
 ): PRef.Synchronized<RA, RB | RC, EA, Maybe<EC | EB>, A, B> {
-  return ref.matchIO(identity, Maybe.just, IO.succeedNow, (b) =>
-    f(b).asJustError.ifIO(IO.succeedNow(b), IO.failNow(Nothing())),
+  return ref.matchIO(
+    identity,
+    (eb): Maybe<EC | EB> => Maybe.just(eb),
+    IO.succeedNow,
+    (b) => f(b).asJustError.ifIO(IO.succeedNow(b), IO.failNow(Nothing())),
   );
 }
 
@@ -101,6 +109,7 @@ export function filterOutputIO_<RA, RB, EA, EB, A, B, RC, EC>(
 export function getAndUpdateIO_<RA, RB, EA, EB, R1, E1, A>(
   ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
   f: (a: A) => IO<R1, E1, A>,
+  __tsplusTrace?: string,
 ): IO<RA | RB | R1, EA | EB | E1, A> {
   return ref.modifyIO((a) => f(a).map((r) => [a, r]));
 }
@@ -112,6 +121,7 @@ export function getAndUpdateIO_<RA, RB, EA, EB, R1, E1, A>(
 export function getAndUpdateJustIO_<RA, RB, EA, EB, R1, E1, A>(
   ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
   f: (a: A) => Maybe<IO<R1, E1, A>>,
+  __tsplusTrace?: string,
 ): IO<RA | RB | R1, EA | EB | E1, A> {
   return ref.modifyIO((a) =>
     f(a)
@@ -173,6 +183,7 @@ export function modifyJustIO_<RA, RB, EA, EB, R1, E1, A, B>(
   ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
   def: B,
   f: (a: A) => Maybe<IO<R1, E1, readonly [B, A]>>,
+  __tsplusTrace?: string,
 ): IO<RA | RB | R1, EA | EB | E1, B> {
   return ref.modifyIO((a) => f(a).getOrElse(IO.succeedNow(tuple(def, a))));
 }
@@ -185,6 +196,7 @@ export function modifyJustIO_<RA, RB, EA, EB, R1, E1, A, B>(
 export function updateAndGetIO_<RA, RB, EA, EB, R1, E1, A>(
   ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
   f: (a: A) => IO<R1, E1, A>,
+  __tsplusTrace?: string,
 ): IO<RA | RB | R1, E1 | EA | EB, void> {
   return ref.modifyIO((a) => f(a).map((r) => [r, r])).asUnit;
 }
@@ -197,6 +209,7 @@ export function updateAndGetIO_<RA, RB, EA, EB, R1, E1, A>(
 export function updateIO_<RA, RB, EA, EB, R1, E1, A>(
   ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
   f: (a: A) => IO<R1, E1, A>,
+  __tsplusTrace?: string,
 ): IO<RA | RB | R1, E1 | EA | EB, void> {
   return ref.modifyIO((a) => f(a).map((r) => [undefined, r]));
 }
@@ -209,6 +222,7 @@ export function updateIO_<RA, RB, EA, EB, R1, E1, A>(
 export function updateJustAndGetIO_<RA, RB, EA, EB, R1, E1, A>(
   ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
   f: (a: A) => Maybe<IO<R1, E1, A>>,
+  __tsplusTrace?: string,
 ): IO<RA | RB | R1, E1 | EA | EB, A> {
   return ref.modifyIO((a) =>
     f(a)
@@ -225,6 +239,7 @@ export function updateJustAndGetIO_<RA, RB, EA, EB, R1, E1, A>(
 export function updateJustIO_<RA, RB, EA, EB, R1, E1, A>(
   ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
   f: (a: A) => Maybe<IO<R1, E1, A>>,
+  __tsplusTrace?: string,
 ): IO<RA | RB | R1, E1 | EA | EB, void> {
   return ref.modifyIO((a) =>
     f(a)

package/_src/Ref/Synchronized/constructors.ts

@@ -3,7 +3,7 @@ import { PSynchronizedInternal } from "./definition.js";
 /**
  * @tsplus static fncts.io.Ref.SynchronizedOps make
  */
-export function makeSynchronized<A>(a: Lazy<A>): UIO<Ref.Synchronized<A>> {
+export function makeSynchronized<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<Ref.Synchronized<A>> {
   return Do((_) => {
     const ref       = _(Ref.make(a));
     const semaphore = _(TSemaphore.make(1).commit);

package/_src/Ref/api/collect.ts

@@ -13,6 +13,7 @@ import { identity } from "@fncts/base/data/function";
 export function collect_<RA, RB, EA, EB, A, B, C>(
   ref: PRef<RA, RB, EA, EB, A, B>,
   pf: (_: B) => Maybe<C>,
+  __tsplusTrace?: string,
 ): PRef<RA, RB, EA, Maybe<EB>, A, C> {
   return ref.match(identity, Maybe.just, Either.right, (b) => pf(b).toEither(Nothing()));
 }

package/_src/Ref/api/dimap.ts

@@ -9,6 +9,7 @@ import type { PRef } from "../definition.js";
 export function contramap_<RA, RB, EA, EB, B, A, C>(
   ref: PRef<RA, RB, EA, EB, A, B>,
   f: (_: C) => A,
+  __tsplusTrace?: string,
 ): PRef<RA, RB, EA, EB, C, B> {
   return ref.contramapEither((c) => Either.right(f(c)));
 }
@@ -23,6 +24,7 @@ export function contramap_<RA, RB, EA, EB, B, A, C>(
 export function contramapEither_<RA, RB, EA, EB, A, B, EC, C>(
   ref: PRef<RA, RB, EA, EB, A, B>,
   f: (_: C) => Either<EC, A>,
+  __tsplusTrace?: string,
 ): PRef<RA, RB, EC | EA, EB, C, B> {
   return ref.dimapEither(f, Either.right);
 }
@@ -38,6 +40,7 @@ export function dimap_<RA, RB, EA, EB, A, B, C, D>(
   ref: PRef<RA, RB, EA, EB, A, B>,
   f: (_: C) => A,
   g: (_: B) => D,
+  __tsplusTrace?: string,
 ): PRef<RA, RB, EA, EB, C, D> {
   return ref.dimapEither(
     (c) => Either.right(f(c)),
@@ -56,6 +59,7 @@ export function dimapEither_<RA, RB, EA, EB, A, B, C, EC, D, ED>(
   ref: PRef<RA, RB, EA, EB, A, B>,
   f: (_: C) => Either<EC, A>,
   g: (_: B) => Either<ED, D>,
+  __tsplusTrace?: string,
 ): PRef<RA, RB, EC | EA, ED | EB, C, D> {
   return ref.match(
     (ea: EA | EC) => ea,
@@ -76,6 +80,7 @@ export function dimapError_<RA, RB, EA, EB, A, B, EC, ED>(
   ref: PRef<RA, RB, EA, EB, A, B>,
   f: (_: EA) => EC,
   g: (_: EB) => ED,
+  __tsplusTrace?: string,
 ): PRef<RA, RB, EC, ED, A, B> {
   return ref.match(f, g, Either.right, Either.right);
 }
@@ -90,6 +95,7 @@ export function dimapError_<RA, RB, EA, EB, A, B, EC, ED>(
 export function mapEither_<RA, RB, EA, EB, A, B, EC, C>(
   ref: PRef<RA, RB, EA, EB, A, B>,
   f: (_: B) => Either<EC, C>,
+  __tsplusTrace?: string,
 ): PRef<RA, RB, EA, EC | EB, A, C> {
   return ref.dimapEither(Either.right, f);
 }
@@ -103,6 +109,7 @@ export function mapEither_<RA, RB, EA, EB, A, B, EC, C>(
 export function map_<RA, RB, EA, EB, A, B, C>(
   ref: PRef<RA, RB, EA, EB, A, B>,
   f: (_: B) => C,
+  __tsplusTrace?: string,
 ): PRef<RA, RB, EA, EB, A, C> {
   return ref.mapEither((b) => Either.right(f(b)));
 }

package/_src/Ref/api/filter.ts

@@ -13,6 +13,7 @@ import { identity } from "@fncts/base/data/function";
 export function filterInput_<RA, RB, EA, EB, B, A, A1 extends A>(
   ref: PRef<RA, RB, EA, EB, A, B>,
   f: (_: A1) => boolean,
+  __tsplusTrace?: string,
 ): PRef<RA, RB, Maybe<EA>, EB, A1, B> {
   return ref.match(Maybe.just, identity, (a) => (f(a) ? Either.right(a) : Either.left(Nothing())), Either.right);
 }
@@ -28,6 +29,7 @@ export function filterInput_<RA, RB, EA, EB, B, A, A1 extends A>(
 export function filterOutput_<RA, RB, EA, EB, A, B>(
   ref: PRef<RA, RB, EA, EB, A, B>,
   f: (_: B) => boolean,
+  __tsplusTrace?: string,
 ): PRef<RA, RB, EA, Maybe<EB>, A, B> {
   return ref.match(identity, Maybe.just, Either.right, (b) => (f(b) ? Either.right(b) : Either.left(Nothing())));
 }

package/_src/Ref/api/get.ts

@@ -8,7 +8,10 @@ import { concrete } from "../definition.js";
  * @tsplus getter fncts.io.Ref get
  * @tsplus getter fncts.io.Ref.Synchronized get
  */
-export function get<RA, RB, EA, EB, A, B>(self: PRef<RA, RB, EA, EB, A, B>): IO<RA | RB, EA | EB, B> {
+export function get<RA, RB, EA, EB, A, B>(
+  self: PRef<RA, RB, EA, EB, A, B>,
+  __tsplusTrace?: string,
+): IO<RA | RB, EA | EB, B> {
   concrete(self);
   return self.get as IO<RA | RB, EA | EB, B>;
 }

package/_src/Ref/api/modify.ts

@@ -15,6 +15,7 @@ import { concrete } from "../definition.js";
 export function modify_<RA, RB, EA, EB, B, A>(
   ref: PRef<RA, RB, EA, EB, A, A>,
   f: (a: A) => readonly [B, A],
+  __tsplusTrace?: string,
 ): IO<RA | RB, EA | EB, B> {
   concrete(ref);
   switch (ref._tag) {
@@ -70,6 +71,7 @@ export function modifyJust_<RA, RB, EA, EB, A, B>(
   self: PRef<RA, RB, EA, EB, A, A>,
   def: B,
   f: (a: A) => Maybe<readonly [B, A]>,
+  __tsplusTrace?: string,
 ): IO<RA | RB, EA | EB, B> {
   concrete(self);
   switch (self._tag) {
@@ -87,7 +89,11 @@ export function modifyJust_<RA, RB, EA, EB, A, B>(
  * @tsplus fluent fncts.io.Ref getAndSet
  * @tsplus fluent fncts.io.Ref.Synchronized getAndSet
  */
-export function getAndSet_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, a: A): IO<RA | RB, EA | EB, A> {
+export function getAndSet_<RA, RB, EA, EB, A>(
+  self: PRef<RA, RB, EA, EB, A, A>,
+  a: A,
+  __tsplusTrace?: string,
+): IO<RA | RB, EA | EB, A> {
   concrete(self);
   switch (self._tag) {
     case "Atomic":
@@ -107,6 +113,7 @@ export function getAndSet_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>,
 export function getAndUpdate_<RA, RB, EA, EB, A>(
   self: PRef<RA, RB, EA, EB, A, A>,
   f: (a: A) => A,
+  __tsplusTrace?: string,
 ): IO<RA | RB, EA | EB, A> {
   concrete(self);
   switch (self._tag) {
@@ -128,6 +135,7 @@ export function getAndUpdate_<RA, RB, EA, EB, A>(
 export function getAndUpdateJust_<RA, RB, EA, EB, A>(
   self: PRef<RA, RB, EA, EB, A, A>,
   f: (a: A) => Maybe<A>,
+  __tsplusTrace?: string,
 ): IO<RA | RB, EA | EB, A> {
   concrete(self);
   switch (self._tag) {
@@ -147,6 +155,7 @@ export function getAndUpdateJust_<RA, RB, EA, EB, A>(
 export function update_<RA, RB, EA, EB, A>(
   self: PRef<RA, RB, EA, EB, A, A>,
   f: (a: A) => A,
+  __tsplusTrace?: string,
 ): IO<RA | RB, EA | EB, void> {
   concrete(self);
   switch (self._tag) {
@@ -167,6 +176,7 @@ export function update_<RA, RB, EA, EB, A>(
 export function updateAndGet_<RA, RB, EA, EB, A>(
   self: PRef<RA, RB, EA, EB, A, A>,
   f: (a: A) => A,
+  __tsplusTrace?: string,
 ): IO<RA | RB, EA | EB, A> {
   concrete(self);
   switch (self._tag) {
@@ -190,6 +200,7 @@ export function updateAndGet_<RA, RB, EA, EB, A>(
 export function updateJust_<RA, RB, EA, EB, A>(
   self: PRef<RA, RB, EA, EB, A, A>,
   f: (a: A) => Maybe<A>,
+  __tsplusTrace?: string,
 ): IO<RA | RB, EA | EB, void> {
   concrete(self);
   switch (self._tag) {
@@ -211,6 +222,7 @@ export function updateJust_<RA, RB, EA, EB, A>(
 export function updateJustAndGet_<RA, RB, EA, EB, A>(
   self: PRef<RA, RB, EA, EB, A, A>,
   f: (a: A) => Maybe<A>,
+  __tsplusTrace?: string,
 ): IO<RA | RB, EA | EB, A> {
   concrete(self);
   switch (self._tag) {

package/_src/Ref/api/set.ts

@@ -9,7 +9,11 @@ import { concrete } from "../definition.js";
  * @tsplus fluent fncts.io.Ref set
  * @tsplus fluent fncts.io.Ref.Synchronized set
  */
-export function set_<RA, RB, EA, EB, A, B>(self: PRef<RA, RB, EA, EB, A, B>, a: A): IO<RA | RB, EA | EB, void> {
+export function set_<RA, RB, EA, EB, A, B>(
+  self: PRef<RA, RB, EA, EB, A, B>,
+  a: A,
+  __tsplusTrace?: string,
+): IO<RA | RB, EA | EB, void> {
   concrete(self);
   return self.set(a);
 }

package/_src/Ref/constructors.ts

@@ -3,13 +3,13 @@ import { Atomic } from "./Atomic.js";
 /**
  * @tsplus static fncts.io.RefOps make
  */
-export function make<A>(a: Lazy<A>): UIO<Ref<A>> {
+export function make<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<Ref<A>> {
   return IO.succeed(unsafeMake(a()));
 }
 
 /**
  * @tsplus static fncts.io.RefOps unsafeMake
  */
-export function unsafeMake<A>(a: A): Ref.Atomic<A> {
+export function unsafeMake<A>(a: A, __tsplusTrace?: string): Ref.Atomic<A> {
   return new Atomic(a);
 }

package/_src/Ref/definition.ts

@@ -87,7 +87,7 @@ export abstract class RefInternal<RA, RB, EA, EB, A, B> implements PRef<RA, RB,
    * Writes a new value to the `Ref`, with a guarantee of immediate
    * consistency (at some cost to performance).
    */
-  abstract set(a: A): IO<RA, EA, void>;
+  abstract set(a: A, __tsplusTrace?: string): IO<RA, EA, void>;
 }
 
 /**