@fncts/io 0.0.11 → 0.0.14

package/_src/Future/api.ts

@@ -8,7 +8,7 @@ import { Done, FutureStateTag, Pending } from "@fncts/io/Future/definition";
  *
  * @tsplus fluent fncts.io.Future done
  */
-export function done_<E, A>(future: Future<E, A>, exit: Exit<E, A>): UIO<boolean> {
+export function done_<E, A>(future: Future<E, A>, exit: Exit<E, A>, __tsplusTrace?: string): UIO<boolean> {
   return future.fulfillWith(IO.fromExitNow(exit));
 }
 
@@ -18,7 +18,7 @@ export function done_<E, A>(future: Future<E, A>, exit: Exit<E, A>): UIO<boolean
  *
  * @tsplus fluent fncts.io.Future fail
  */
-export function fail_<E, A>(future: Future<E, A>, e: E): UIO<boolean> {
+export function fail_<E, A>(future: Future<E, A>, e: E, __tsplusTrace?: string): UIO<boolean> {
   return future.fulfillWith(IO.failNow(e));
 }
 
@@ -28,7 +28,7 @@ export function fail_<E, A>(future: Future<E, A>, e: E): UIO<boolean> {
  *
  * @tsplus fluent fncts.io.Future failCause
  */
-export function failCause_<E, A>(future: Future<E, A>, cause: Cause<E>): UIO<boolean> {
+export function failCause_<E, A>(future: Future<E, A>, cause: Cause<E>, __tsplusTrace?: string): UIO<boolean> {
   return future.fulfillWith(IO.failCauseNow(cause));
 }
 
@@ -41,7 +41,11 @@ export function failCause_<E, A>(future: Future<E, A>, cause: Cause<E>): UIO<boo
  *
  * @tsplus fluent fncts.io.Future fulfill
  */
-export function fulfill_<R, E, A>(future: Future<E, A>, io: IO<R, E, A>): IO<R, never, boolean> {
+export function fulfill_<R, E, A>(
+  future: Future<E, A>,
+  io: IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R, never, boolean> {
   return IO.uninterruptibleMask(({ restore }) => restore(io).result.flatMap((exit) => future.done(exit)));
 }
 
@@ -60,7 +64,7 @@ export function fulfill_<R, E, A>(future: Future<E, A>, io: IO<R, E, A>): IO<R,
  *
  * @tsplus fluent fncts.io.Future fulfillWith
  */
-export function fulfillWith_<E, A>(future: Future<E, A>, io: FIO<E, A>): UIO<boolean> {
+export function fulfillWith_<E, A>(future: Future<E, A>, io: FIO<E, A>, __tsplusTrace?: string): UIO<boolean> {
   return IO.succeed(() => {
     switch (future.state._tag) {
       case FutureStateTag.Done: {
@@ -84,7 +88,7 @@ export function fulfillWith_<E, A>(future: Future<E, A>, io: FIO<E, A>): UIO<boo
  *
  * @tsplus fluent fncts.io.Future halt
  */
-export function halt_<E, A>(future: Future<E, A>, defect: unknown): UIO<boolean> {
+export function halt_<E, A>(future: Future<E, A>, defect: unknown, __tsplusTrace?: string): UIO<boolean> {
   return future.fulfillWith(IO.haltNow(defect));
 }
 
@@ -94,7 +98,7 @@ export function halt_<E, A>(future: Future<E, A>, defect: unknown): UIO<boolean>
  *
  * @tsplus getter fncts.io.Future interrupt
  */
-export function interrupt<E, A>(future: Future<E, A>): UIO<boolean> {
+export function interrupt<E, A>(future: Future<E, A>, __tsplusTrace?: string): UIO<boolean> {
   return IO.fiberId.flatMap((id) => future.fulfillWith(IO.interruptAs(id)));
 }
 
@@ -104,7 +108,7 @@ export function interrupt<E, A>(future: Future<E, A>): UIO<boolean> {
  *
  * @tsplus fluent fncts.io.Future interruptAs
  */
-export function interruptAs_<E, A>(future: Future<E, A>, id: FiberId): UIO<boolean> {
+export function interruptAs_<E, A>(future: Future<E, A>, id: FiberId, __tsplusTrace?: string): UIO<boolean> {
   return future.fulfillWith(IO.interruptAs(id));
 }
 
@@ -114,7 +118,7 @@ export function interruptAs_<E, A>(future: Future<E, A>, id: FiberId): UIO<boole
  *
  * @tsplus getter fncts.io.Future isDone
  */
-export function isDone<E, A>(future: Future<E, A>): UIO<boolean> {
+export function isDone<E, A>(future: Future<E, A>, __tsplusTrace?: string): UIO<boolean> {
   return IO.succeed(future.state._tag === FutureStateTag.Done);
 }
 
@@ -124,7 +128,7 @@ export function isDone<E, A>(future: Future<E, A>): UIO<boolean> {
  *
  * @tsplus getter fncts.io.Future poll
  */
-export function poll<E, A>(future: Future<E, A>): UIO<Maybe<FIO<E, A>>> {
+export function poll<E, A>(future: Future<E, A>, __tsplusTrace?: string): UIO<Maybe<FIO<E, A>>> {
   return IO.succeed(() => {
     switch (future.state._tag) {
       case FutureStateTag.Done: {
@@ -142,7 +146,7 @@ export function poll<E, A>(future: Future<E, A>): UIO<Maybe<FIO<E, A>>> {
  *
  * @tsplus fluent fncts.io.Future succeed
  */
-export function succeed_<A, E>(future: Future<E, A>, a: A) {
+export function succeed_<A, E>(future: Future<E, A>, a: A, __tsplusTrace?: string) {
   return future.fulfillWith(IO.succeedNow(a));
 }
 
@@ -152,7 +156,7 @@ export function succeed_<A, E>(future: Future<E, A>, a: A) {
  *
  * @tsplus fluent fncts.io.Future unsafeDone
  */
-export function unsafeDone_<E, A>(future: Future<E, A>, io: FIO<E, A>) {
+export function unsafeDone_<E, A>(future: Future<E, A>, io: FIO<E, A>, __tsplusTrace?: string) {
   if (future.state._tag === FutureStateTag.Pending) {
     const state  = future.state;
     future.state = new Done(io);
@@ -165,7 +169,7 @@ export function unsafeDone_<E, A>(future: Future<E, A>, io: FIO<E, A>) {
 /**
  * @tsplus fluent fncts.io.Future unsafeSucceed
  */
-export function unsafeSucceed_<A>(future: Future<never, A>, a: A): void {
+export function unsafeSucceed_<A>(future: Future<never, A>, a: A, __tsplusTrace?: string): void {
   future.unsafeDone(IO.succeedNow(a));
 }
 
@@ -175,8 +179,8 @@ export function unsafeSucceed_<A>(future: Future<never, A>, a: A): void {
  *
  * @tsplus getter fncts.io.Future await
  */
-export function wait<E, A>(future: Future<E, A>): IO<unknown, E, A> {
-  return IO.asyncInterrupt<unknown, E, A>((k) => {
+export function wait<E, A>(future: Future<E, A>, __tsplusTrace?: string): IO<never, E, A> {
+  return IO.asyncInterrupt<never, E, A>((k) => {
     switch (future.state._tag) {
       case FutureStateTag.Done: {
         return Either.right(future.state.value);
@@ -189,7 +193,11 @@ export function wait<E, A>(future: Future<E, A>): IO<unknown, E, A> {
   }, future.blockingOn);
 }
 
-function interruptJoiner<E, A>(future: Future<E, A>, joiner: (a: FIO<E, A>) => void): Canceler<unknown> {
+function interruptJoiner<E, A>(
+  future: Future<E, A>,
+  joiner: (a: FIO<E, A>) => void,
+  __tsplusTrace?: string,
+): Canceler<never> {
   return IO.succeed(() => {
     switch (future.state._tag) {
       case FutureStateTag.Pending: {

package/_src/Future/constructors.ts

@@ -5,7 +5,7 @@ import { Future, Pending } from "@fncts/io/Future/definition";
  *
  * @tsplus static fncts.io.FutureOps make
  */
-export function make<E, A>(): IO<unknown, never, Future<E, A>> {
+export function make<E, A>(__tsplusTrace?: string): IO<never, never, Future<E, A>> {
   return IO.fiberId.flatMap((id) => Future.makeAs<E, A>(id));
 }
 
@@ -14,7 +14,7 @@ export function make<E, A>(): IO<unknown, never, Future<E, A>> {
  *
  * @tsplus static fncts.io.FutureOps makeAs
  */
-export function makeAs<E, A>(fiberId: FiberId) {
+export function makeAs<E, A>(fiberId: FiberId, __tsplusTrace?: string) {
   return IO.succeed(unsafeMake<E, A>(fiberId));
 }
 

package/_src/Hub/api.ts

@@ -16,7 +16,10 @@ import { QueueInternal } from "@fncts/io/Queue";
  *
  * @tsplus getter fncts.io.Hub awaitShutdown
  */
-export function awaitShutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): UIO<void> {
+export function awaitShutdown<RA, RB, EA, EB, A, B>(
+  self: PHub<RA, RB, EA, EB, A, B>,
+  __tsplusTrace?: string,
+): UIO<void> {
   concrete(self);
   return self.awaitShutdown;
 }
@@ -26,7 +29,7 @@ export function awaitShutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A
  *
  * @tsplus getter fncts.io.Hub capacity
  */
-export function capacity<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): number {
+export function capacity<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): number {
   concrete(self);
   return self.capacity;
 }
@@ -40,13 +43,14 @@ export function capacity<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>)
 export function contramapIO_<RA, RB, RC, EA, EB, EC, A, B, C>(
   self: PHub<RA, RB, EA, EB, A, B>,
   f: (c: C) => IO<RC, EC, A>,
-): PHub<RC & RA, RB, EA | EC, EB, C, B> {
+  __tsplusTrace?: string,
+): PHub<RC | RA, RB, EA | EC, EB, C, B> {
   return self.dimapIO(f, IO.succeedNow);
 }
 
 class DimapIO<RA, RB, RC, RD, EA, EB, EC, ED, A, B, C, D> extends PHubInternal<
-  RC & RA,
-  RD & RB,
+  RC | RA,
+  RD | RB,
   EA | EC,
   EB | ED,
   C,
@@ -79,6 +83,7 @@ export function dimap_<RA, RB, EA, EB, A, B, C, D>(
   self: PHub<RA, RB, EA, EB, A, B>,
   f: (c: C) => A,
   g: (b: B) => D,
+  __tsplusTrace?: string,
 ): PHub<RA, RB, EA, EB, C, D> {
   return self.dimapIO(
     (c) => IO.succeedNow(f(c)),
@@ -96,12 +101,13 @@ export function dimapIO_<RA, RB, RC, RD, EA, EB, EC, ED, A, B, C, D>(
   source: PHub<RA, RB, EA, EB, A, B>,
   f: (c: C) => IO<RC, EC, A>,
   g: (b: B) => IO<RD, ED, D>,
-): PHub<RC & RA, RD & RB, EA | EC, EB | ED, C, D> {
+  __tsplusTrace?: string,
+): PHub<RC | RA, RD | RB, EA | EC, EB | ED, C, D> {
   concrete(source);
   return new DimapIO(source, f, g);
 }
 
-class FilterInputIO<RA, RA1, RB, EA, EA1, EB, A, B> extends PHubInternal<RA & RA1, RB, EA | EA1, EB, A, B> {
+class FilterInputIO<RA, RA1, RB, EA, EA1, EB, A, B> extends PHubInternal<RA | RA1, RB, EA | EA1, EB, A, B> {
   constructor(readonly source: PHubInternal<RA, RB, EA, EB, A, B>, readonly f: (a: A) => IO<RA1, EA1, boolean>) {
     super();
   }
@@ -125,7 +131,8 @@ class FilterInputIO<RA, RA1, RB, EA, EA1, EB, A, B> extends PHubInternal<RA & RA
 export function filterInputIO_<RA, RA1, RB, EA, EA1, EB, A, B>(
   source: PHub<RA, RB, EA, EB, A, B>,
   f: (a: A) => IO<RA1, EA1, boolean>,
-): PHub<RA & RA1, RB, EA | EA1, EB, A, B> {
+  __tsplusTrace?: string,
+): PHub<RA | RA1, RB, EA | EA1, EB, A, B> {
   concrete(source);
   return new FilterInputIO(source, f);
 }
@@ -135,11 +142,15 @@ export function filterInputIO_<RA, RA1, RB, EA, EA1, EB, A, B>(
  *
  * @tsplus fluent fncts.io.Hub filterInput
  */
-export function filterInput_<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, f: (a: A) => boolean) {
+export function filterInput_<RA, RB, EA, EB, A, B>(
+  self: PHub<RA, RB, EA, EB, A, B>,
+  f: (a: A) => boolean,
+  __tsplusTrace?: string,
+) {
   return self.filterInputIO((a) => IO.succeedNow(f(a)));
 }
 
-class FilterOutputIO<RA, RB, RB1, EA, EB, EB1, A, B> extends PHubInternal<RA, RB & RB1, EA, EB | EB1, A, B> {
+class FilterOutputIO<RA, RB, RB1, EA, EB, EB1, A, B> extends PHubInternal<RA, RB | RB1, EA, EB | EB1, A, B> {
   constructor(readonly source: PHubInternal<RA, RB, EA, EB, A, B>, readonly f: (a: B) => IO<RB1, EB1, boolean>) {
     super();
   }
@@ -162,7 +173,8 @@ class FilterOutputIO<RA, RB, RB1, EA, EB, EB1, A, B> extends PHubInternal<RA, RB
 export function filterOutputIO_<RA, RB, RB1, EA, EB, EB1, A, B>(
   source: PHub<RA, RB, EA, EB, A, B>,
   f: (a: B) => IO<RB1, EB1, boolean>,
-): PHub<RA, RB & RB1, EA, EB | EB1, A, B> {
+  __tsplusTrace?: string,
+): PHub<RA, RB | RB1, EA, EB | EB1, A, B> {
   concrete(source);
   return new FilterOutputIO(source, f);
 }
@@ -175,6 +187,7 @@ export function filterOutputIO_<RA, RB, RB1, EA, EB, EB1, A, B>(
 export function filterOutput_<RA, RB, EA, EB, A, B>(
   self: PHub<RA, RB, EA, EB, A, B>,
   f: (b: B) => boolean,
+  __tsplusTrace?: string,
 ): PHub<RA, RB, EA, EB, A, B> {
   return self.filterOutputIO((b) => IO.succeedNow(f(b)));
 }
@@ -184,7 +197,10 @@ export function filterOutput_<RA, RB, EA, EB, A, B>(
  *
  * @tsplus getter fncts.io.Hub isShutdown
  */
-export function isShutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): UIO<boolean> {
+export function isShutdown<RA, RB, EA, EB, A, B>(
+  self: PHub<RA, RB, EA, EB, A, B>,
+  __tsplusTrace?: string,
+): UIO<boolean> {
   concrete(self);
   return self.isShutdown;
 }
@@ -198,7 +214,7 @@ export function isShutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B
  *
  * @tsplus static fncts.io.HubOps makeBounded
  */
-export function makeBounded<A>(requestedCapacity: number): UIO<Hub<A>> {
+export function makeBounded<A>(requestedCapacity: number, __tsplusTrace?: string): UIO<Hub<A>> {
   return IO.succeed(HubInternal.makeBounded<A>(requestedCapacity)).flatMap((hub) =>
     makeHubInternal(hub, new BackPressure()),
   );
@@ -212,7 +228,7 @@ export function makeBounded<A>(requestedCapacity: number): UIO<Hub<A>> {
  *
  * @tsplus static fncts.io.HubOps makeDropping
  */
-export function makeDropping<A>(requestedCapacity: number): UIO<Hub<A>> {
+export function makeDropping<A>(requestedCapacity: number, __tsplusTrace?: string): UIO<Hub<A>> {
   return IO.succeed(HubInternal.makeBounded<A>(requestedCapacity)).flatMap((hub) =>
     makeHubInternal(hub, new Dropping()),
   );
@@ -226,7 +242,7 @@ export function makeDropping<A>(requestedCapacity: number): UIO<Hub<A>> {
  *
  * @tsplus static fncts.io.HubOps makeSliding
  */
-export function makeSliding<A>(requestedCapacity: number): UIO<Hub<A>> {
+export function makeSliding<A>(requestedCapacity: number, __tsplusTrace?: string): UIO<Hub<A>> {
   return IO.succeed(HubInternal.makeBounded<A>(requestedCapacity)).flatMap((hub) =>
     makeHubInternal(hub, new Sliding()),
   );
@@ -237,7 +253,7 @@ export function makeSliding<A>(requestedCapacity: number): UIO<Hub<A>> {
  *
  * @tsplus static fncts.io.HubOps makeUnbounded
  */
-export function makeUnbounded<A>(): UIO<Hub<A>> {
+export function makeUnbounded<A>(__tsplusTrace?: string): UIO<Hub<A>> {
   return IO.succeed(HubInternal.makeUnbounded<A>()).flatMap((hub) => makeHubInternal(hub, new Dropping()));
 }
 
@@ -249,6 +265,7 @@ export function makeUnbounded<A>(): UIO<Hub<A>> {
 export function map_<RA, RB, EA, EB, A, B, C>(
   self: PHub<RA, RB, EA, EB, A, B>,
   f: (b: B) => C,
+  __tsplusTrace?: string,
 ): PHub<RA, RB, EA, EB, A, C> {
   return self.mapIO((b) => IO.succeedNow(f(b)));
 }
@@ -262,7 +279,8 @@ export function map_<RA, RB, EA, EB, A, B, C>(
 export function mapIO_<RA, RB, RC, EA, EB, EC, A, B, C>(
   self: PHub<RA, RB, EA, EB, A, B>,
   f: (b: B) => IO<RC, EC, C>,
-): PHub<RA, RC & RB, EA, EB | EC, A, C> {
+  __tsplusTrace?: string,
+): PHub<RA, RC | RB, EA, EB | EC, A, C> {
   return self.dimapIO(IO.succeedNow, f);
 }
 
@@ -279,7 +297,7 @@ class ToQueue<RA, RB, EA, EB, A, B> extends QueueInternal<RA, never, EA, unknown
   takeAll       = IO.succeedNow(Conc.empty<never>());
   offer         = (a: A): IO<RA, EA, boolean> => this.source.publish(a);
   offerAll      = (as: Iterable<A>): IO<RA, EA, boolean> => this.source.publishAll(as);
-  takeUpTo      = (): IO<unknown, never, Conc<never>> => IO.succeedNow(Conc.empty());
+  takeUpTo      = (): IO<never, never, Conc<never>> => IO.succeedNow(Conc.empty());
 }
 
 /**
@@ -288,7 +306,11 @@ class ToQueue<RA, RB, EA, EB, A, B> extends QueueInternal<RA, never, EA, unknown
  *
  * @tsplus fluent fncts.io.Hub publish
  */
-export function publish_<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, a: A): IO<RA, EA, boolean> {
+export function publish_<RA, RB, EA, EB, A, B>(
+  self: PHub<RA, RB, EA, EB, A, B>,
+  a: A,
+  __tsplusTrace?: string,
+): IO<RA, EA, boolean> {
   concrete(self);
   return self.publish(a);
 }
@@ -302,6 +324,7 @@ export function publish_<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>,
 export function publishAll_<RA, RB, EA, EB, A, B>(
   self: PHub<RA, RB, EA, EB, A, B>,
   as: Iterable<A>,
+  __tsplusTrace?: string,
 ): IO<RA, EA, boolean> {
   concrete(self);
   return self.publishAll(as);
@@ -312,7 +335,7 @@ export function publishAll_<RA, RB, EA, EB, A, B>(
  *
  * @tsplus getter fncts.io.Hub shutdown
  */
-export function shutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): UIO<void> {
+export function shutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<void> {
   concrete(self);
   return self.shutdown;
 }
@@ -326,7 +349,8 @@ export function shutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>)
  */
 export function subscribe<RA, RB, EA, EB, A, B>(
   self: PHub<RA, RB, EA, EB, A, B>,
-): IO<Has<Scope>, never, Hub.Dequeue<RB, EB, B>> {
+  __tsplusTrace?: string,
+): IO<Scope, never, Hub.Dequeue<RB, EB, B>> {
   concrete(self);
   return self.subscribe;
 }
@@ -336,7 +360,7 @@ export function subscribe<RA, RB, EA, EB, A, B>(
  *
  * @tsplus getter fncts.io.Hub size
  */
-export function size<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): UIO<number> {
+export function size<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<number> {
   concrete(self);
   return self.size;
 }
@@ -346,7 +370,10 @@ export function size<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): UI
  *
  * @tsplus getter fncts.io.Hub toQueue
  */
-export function toQueue<RA, RB, EA, EB, A, B>(source: PHub<RA, RB, EA, EB, A, B>): Hub.Enqueue<RA, EA, A> {
+export function toQueue<RA, RB, EA, EB, A, B>(
+  source: PHub<RA, RB, EA, EB, A, B>,
+  __tsplusTrace?: string,
+): Hub.Enqueue<RA, EA, A> {
   concrete(source);
   return new ToQueue(source);
 }

package/_src/Hub/definition.ts

@@ -13,8 +13,8 @@ export type HubTypeId = typeof HubTypeId;
  */
 export interface PHub<RA, RB, EA, EB, A, B> {
   readonly _typeId: HubTypeId;
-  readonly _RA: (_: RA) => void;
-  readonly _RB: (_: RB) => void;
+  readonly _RA: () => RA;
+  readonly _RB: () => RB;
   readonly _EA: () => EA;
   readonly _EB: () => EB;
   readonly _A: (_: A) => void;
@@ -24,7 +24,7 @@ export interface PHub<RA, RB, EA, EB, A, B> {
 /**
  * @tsplus type fncts.io.Hub
  */
-export interface Hub<A> extends PHub<unknown, unknown, never, never, A, A> {}
+export interface Hub<A> extends PHub<never, never, never, never, A, A> {}
 
 /**
  * @tsplus type fncts.io.HubOps
@@ -40,8 +40,8 @@ export declare namespace Hub {
 
 export abstract class PHubInternal<RA, RB, EA, EB, A, B> implements PHub<RA, RB, EA, EB, A, B> {
   _typeId: HubTypeId = HubTypeId;
-  readonly _RA!: (_: RA) => void;
-  readonly _RB!: (_: RB) => void;
+  readonly _RA!: () => RA;
+  readonly _RB!: () => RB;
   readonly _EA!: () => EA;
   readonly _EB!: () => EB;
   readonly _A!: (_: A) => void;
@@ -89,7 +89,7 @@ export abstract class PHubInternal<RA, RB, EA, EB, A, B> implements PHub<RA, RB,
    * can be evaluated multiple times within the scope of the managed to take a
    * message from the hub each time.
    */
-  abstract subscribe: IO<Has<Scope>, never, Hub.Dequeue<RB, EB, B>>;
+  abstract subscribe: IO<Scope, never, Hub.Dequeue<RB, EB, B>>;
 }
 
 /**

package/_src/Hub/internal.ts

@@ -125,10 +125,10 @@ export class BackPressure<A> extends 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 publishers = yield* _(IO.succeed(self.publishers.unsafeDequeueAll));
-      yield* _(IO.foreachC(publishers, ([_, future, last]) => (last ? future.interruptAs(fiberId) : IO.unit)));
+    return Do((_) => {
+      const fiberId    = _(IO.fiberId);
+      const publishers = _(IO.succeed(self.publishers.unsafeDequeueAll));
+      _(IO.foreachC(publishers, ([_, future, last]) => (last ? future.interruptAs(fiberId) : IO.unit)));
     });
   }
 
@@ -254,7 +254,7 @@ export class Sliding<A> extends Strategy<A> {
   }
 }
 
-class UnsafeSubscription<A> extends QueueInternal<never, unknown, unknown, never, never, A> {
+class UnsafeSubscription<A> extends QueueInternal<never, never, unknown, never, never, A> {
   constructor(
     readonly hub: HubInternal<A>,
     readonly subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>,
@@ -294,7 +294,7 @@ class UnsafeSubscription<A> extends QueueInternal<never, unknown, unknown, never
 
   offerAll = (_: Iterable<never>): IO<never, unknown, boolean> => IO.succeedNow(false);
 
-  take: IO<unknown, never, A> = IO.fiberId.flatMap((fiberId) =>
+  take: IO<never, never, A> = IO.fiberId.flatMap((fiberId) =>
     IO.defer(() => {
       if (this.shutdownFlag.get) {
         return IO.interrupt;
@@ -327,7 +327,7 @@ class UnsafeSubscription<A> extends QueueInternal<never, unknown, unknown, never
     }),
   );
 
-  takeAll: IO<unknown, never, Conc<A>> = IO.defer(() => {
+  takeAll: IO<never, never, Conc<A>> = IO.defer(() => {
     if (this.shutdownFlag.get) {
       return IO.interrupt;
     }
@@ -339,7 +339,7 @@ class UnsafeSubscription<A> extends QueueInternal<never, unknown, unknown, never
     return IO.succeedNow(as);
   });
 
-  takeUpTo = (n: number): IO<unknown, never, Conc<A>> => {
+  takeUpTo = (n: number): IO<never, never, Conc<A>> => {
     return IO.defer(() => {
       if (this.shutdownFlag.get) {
         return IO.interrupt;
@@ -395,7 +395,7 @@ export function subscribersHashSet<A>(): HashSet<
   return HashSet.empty<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>();
 }
 
-class UnsafeHub<A> extends PHubInternal<unknown, unknown, never, never, A, A> {
+class UnsafeHub<A> extends PHubInternal<never, never, never, never, A, A> {
   constructor(
     readonly hub: HubInternal<A>,
     readonly subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>,
@@ -431,14 +431,14 @@ class UnsafeHub<A> extends PHubInternal<unknown, unknown, never, never, A, A> {
     return IO.succeed(this.hub.size());
   });
 
-  subscribe: IO<Has<Scope>, never, Queue.Dequeue<A>> = IO.acquireRelease(
+  subscribe: IO<Scope, never, Queue.Dequeue<A>> = IO.acquireRelease(
     makeSubscription(this.hub, this.subscribers, this.strategy).tap((dequeue) =>
       this.scope.addFinalizer(dequeue.shutdown),
     ),
     (dequeue) => dequeue.shutdown,
   );
 
-  publish = (a: A): IO<unknown, never, boolean> =>
+  publish = (a: A): IO<never, never, boolean> =>
     IO.defer(() => {
       if (this.shutdownFlag.get) {
         return IO.interrupt;
@@ -452,7 +452,7 @@ class UnsafeHub<A> extends PHubInternal<unknown, unknown, never, never, A, A> {
       return this.strategy.handleSurplus(this.hub, this.subscribers, Conc.single(a), this.shutdownFlag);
     });
 
-  publishAll = (as: Iterable<A>): IO<unknown, never, boolean> =>
+  publishAll = (as: Iterable<A>): IO<never, never, boolean> =>
     IO.defer(() => {
       if (this.shutdownFlag.get) {
         return IO.interrupt;
@@ -485,9 +485,9 @@ export function unsafeMakeHub<A>(
 }
 
 export function makeHubInternal<A>(hub: HubInternal<A>, strategy: Strategy<A>): UIO<Hub<A>> {
-  return IO.gen(function* (_) {
-    const scope  = yield* _(Scope.make);
-    const future = yield* _(Future.make<never, void>());
+  return Do((_) => {
+    const scope  = _(Scope.make);
+    const future = _(Future.make<never, void>());
     return unsafeMakeHub(hub, subscribersHashSet(), scope, future, new AtomicBoolean(false), strategy);
   });
 }

package/_src/IO/api/acquireRelease.ts

@@ -5,6 +5,7 @@
 export function acquireRelease<R, E, A, R1>(
   acquire: Lazy<IO<R, E, A>>,
   release: (a: A) => IO<R1, never, any>,
-): IO<R & R1 & Has<Scope>, E, A> {
+  __tsplusTrace?: string,
+): IO<R | R1 | Scope, E, A> {
   return IO.acquireReleaseExit(acquire, (a, _) => release(a));
 }

package/_src/IO/api/acquireReleaseExit.ts

@@ -6,6 +6,6 @@ export function acquireReleaseExit<R, E, A, R1>(
   acquire: Lazy<IO<R, E, A>>,
   release: (a: A, exit: Exit<any, any>) => IO<R1, never, any>,
   __tsplusTrace?: string,
-): IO<R & R1 & Has<Scope>, E, A> {
+): IO<R | R1 | Scope, E, A> {
   return IO.uninterruptible(IO.defer(acquire).tap((a) => IO.addFinalizerExit((exit) => release(a, exit))));
 }

package/_src/IO/api/acquireReleaseInterruptible.ts

@@ -5,6 +5,6 @@ export function acquireReleaseInterruptible<R, E, A, R1>(
   acquire: Lazy<IO<R, E, A>>,
   release: IO<R1, never, any>,
   __tsplusTrace?: string,
-): IO<R & R1 & Has<Scope>, E, A> {
+): IO<R | R1 | Scope, E, A> {
   return IO.acquireReleaseInterruptibleExit(acquire, () => release);
 }

package/_src/IO/api/acquireReleaseInterruptibleExit.ts

@@ -5,6 +5,6 @@ export function acquireReleaseInterruptibleExit<R, E, A, R1>(
   acquire: Lazy<IO<R, E, A>>,
   release: (exit: Exit<any, any>) => IO<R1, never, any>,
   __tsplusTrace?: string,
-): IO<R & R1 & Has<Scope>, E, A> {
+): IO<R | R1 | Scope, E, A> {
   return IO.defer(acquire).ensuring(IO.addFinalizerExit(release));
 }

package/_src/IO/api/addFinalizer.ts

@@ -1,9 +1,6 @@
 /**
  * @tsplus static fncts.io.IOOps addFinalizer
  */
-export function addFinalizer<R>(
-  finalizer: Lazy<URIO<R, any>>,
-  __tsplusTrace?: string,
-): IO<R & Has<Scope>, never, void> {
+export function addFinalizer<R>(finalizer: Lazy<URIO<R, any>>, __tsplusTrace?: string): IO<R | Scope, never, void> {
   return IO.addFinalizerExit(() => finalizer());
 }

package/_src/IO/api/addFinalizerExit.ts

@@ -3,10 +3,11 @@
  */
 export function addFinalizerExit<R>(
   finalizer: (exit: Exit<any, any>) => URIO<R, any>,
-): IO<R & Has<Scope>, never, void> {
-  return IO.gen(function* (_) {
-    const environment = yield* _(IO.environment<R>());
-    const scope       = yield* _(IO.scope);
-    yield* _(scope.addFinalizerExit(Finalizer.get((exit) => finalizer(exit).provideEnvironment(environment))));
+  __tsplusTrace?: string,
+): IO<R | Scope, never, void> {
+  return Do((_) => {
+    const environment = _(IO.environment<R>());
+    const scope       = _(IO.scope);
+    _(scope.addFinalizerExit(Finalizer.get((exit) => finalizer(exit).provideEnvironment(environment))));
   });
 }

package/_src/IO/api/asyncIO.ts

@@ -1,7 +1,10 @@
 /**
  * @tsplus static fncts.io.IOOps asyncIO
  */
-export function asyncIO<R, E, A>(register: (k: (_: IO<R, E, A>) => void) => IO<R, E, void>): IO<R, E, A> {
+export function asyncIO<R, E, A>(
+  register: (k: (_: IO<R, E, A>) => void) => IO<R, E, void>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
   return Do((Δ) => {
     const f = Δ(Future.make<E, A>());
     const r = Δ(IO.runtime<R>());

package/_src/IO/api/bracket.ts

@@ -25,6 +25,7 @@ export function bracket_<R, E, A, R1, E1, A1, R2, E2, A2>(
   acquire: Lazy<IO<R, E, A>>,
   use: (a: A) => IO<R1, E1, A1>,
   release: (a: A) => IO<R2, E2, A2>,
-): IO<R & R1 & R2, E | E1 | E2, A1> {
+  __tsplusTrace?: string,
+): IO<R | R1 | R2, E | E1 | E2, A1> {
   return IO.bracketExit(acquire, use, release);
 }

package/_src/IO/api/bracketExit.ts

@@ -12,7 +12,8 @@ export function bracketExit_<R, E, A, E1, R1, A1, R2, E2>(
   acquire: Lazy<IO<R, E, A>>,
   use: (a: A) => IO<R1, E1, A1>,
   release: (a: A, e: Exit<E1, A1>) => IO<R2, E2, any>,
-): IO<R & R1 & R2, E | E1 | E2, A1> {
+  __tsplusTrace?: string,
+): IO<R | R1 | R2, E | E1 | E2, A1> {
   return IO.uninterruptibleMask(({ restore }) =>
     acquire().flatMap((a) =>
       IO.defer(restore(use(a))).result.flatMap((exit) =>

package/_src/IO/api/concurrency.ts

@@ -17,7 +17,10 @@ export const concurrency: UIO<Maybe<number>> = Concurrency.get;
  *
  * @tsplus static fncts.io.IOOps concurrencyWith
  */
-export function concurrencyWith<R, E, A>(f: (concurrency: Maybe<number>) => IO<R, E, A>): IO<R, E, A> {
+export function concurrencyWith<R, E, A>(
+  f: (concurrency: Maybe<number>) => IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
   return Concurrency.getWith(f);
 }
 
@@ -27,7 +30,7 @@ export function concurrencyWith<R, E, A>(f: (concurrency: Maybe<number>) => IO<R
  *
  * @tsplus fluent fncts.io.IO withConcurrency
  */
-export function withConcurrency_<R, E, A>(ma: IO<R, E, A>, n: number): IO<R, E, A> {
+export function withConcurrency_<R, E, A>(ma: IO<R, E, A>, n: number, __tsplusTrace?: string): IO<R, E, A> {
   return IO.defer(Concurrency.locally(Just(n))(ma));
 }
 
@@ -37,6 +40,6 @@ export function withConcurrency_<R, E, A>(ma: IO<R, E, A>, n: number): IO<R, E,
  *
  * @tsplus getter fncts.io.IO withConcurrencyUnbounded
  */
-export function withConcurrencyUnbounded<R, E, A>(ma: IO<R, E, A>): IO<R, E, A> {
+export function withConcurrencyUnbounded<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
   return IO.defer(Concurrency.locally(Nothing())(ma));
 }