@fncts/io 0.0.10 → 0.0.13

package/_src/Channel/definition.ts

@@ -26,13 +26,13 @@ export const enum ChannelTag {
  * @tsplus companion fncts.io.ChannelOps
  */
 export abstract class Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
-  readonly _Env!: (_: Env) => void;
-  readonly _InErr!: (_: InErr) => void;
-  readonly _InElem!: (_: InElem) => void;
-  readonly _InDone!: (_: InDone) => void;
-  readonly _OutErr!: () => OutErr;
-  readonly _OutElem!: () => OutElem;
-  readonly _OutDone!: () => OutDone;
+  declare _Env: () => Env;
+  declare _InErr: (_: InErr) => void;
+  declare _InElem: (_: InElem) => void;
+  declare _InDone: (_: InDone) => void;
+  declare _OutErr: () => OutErr;
+  declare _OutElem: () => OutElem;
+  declare _OutDone: () => OutDone;
 }
 
 /**
@@ -53,7 +53,7 @@ export function unifyChannel<X extends Channel<any, any, any, any, any, any, any
 }
 
 export abstract class Continuation<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2> {
-  readonly _Env!: (_: Env) => void;
+  readonly _Env!: () => Env;
   readonly _InErr!: (_: InErr) => void;
   readonly _InElem!: (_: InElem) => void;
   readonly _InDone!: (_: InDone) => void;
@@ -170,14 +170,14 @@ export class Read<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone,
   }
 }
 
-export class Done<OutDone> extends Channel<unknown, unknown, unknown, unknown, never, never, OutDone> {
+export class Done<OutDone> extends Channel<never, unknown, unknown, unknown, never, never, OutDone> {
   readonly _tag = ChannelTag.Done;
   constructor(readonly terminal: () => OutDone) {
     super();
   }
 }
 
-export class Fail<OutErr> extends Channel<unknown, unknown, unknown, unknown, OutErr, never, never> {
+export class Fail<OutErr> extends Channel<never, unknown, unknown, unknown, OutErr, never, never> {
   readonly _tag = ChannelTag.Halt;
   constructor(readonly cause: () => Cause<OutErr>) {
     super();
@@ -257,7 +257,7 @@ export class BracketOut<R, E, Z, OutDone> extends Channel<R, unknown, unknown, u
 }
 
 export class Provide<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> extends Channel<
-  unknown,
+  never,
   InErr,
   InElem,
   InDone,
@@ -274,7 +274,7 @@ export class Provide<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> exten
   }
 }
 
-export class Emit<OutElem, OutDone> extends Channel<unknown, unknown, unknown, unknown, never, OutElem, OutDone> {
+export class Emit<OutElem, OutDone> extends Channel<never, unknown, unknown, unknown, never, OutElem, OutDone> {
   readonly _tag = ChannelTag.Emit;
   constructor(readonly out: () => OutElem) {
     super();

package/_src/Channel/internal/MergeDecision.ts

@@ -12,7 +12,7 @@ export type MergeDecisionTypeId = typeof MergeDecisionTypeId;
  */
 export abstract class MergeDecision<R, E0, Z0, E, Z> {
   readonly _typeId: MergeDecisionTypeId = MergeDecisionTypeId;
-  readonly _R!: (_: R) => void;
+  readonly _R!: () => R;
   readonly _E0!: (_: E0) => void;
   readonly _Z0!: (_: Z0) => void;
   readonly _E!: () => E;

package/_src/Clock/live.ts

@@ -2,7 +2,7 @@ class LiveClock extends Clock {
   currentTime: UIO<number> = IO.succeed(Date.now());
 
   sleep(duration: Lazy<Duration>, __tsplusTrace?: string): UIO<void> {
-    return IO.asyncInterrupt<unknown, never, void>((k) => {
+    return IO.asyncInterrupt<never, never, void>((k) => {
       const handle = setTimeout(() => {
         k(IO.unit);
       }, duration().milliseconds);

package/_src/Fiber/FiberContext.ts

@@ -34,7 +34,7 @@ export class TracedCont {
 
 export class Finalizer {
   readonly _tag = "Finalizer";
-  constructor(readonly finalizer: UIO<any>, readonly apply: ErasedCont, readonly trace?: string) {}
+  constructor(readonly finalizer: IO<any, never, any>, readonly apply: ErasedCont, readonly trace?: string) {}
 }
 
 export type Frame =
@@ -533,7 +533,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
   }
 
   unsafeRunLater(i0: Instruction) {
-    defaultScheduler(() => {
+    this.unsafeGetRef(FiberRef.currentScheduler).scheduleTask(() => {
       this.nextIO = i0;
       this.runUntil(this.runtimeConfig.yieldOpCount);
     });
@@ -569,7 +569,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
     this.fiberRefLocals.set(this.fiberRefLocals.get.remove(ref));
   }
 
-  private unsafePoll() {
+  unsafePoll() {
     switch (this.state._tag) {
       case "Executing": {
         return Nothing();
@@ -592,7 +592,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
     }
   });
 
-  private unsafeAddFinalizer(finalizer: UIO<any>): void {
+  private unsafeAddFinalizer(finalizer: IO<any, never, any>): void {
     this.stack.push(
       new Finalizer(finalizer, (v) => {
         this.unsafeDisableInterruption();
@@ -929,7 +929,9 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
     const childIO = !parentScope.unsafeAdd(childContext) ? IO.interruptAs(parentScope.fiberId) : io;
 
     childContext.nextIO = concrete(childIO);
-    defaultScheduler(() => childContext.runUntil(this.runtimeConfig.yieldOpCount));
+    this.unsafeGetRef(FiberRef.currentScheduler).scheduleTask(() =>
+      childContext.runUntil(this.runtimeConfig.yieldOpCount),
+    );
 
     return childContext;
   }
@@ -968,12 +970,12 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
 
   private unsafeRace<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(
     race: Race<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>,
-  ): IO<R & R1 & R2 & R3, E2 | E3, A2 | A3> {
+  ): IO<R | R1 | R2 | R3, E2 | E3, A2 | A3> {
     const raceIndicator = new AtomicReference(true);
     const left          = this.unsafeFork(concrete(race.left), Nothing(), race.trace);
     const right         = this.unsafeFork(concrete(race.right), Nothing(), race.trace);
 
-    return IO.async<R & R1 & R2 & R3, E2 | E3, A2 | A3>((cb) => {
+    return IO.async<R | R1 | R2 | R3, E2 | E3, A2 | A3>((cb) => {
       const leftRegister = left.unsafeAddObserver(() => {
         this.unsafeCompleteRace(left, right, race.leftWins, raceIndicator, cb);
       });
@@ -995,7 +997,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
     loser: Fiber<any, any>,
     cont: (fiber0: Fiber<any, any>, fiber1: Fiber<any, any>) => Erased,
     ab: AtomicReference<boolean>,
-    cb: (_: IO<R & R1 & R2 & R3, E2 | E3, A2 | A3>) => void,
+    cb: (_: IO<R | R1 | R2 | R3, E2 | E3, A2 | A3>) => void,
   ): void {
     if (ab.compareAndSet(true, false)) {
       cb(cont(winner, loser));

package/_src/Fiber/api/awaitAll.ts

@@ -3,6 +3,6 @@
  *
  * @tsplus static fncts.io.FiberOps awaitAll
  */
-export function awaitAll<E, A>(as: Iterable<Fiber<E, A>>): IO<unknown, never, Exit<E, Conc<A>>> {
+export function awaitAll<E, A>(as: Iterable<Fiber<E, A>>): IO<never, never, Exit<E, Conc<A>>> {
   return IO.foreachC(as, (f) => f.await.flatMap(IO.fromExitNow)).result;
 }

package/_src/Fiber/api/evalOnIO.ts

@@ -8,7 +8,7 @@ export function evalOnIO_<E, A, R1, E1, B, R2, E2, C>(
   fiber: Fiber<E, A>,
   effect: IO<R1, E1, B>,
   orElse: IO<R2, E2, C>,
-): IO<R1 & R2, E1 | E2, B | C> {
+): IO<R1 | R2, E1 | E2, B | C> {
   return Do((Δ) => {
     const r = Δ(IO.environment<R1 & R2>());
     const f = Δ(Future.make<E1 | E2, B | C>());

package/_src/Fiber/api/joinAll.ts

@@ -5,7 +5,7 @@
  *
  * @tsplus static fncts.io.FiberOps joinAll
  */
-export function joinAll<E, A>(as: Iterable<Fiber<E, A>>): IO<unknown, E, Conc<A>> {
+export function joinAll<E, A>(as: Iterable<Fiber<E, A>>): IO<never, E, Conc<A>> {
   return Fiber.awaitAll(as)
     .flatMap(IO.fromExitNow)
     .tap(() => IO.foreach(as, (f) => f.inheritRefs));

package/_src/Fiber/definition.ts

@@ -80,7 +80,7 @@ export interface RuntimeFiber<E, A> extends FiberCommon<E, A> {
   readonly evalOnIO: <R1, E1, B, R2, E2, C>(
     effect: IO<R1, E1, B>,
     orElse: IO<R2, E2, C>,
-  ) => IO<R1 & R2, E1 | E2, B | C>;
+  ) => IO<R1 | R2, E1 | E2, B | C>;
 
   /**
    * The status of the fiber.

package/_src/FiberRef/api/locallyScoped.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus fluent fncts.io.FiberRef locallyScoped
  */
-export function locallyScoped_<A>(ref: FiberRef<A>, a: A): IO<Has<Scope>, never, void> {
+export function locallyScoped_<A>(ref: FiberRef<A>, a: A): IO<Scope, never, void> {
   return IO.acquireRelease(
     ref.get.flatMap((old) => ref.set(a).as(old)),
     (a) => ref.set(a),

package/_src/FiberRef/api/locallyScopedWith.ts

@@ -1,6 +1,6 @@
 /**
  * @tsplus fluent fncts.io.FiberRef locallyScopedWith
  */
-export function locallyScopedWith<A>(self: FiberRef<A>, f: (a: A) => A): IO<Has<Scope>, never, void> {
+export function locallyScopedWith<A>(self: FiberRef<A>, f: (a: A) => A): IO<Scope, never, void> {
   return self.getWith((a) => self.locallyScoped(f(a)));
 }

package/_src/FiberRef/constructors.ts

@@ -2,7 +2,7 @@ import { identity } from "@fncts/base/data/function";
 
 function makeWith<Value, Patch>(
   ref: Lazy<FiberRef.WithPatch<Value, Patch>>,
-): IO<Has<Scope>, never, FiberRef.WithPatch<Value, Patch>> {
+): IO<Scope, never, FiberRef.WithPatch<Value, Patch>> {
   return IO.acquireRelease(
     IO.succeed(ref).tap((ref) => ref.update(identity)),
     (ref) => ref.remove,
@@ -16,6 +16,6 @@ export function make<A>(
   initial: A,
   fork: (a: A) => A = identity,
   join: (a: A, a1: A) => A = (_, a) => a,
-): IO<Has<Scope>, never, FiberRef<A>> {
+): IO<Scope, never, FiberRef<A>> {
   return makeWith(FiberRef.unsafeMake(initial, fork, join));
 }

package/_src/FiberRef/unsafe.ts

@@ -1,7 +1,9 @@
 import type { LogSpan } from "../LogSpan.js";
+import type { Scheduler } from "@fncts/io/internal/Scheduler.js";
 
 import { identity } from "@fncts/base/data/function";
 import { Patch } from "@fncts/base/data/Patch";
+import { defaultScheduler } from "@fncts/io/internal/Scheduler";
 
 import { FiberRefInternal } from "./definition.js";
 
@@ -77,3 +79,8 @@ export const currentLogSpan = FiberRef.unsafeMake<List<LogSpan>>(Nil());
  * @tsplus static fncts.io.FiberRefOps currentLogAnnotations
  */
 export const currentLogAnnotations = FiberRef.unsafeMake<HashMap<string, string>>(HashMap.makeDefault());
+
+/**
+ * @tsplus static fncts.io.FiberRefOps currentScheduler
+ */
+export const currentScheduler = FiberRef.unsafeMake<Scheduler>(defaultScheduler);

package/_src/Future/api.ts

@@ -175,8 +175,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>): 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 +189,7 @@ 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): 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>(): IO<never, never, Future<E, A>> {
   return IO.fiberId.flatMap((id) => Future.makeAs<E, A>(id));
 }
 

package/_src/Hub/api.ts

@@ -40,13 +40,13 @@ 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> {
+): 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,
@@ -96,12 +96,12 @@ 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> {
+): 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 +125,7 @@ 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> {
+): PHub<RA | RA1, RB, EA | EA1, EB, A, B> {
   concrete(source);
   return new FilterInputIO(source, f);
 }
@@ -139,7 +139,7 @@ export function filterInput_<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A,
   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 +162,7 @@ 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> {
+): PHub<RA, RB | RB1, EA, EB | EB1, A, B> {
   concrete(source);
   return new FilterOutputIO(source, f);
 }
@@ -262,7 +262,7 @@ 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> {
+): PHub<RA, RC | RB, EA, EB | EC, A, C> {
   return self.dimapIO(IO.succeedNow, f);
 }
 
@@ -279,7 +279,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());
 }
 
 /**
@@ -326,7 +326,7 @@ 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>> {
+): IO<Scope, never, Hub.Dequeue<RB, EB, B>> {
   concrete(self);
   return self.subscribe;
 }

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,6 @@
 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> {
+): 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

@@ -4,6 +4,6 @@
 export function addFinalizer<R>(
   finalizer: Lazy<URIO<R, any>>,
   __tsplusTrace?: string,
-): IO<R & Has<Scope>, never, void> {
+): IO<R | Scope, never, void> {
   return IO.addFinalizerExit(() => finalizer());
 }

package/_src/IO/api/addFinalizerExit.ts

@@ -1,12 +1,10 @@
 /**
  * @tsplus static fncts.io.IOOps addFinalizerExit
  */
-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))));
+export function addFinalizerExit<R>(finalizer: (exit: Exit<any, any>) => URIO<R, any>): 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/bracket.ts

@@ -25,6 +25,6 @@ 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> {
+): IO<R | R1 | R2, E | E1 | E2, A1> {
   return IO.bracketExit(acquire, use, release);
 }

package/_src/IO/api/bracketExit.ts

@@ -12,7 +12,7 @@ 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> {
+): 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/concurrentFinalizers.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus getter fncts.io.IO concurrentFinalizers
  */
-export function concurrentFinalizers<R, E, A>(io: IO<R, E, A>): IO<R & Has<Scope>, E, A> {
+export function concurrentFinalizers<R, E, A>(io: IO<R, E, A>): IO<R | Scope, E, A> {
   return Do((Δ) => {
     const outerScope = Δ(IO.scope);
     const innerScope = Δ(Scope.concurrent);

package/_src/IO/api/core-scope.ts

@@ -62,7 +62,7 @@ export function raceWith_<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(
   leftWins: (exit: Exit<E, A>, fiber: Fiber<E1, A1>) => IO<R2, E2, A2>,
   rightWins: (exit: Exit<E1, A1>, fiber: Fiber<E, A>) => IO<R3, E3, A3>,
   __tsplusTrace?: string,
-): IO<R & R1 & R2 & R3, E2 | E3, A2 | A3> {
+): IO<R | R1 | R2 | R3, E2 | E3, A2 | A3> {
   return IO.defer(
     () =>
       new Race(

package/_src/IO/api/ensuringChildren.ts

@@ -4,8 +4,8 @@
 export function ensuringChildren<R, E, A, R1>(
   self: IO<R, E, A>,
   children: (_: Conc<Fiber.Runtime<any, any>>) => IO<R1, never, void>,
-): IO<R & R1, E, A> {
-  return Supervisor.track.flatMap((supervisor) =>
+): IO<R | R1, E, A> {
+  return Supervisor.track(true).flatMap((supervisor) =>
     self.supervised(supervisor).ensuring(supervisor.value.flatMap(children)),
   );
 }