@fncts/io 0.0.11 → 0.0.14

package/_src/Ref/Derived.ts

@@ -4,7 +4,7 @@ import type { PRef } from "./definition.js";
 import { RefInternal } from "./definition.js";
 import { DerivedAll } from "./DerivedAll.js";
 
-export class Derived<EA, EB, A, B> extends RefInternal<unknown, unknown, EA, EB, A, B> {
+export class Derived<EA, EB, A, B> extends RefInternal<never, never, EA, EB, A, B> {
   readonly _tag = "Derived";
 
   constructor(
@@ -23,7 +23,7 @@ export class Derived<EA, EB, A, B> extends RefInternal<unknown, unknown, EA, EB,
     eb: (_: EB) => ED,
     ca: (_: C) => Either<EC, A>,
     bd: (_: B) => Either<ED, D>,
-  ): PRef<unknown, unknown, EC, ED, C, D> {
+  ): PRef<never, never, EC, ED, C, D> {
     return this.use(
       (value, getEither, setEither) =>
         new Derived<EC, ED, C, D>((f) =>
@@ -42,7 +42,7 @@ export class Derived<EA, EB, A, B> extends RefInternal<unknown, unknown, EA, EB,
     ec: (_: EB) => EC,
     ca: (_: C) => (_: B) => Either<EC, A>,
     bd: (_: B) => Either<ED, D>,
-  ): PRef<unknown, unknown, EC, ED, C, D> {
+  ): PRef<never, never, EC, ED, C, D> {
     return this.use(
       (value, getEither, setEither) =>
         new DerivedAll<EC, ED, C, D>((f) =>

package/_src/Ref/DerivedAll.ts

@@ -3,7 +3,7 @@ import type { PRef } from "./definition.js";
 
 import { RefInternal } from "./definition.js";
 
-export class DerivedAll<EA, EB, A, B> extends RefInternal<unknown, unknown, EA, EB, A, B> {
+export class DerivedAll<EA, EB, A, B> extends RefInternal<never, never, EA, EB, A, B> {
   readonly _tag = "DerivedAll";
 
   constructor(
@@ -22,7 +22,7 @@ export class DerivedAll<EA, EB, A, B> extends RefInternal<unknown, unknown, EA,
     eb: (_: EB) => ED,
     ca: (_: C) => Either<EC, A>,
     bd: (_: B) => Either<ED, D>,
-  ): PRef<unknown, unknown, EC, ED, C, D> {
+  ): PRef<never, never, EC, ED, C, D> {
     return this.use(
       (value, getEither, setEither) =>
         new DerivedAll((f) =>
@@ -41,7 +41,7 @@ export class DerivedAll<EA, EB, A, B> extends RefInternal<unknown, unknown, EA,
     ec: (_: EB) => EC,
     ca: (_: C) => (_: B) => Either<EC, A>,
     bd: (_: B) => Either<ED, D>,
-  ): PRef<unknown, unknown, EC, ED, C, D> {
+  ): PRef<never, never, EC, ED, C, D> {
     return this.use(
       (value, getEither, setEither) =>
         new DerivedAll((f) =>

package/_src/Ref/Synchronized/api.ts

@@ -15,7 +15,8 @@ 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>>,
-): PRef.Synchronized<RA, RB & RC, EA, Maybe<EB | EC>, A, C> {
+  __tsplusTrace?: string,
+): PRef.Synchronized<RA, RB | RC, EA, Maybe<EB | EC>, A, C> {
   return ref.matchIO(
     identity,
     (eb) => Just<EB | EC>(eb),
@@ -36,7 +37,8 @@ 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>,
-): PRef.Synchronized<RA & RC, RB, EC | EA, EB, C, B> {
+  __tsplusTrace?: string,
+): PRef.Synchronized<RA | RC, RB, EC | EA, EB, C, B> {
   return ref.dimapIO(f, IO.succeedNow);
 }
 
@@ -50,7 +52,8 @@ 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>,
-): PRef.Synchronized<RA & RC, RB & RD, EA | EC, EB | ED, C, D> {
+  __tsplusTrace?: string,
+): PRef.Synchronized<RA | RC, RB | RD, EA | EC, EB | ED, C, D> {
   return ref.matchIO(
     (ea: EA | EC) => ea,
     (eb: EB | ED) => eb,
@@ -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>,
-): PRef.Synchronized<RA & RC, RB, Maybe<EC | EA>, EB, A1, B> {
+  __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>,
-): 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())),
+  __tsplusTrace?: string,
+): PRef.Synchronized<RA, RB | RC, EA, Maybe<EC | EB>, A, B> {
+  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,7 +109,8 @@ 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>,
-): IO<RA & RB & R1, EA | EB | E1, A> {
+  __tsplusTrace?: string,
+): IO<RA | RB | R1, EA | EB | E1, A> {
   return ref.modifyIO((a) => f(a).map((r) => [a, r]));
 }
 
@@ -112,7 +121,8 @@ 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>>,
-): IO<RA & RB & R1, EA | EB | E1, A> {
+  __tsplusTrace?: string,
+): IO<RA | RB | R1, EA | EB | E1, A> {
   return ref.modifyIO((a) =>
     f(a)
       .getOrElse(IO.succeedNow(a))
@@ -130,7 +140,7 @@ export function matchIO_<RA, RB, EA, EB, A, B, RC, RD, EC, ED, C, D>(
   ca: (_: C) => IO<RC, EC, A>,
   bd: (_: B) => IO<RD, ED, D>,
   __tsplusTrace?: string,
-): PRef.Synchronized<RA & RC, RB & RD, EC, ED, C, D> {
+): PRef.Synchronized<RA | RC, RB | RD, EC, ED, C, D> {
   return self.matchIO(ea, eb, ca, bd);
 }
 
@@ -145,7 +155,7 @@ export function matchAllIO_<RA, RB, EA, EB, A, B, RC, RD, EC, ED, C, D>(
   ca: (_: C) => (_: B) => IO<RC, EC, A>,
   bd: (_: B) => IO<RD, ED, D>,
   __tsplusTrace?: string,
-): PRef.Synchronized<RA & RB & RC, RB & RD, EC, ED, C, D> {
+): PRef.Synchronized<RA | RB | RC, RB & RD, EC, ED, C, D> {
   return self.matchAllIO(ea, eb, ec, ca, bd);
 }
 
@@ -156,7 +166,7 @@ export function modifyIO_<RA, RB, EA, EB, A, R1, E1, B>(
   self: PRef.Synchronized<RA, RB, EA, EB, A, A>,
   f: (a: A) => IO<R1, E1, readonly [B, A]>,
   __tsplusTrace?: string,
-): IO<RA & RB & R1, EA | EB | E1, B> {
+): IO<RA | RB | R1, EA | EB | E1, B> {
   concreteSynchronized(self);
   return self.withPermit(self.unsafeGet.flatMap(f).flatMap(([b, a]) => self.unsafeSet(a).as(b)));
 }
@@ -173,7 +183,8 @@ 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]>>,
-): IO<RA & RB & R1, EA | EB | E1, B> {
+  __tsplusTrace?: string,
+): IO<RA | RB | R1, EA | EB | E1, B> {
   return ref.modifyIO((a) => f(a).getOrElse(IO.succeedNow(tuple(def, a))));
 }
 
@@ -185,7 +196,8 @@ 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>,
-): IO<RA & RB & R1, E1 | EA | EB, void> {
+  __tsplusTrace?: string,
+): IO<RA | RB | R1, E1 | EA | EB, void> {
   return ref.modifyIO((a) => f(a).map((r) => [r, r])).asUnit;
 }
 
@@ -197,7 +209,8 @@ 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>,
-): IO<RA & RB & R1, E1 | EA | EB, void> {
+  __tsplusTrace?: string,
+): IO<RA | RB | R1, E1 | EA | EB, void> {
   return ref.modifyIO((a) => f(a).map((r) => [undefined, r]));
 }
 
@@ -209,7 +222,8 @@ 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>>,
-): IO<RA & RB & R1, E1 | EA | EB, A> {
+  __tsplusTrace?: string,
+): IO<RA | RB | R1, E1 | EA | EB, A> {
   return ref.modifyIO((a) =>
     f(a)
       .getOrElse(IO.succeedNow(a))
@@ -225,7 +239,8 @@ 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>>,
-): IO<RA & RB & R1, E1 | EA | EB, void> {
+  __tsplusTrace?: string,
+): IO<RA | RB | R1, E1 | EA | EB, void> {
   return ref.modifyIO((a) =>
     f(a)
       .getOrElse(IO.succeedNow(a))

package/_src/Ref/Synchronized/constructors.ts

@@ -3,10 +3,10 @@ import { PSynchronizedInternal } from "./definition.js";
 /**
  * @tsplus static fncts.io.Ref.SynchronizedOps make
  */
-export function makeSynchronized<A>(a: Lazy<A>): UIO<Ref.Synchronized<A>> {
-  return IO.gen(function* (_) {
-    const ref       = yield* _(Ref.make(a));
-    const semaphore = yield* _(TSemaphore.make(1).commit);
-    return new PSynchronizedInternal(new Set([semaphore]), ref.get, (a) => ref.set(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);
+    return new PSynchronizedInternal(new Set([semaphore]), ref.get, (a: A) => ref.set(a));
   });
 }

package/_src/Ref/Synchronized/definition.ts

@@ -49,7 +49,7 @@ export class PSynchronizedInternal<RA, RB, EA, EB, A, B> extends RefInternal<RA,
     ca: (_: C) => (_: B) => IO<RC, EC, A>,
     bd: (_: B) => IO<RD, ED, D>,
     __tsplusTrace?: string,
-  ): PSynchronizedInternal<RA & RC & RB, RB & RD, EC, ED, C, D> {
+  ): PSynchronizedInternal<RA | RC | RB, RB | RD, EC, ED, C, D> {
     return new PSynchronizedInternal(
       this.semaphores,
       this.get.matchIO((e) => IO.failNow(eb(e)), bd),
@@ -67,7 +67,7 @@ export class PSynchronizedInternal<RA, RB, EA, EB, A, B> extends RefInternal<RA,
     ca: (_: C) => IO<RC, EC, A>,
     bd: (_: B) => IO<RD, ED, D>,
     __tsplusTrace?: string,
-  ): PSynchronizedInternal<RA & RC, RB & RD, EC, ED, C, D> {
+  ): PSynchronizedInternal<RA | RC, RB | RD, EC, ED, C, D> {
     return new PSynchronizedInternal(
       this.semaphores,
       this.unsafeGet.matchIO((e) => IO.failNow(eb(e)), bd),

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>;
+  return self.get as IO<RA | RB, EA | EB, B>;
 }

package/_src/Ref/api/modify.ts

@@ -15,7 +15,8 @@ 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],
-): IO<RA & RB, EA | EB, B> {
+  __tsplusTrace?: string,
+): IO<RA | RB, EA | EB, B> {
   concrete(ref);
   switch (ref._tag) {
     case "Atomic":
@@ -70,7 +71,8 @@ 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]>,
-): IO<RA & RB, EA | EB, B> {
+  __tsplusTrace?: string,
+): IO<RA | RB, EA | EB, B> {
   concrete(self);
   switch (self._tag) {
     case "Atomic":
@@ -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,7 +113,8 @@ 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,
-): IO<RA & RB, EA | EB, A> {
+  __tsplusTrace?: string,
+): IO<RA | RB, EA | EB, A> {
   concrete(self);
   switch (self._tag) {
     case "Atomic":
@@ -128,7 +135,8 @@ 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>,
-): IO<RA & RB, EA | EB, A> {
+  __tsplusTrace?: string,
+): IO<RA | RB, EA | EB, A> {
   concrete(self);
   switch (self._tag) {
     case "Atomic":
@@ -147,7 +155,8 @@ 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,
-): IO<RA & RB, EA | EB, void> {
+  __tsplusTrace?: string,
+): IO<RA | RB, EA | EB, void> {
   concrete(self);
   switch (self._tag) {
     case "Atomic":
@@ -167,7 +176,8 @@ 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,
-): IO<RA & RB, EA | EB, A> {
+  __tsplusTrace?: string,
+): IO<RA | RB, EA | EB, A> {
   concrete(self);
   switch (self._tag) {
     case "Atomic":
@@ -190,7 +200,8 @@ 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>,
-): IO<RA & RB, EA | EB, void> {
+  __tsplusTrace?: string,
+): IO<RA | RB, EA | EB, void> {
   concrete(self);
   switch (self._tag) {
     case "Atomic":
@@ -211,7 +222,8 @@ 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>,
-): IO<RA & RB, EA | EB, A> {
+  __tsplusTrace?: string,
+): IO<RA | RB, EA | EB, A> {
   concrete(self);
   switch (self._tag) {
     case "Atomic":

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

@@ -11,15 +11,15 @@ export type RefTypeId = typeof RefTypeId;
  */
 export interface PRef<RA, RB, EA, EB, A, B> {
   readonly _U: RefTypeId;
-  readonly _RA: (_: RA) => void;
-  readonly _RB: (_: RB) => void;
+  readonly _RA: () => RA;
+  readonly _RB: () => RB;
   readonly _EA: () => EA;
   readonly _EB: () => EB;
   readonly _A: (_: A) => void;
   readonly _B: () => B;
 }
 
-export type Ref<A> = PRef<unknown, unknown, never, never, A, A>;
+export type Ref<A> = PRef<never, never, never, never, A, A>;
 export type ERef<E, A> = PRef<unknown, unknown, E, E, A, A>;
 
 export declare namespace PRef {
@@ -27,12 +27,12 @@ export declare namespace PRef {
 }
 
 export declare namespace ERef {
-  export type Synchronized<E, A> = Synchro.PSynchronized<unknown, unknown, E, E, A, A>;
+  export type Synchronized<E, A> = Synchro.PSynchronized<never, never, E, E, A, A>;
 }
 
 export declare namespace Ref {
   export type Atomic<A> = Atomic_<A>;
-  export type Synchronized<A> = Synchro.PSynchronized<unknown, unknown, never, never, A, A>;
+  export type Synchronized<A> = Synchro.PSynchronized<never, never, never, never, A, A>;
 }
 
 /**
@@ -43,13 +43,13 @@ export interface RefOps {}
 export const Ref: RefOps = {};
 
 export abstract class RefInternal<RA, RB, EA, EB, A, B> implements PRef<RA, RB, EA, EB, A, B> {
-  readonly _U!: RefTypeId;
-  readonly _RA!: (_: RA) => void;
-  readonly _RB!: (_: RB) => void;
-  readonly _EA!: () => EA;
-  readonly _EB!: () => EB;
-  readonly _A!: (_: A) => void;
-  readonly _B!: () => B;
+  declare _U: RefTypeId;
+  declare _RA: () => RA;
+  declare _RB: () => RB;
+  declare _EA: () => EA;
+  declare _EB: () => EB;
+  declare _A: (_: A) => void;
+  declare _B: () => B;
 
   /**
    * Folds over the error and value types of the `Ref`. This is a highly
@@ -76,7 +76,7 @@ export abstract class RefInternal<RA, RB, EA, EB, A, B> implements PRef<RA, RB,
     ec: (_: EB) => EC,
     ca: (_: C) => (_: B) => Either<EC, A>,
     bd: (_: B) => Either<ED, D>,
-  ): PRef<RA & RB, RB, EC, ED, C, D>;
+  ): PRef<RA | RB, RB, EC, ED, C, D>;
 
   /**
    * Reads the value from the `Ref`.
@@ -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>;
 }
 
 /**

package/_src/STM/api/core-api.ts

@@ -5,8 +5,12 @@ import { OnFailure, OnSuccess } from "../definition.js";
  *
  * @tsplus fluent fncts.io.STM catchAll
  */
-export function catchAll_<R, E, A, R1, E1, B>(self: STM<R, E, A>, f: (e: E) => STM<R1, E1, B>): STM<R1 & R, E1, A | B> {
-  return new OnFailure<R1 & R, E, A | B, E1>(self, f);
+export function catchAll_<R, E, A, R1, E1, B>(
+  self: STM<R, E, A>,
+  f: (e: E) => STM<R1, E1, B>,
+  __tsplusTrace?: string,
+): STM<R1 | R, E1, A | B> {
+  return new OnFailure<R1 | R, E, A | B, E1>(self, f);
 }
 
 /**
@@ -15,8 +19,12 @@ export function catchAll_<R, E, A, R1, E1, B>(self: STM<R, E, A>, f: (e: E) => S
  *
  * @tsplus fluent fncts.io.STM flatMap
  */
-export function flatMap_<R, E, A, R1, E1, B>(self: STM<R, E, A>, f: (a: A) => STM<R1, E1, B>): STM<R1 & R, E | E1, B> {
-  return new OnSuccess<R1 & R, E | E1, A, B>(self, f);
+export function flatMap_<R, E, A, R1, E1, B>(
+  self: STM<R, E, A>,
+  f: (a: A) => STM<R1, E1, B>,
+  __tsplusTrace?: string,
+): STM<R1 | R, E | E1, B> {
+  return new OnSuccess<R1 | R, E | E1, A, B>(self, f);
 }
 
 /**
@@ -26,7 +34,11 @@ export function flatMap_<R, E, A, R1, E1, B>(self: STM<R, E, A>, f: (a: A) => ST
  *
  * @tsplus fluent fncts.io.STM ensuring
  */
-export function ensuring_<R, E, A, R1, B>(self: STM<R, E, A>, finalizer: STM<R1, never, B>): STM<R & R1, E, A> {
+export function ensuring_<R, E, A, R1, B>(
+  self: STM<R, E, A>,
+  finalizer: STM<R1, never, B>,
+  __tsplusTrace?: string,
+): STM<R | R1, E, A> {
   return self.matchSTM(
     (e) => finalizer.flatMap(() => STM.failNow(e)),
     (a) => finalizer.flatMap(() => STM.succeedNow(a)),
@@ -38,7 +50,7 @@ export function ensuring_<R, E, A, R1, B>(self: STM<R, E, A>, finalizer: STM<R1,
  *
  * @tsplus fluent fncts.io.STM map
  */
-export function map_<R, E, A, B>(self: STM<R, E, A>, f: (a: A) => B): STM<R, E, B> {
+export function map_<R, E, A, B>(self: STM<R, E, A>, f: (a: A) => B, __tsplusTrace?: string): STM<R, E, B> {
   return self.flatMap((a) => STM.succeedNow(f(a)));
 }
 
@@ -52,7 +64,8 @@ export function matchSTM_<R, E, A, R1, E1, B, R2, E2, C>(
   self: STM<R, E, A>,
   g: (e: E) => STM<R2, E2, C>,
   f: (a: A) => STM<R1, E1, B>,
-): STM<R1 & R2 & R, E1 | E2, B | C> {
+  __tsplusTrace?: string,
+): STM<R1 | R2 | R, E1 | E2, B | C> {
   return self
     .map(Either.right)
     .catchAll((e) => g(e).map(Either.left))

package/_src/STM/api/core-constructors.ts

@@ -5,7 +5,7 @@ import { Effect, FailException, InterruptException, RetryException, Succeed, Suc
  *
  * @tsplus static fncts.io.STMOps failNow
  */
-export function failNow<E>(e: E): STM<unknown, E, never> {
+export function failNow<E>(e: E, __tsplusTrace?: string): STM<never, E, never> {
   return fail(e);
 }
 
@@ -14,7 +14,7 @@ export function failNow<E>(e: E): STM<unknown, E, never> {
  *
  * @tsplus static fncts.io.STMOps fail
  */
-export function fail<E>(e: Lazy<E>): STM<unknown, E, never> {
+export function fail<E>(e: Lazy<E>, __tsplusTrace?: string): STM<never, E, never> {
   return new Effect(() => {
     throw new FailException(e());
   });
@@ -25,14 +25,14 @@ export function fail<E>(e: Lazy<E>): STM<unknown, E, never> {
  *
  * @tsplus static fncts.io.STMOps fiberId
  */
-export const fiberId: STM<unknown, never, FiberId> = new Effect((_, fiberId) => fiberId);
+export const fiberId: STM<never, never, FiberId> = new Effect((_, fiberId) => fiberId);
 
 /**
  * Interrupts the fiber running the effect with the specified fiber id.
  *
  * @tsplus static fncts.io.STMOps interruptAs
  */
-export function interruptAs(fiberId: FiberId): STM<unknown, never, never> {
+export function interruptAs(fiberId: FiberId, __tsplusTrace?: string): STM<never, never, never> {
   return new Effect(() => {
     throw new InterruptException(fiberId);
   });
@@ -41,7 +41,7 @@ export function interruptAs(fiberId: FiberId): STM<unknown, never, never> {
 /**
  * @tsplus static fncts.io.STMOps retry
  */
-export const retry: STM<unknown, never, never> = new Effect(() => {
+export const retry: STM<never, never, never> = new Effect(() => {
   throw new RetryException();
 });
 
@@ -51,7 +51,7 @@ export const retry: STM<unknown, never, never> = new Effect(() => {
  * @tsplus static fncts.io.STMOps succeed
  * @tsplus static fncts.io.STMOps __call
  */
-export function succeed<A>(effect: Lazy<A>): STM<unknown, never, A> {
+export function succeed<A>(effect: Lazy<A>, __tsplusTrace?: string): STM<never, never, A> {
   return new Succeed(effect);
 }
 
@@ -60,6 +60,6 @@ export function succeed<A>(effect: Lazy<A>): STM<unknown, never, A> {
  *
  * @tsplus static fncts.io.STMOps succeedNow
  */
-export function succeedNow<A>(a: A): STM<unknown, never, A> {
+export function succeedNow<A>(a: A, __tsplusTrace?: string): STM<never, never, A> {
   return new SucceedNow(a);
 }