@fncts/io 0.0.11 → 0.0.14

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>, __tsplusTrace?: string): IO<R | Scope, E, A> {
   return Do((Δ) => {
     const outerScope = Δ(IO.scope);
     const innerScope = Δ(Scope.concurrent);

package/_src/IO/api/consoleWith.ts

@@ -3,7 +3,7 @@ import { Console } from "@fncts/io/Console";
 /**
  * @tsplus static fncts.io.IOOps consoleWith
  */
-export function consoleWith<R, E, A>(f: (console: Console) => IO<R, E, A>): IO<R, E, A> {
+export function consoleWith<R, E, A>(f: (console: Console) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
   return IOEnv.services.getWith((services) => f(services.get(Console.Tag)));
 }
 

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,9 @@
 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) =>
+  __tsplusTrace?: string,
+): IO<R | R1, E, A> {
+  return Supervisor.track(true).flatMap((supervisor) =>
     self.supervised(supervisor).ensuring(supervisor.value.flatMap(children)),
   );
 }

package/_src/IO/api/environment.ts

@@ -40,7 +40,7 @@ export function environmentWith<R, A>(f: (_: Environment<R>) => A, __tsplusTrace
 export function environmentWithIO<R0, R, E, A>(
   f: (r: Environment<R0>) => IO<R, E, A>,
   __tsplusTrace?: string,
-): IO<R & R0, E, A> {
+): IO<R | R0, E, A> {
   return IO.environment<R0>().flatMap(f);
 }
 
@@ -63,7 +63,7 @@ export function provideSomeEnvironment_<R, E, A, R0>(
   self: IO<R, E, A>,
   environment: Environment<R0>,
   __tsplusTrace?: string,
-): IO<Intersection.Erase<R, R0>, E, A> {
+): IO<Exclude<R, R0>, E, A> {
   return self.contramapEnvironment((r0) => r0.union(environment));
 }
 
@@ -71,7 +71,7 @@ export function provideSomeEnvironment_<R, E, A, R0>(
  * @tsplus fluent fncts.io.IO provideService
  */
 export function provideService_<E, A, T>(
-  self: IO<Has<T>, E, A>,
+  self: IO<T, E, A>,
   service: T,
   tag: Tag<T>,
   __tsplusTrace?: string,
@@ -87,30 +87,28 @@ export function provideSomeService_<R, E, A, T>(
   service: T,
   tag: Tag<T>,
   __tsplusTrace?: string,
-): IO<Intersection.Erase<R, Has<T>>, E, A> {
-  return self.contramapEnvironment((r: Environment<R>) => r.add(service, tag));
+): IO<Exclude<R, T>, E, A> {
+  return self.contramapEnvironment((r: Environment<Exclude<R, T>>) => r.add(service, tag) as Environment<R>);
 }
 
 /**
  * @tsplus static fncts.io.IOAspects provideSomeService
  */
 export function provideSomeService<T>(service: T, tag: Tag<T>, __tsplusTrace?: string) {
-  return <R, E, A>(io: IO<R & Has<T>, E, A>): IO<R, E, A> =>
-    // @ts-expect-error
-    io.provideSomeService(service, tag);
+  return <R, E, A>(io: IO<R | T, E, A>): IO<R, E, A> => io.provideSomeService(service, tag);
 }
 
 /**
  * @tsplus static fncts.io.IOOps service
  */
-export function service<T>(tag: Tag<T>, __tsplusTrace?: string): IO<Has<T>, never, T> {
+export function service<T>(tag: Tag<T>, __tsplusTrace?: string): IO<T, never, T> {
   return IO.serviceWithIO(IO.succeedNow, tag);
 }
 
 /**
  * @tsplus static fncts.io.IOOps serviceWith
  */
-export function serviceWith<S, A>(f: (service: S) => A, tag: Tag<S>): IO<Has<S>, never, A> {
+export function serviceWith<S, A>(f: (service: S) => A, tag: Tag<S>, __tsplusTrace?: string): IO<S, never, A> {
   return IO.serviceWithIO((s) => IO.succeedNow(f(s)), tag);
 }
 
@@ -121,6 +119,6 @@ export function serviceWithIO<T, R, E, A>(
   f: (service: T) => IO<R, E, A>,
   tag: Tag<T>,
   __tsplusTrace?: string,
-): IO<R & Has<T>, E, A> {
+): IO<R | T, E, A> {
   return IO.defer(FiberRef.currentEnvironment.get.flatMap((environment) => f(environment.unsafeGet(tag))));
 }

package/_src/IO/api/foreachC.ts

@@ -16,7 +16,11 @@ import { AtomicNumber } from "@fncts/base/internal/AtomicNumber";
  * @tsplus static fncts.io.IOOps foreachDiscardC
  * @tsplus fluent fncts.Iterable traverseIODiscardC
  */
-export function foreachDiscardC_<R, E, A>(as: Iterable<A>, f: (a: A) => IO<R, E, any>): IO<R, E, void> {
+export function foreachDiscardC_<R, E, A>(
+  as: Iterable<A>,
+  f: (a: A) => IO<R, E, any>,
+  __tsplusTrace?: string,
+): IO<R, E, void> {
   return IO.concurrencyWith((conc) =>
     conc.match(
       () => foreachConcurrentUnboundedDiscard(as, f),
@@ -34,7 +38,11 @@ export function foreachDiscardC_<R, E, A>(as: Iterable<A>, f: (a: A) => IO<R, E,
  * @tsplus static fncts.io.IOOps foreachC
  * @tsplus fluent fncts.Iterable traverseIOC
  */
-export function foreachC_<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>): IO<R, E, Conc<B>> {
+export function foreachC_<R, E, A, B>(
+  as: Iterable<A>,
+  f: (a: A) => IO<R, E, B>,
+  __tsplusTrace?: string,
+): IO<R, E, Conc<B>> {
   return IO.concurrencyWith((conc) =>
     conc.match(
       () => foreachConcurrentUnbounded(as, f),
@@ -43,7 +51,11 @@ export function foreachC_<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>)
   );
 }
 
-function foreachConcurrentUnboundedDiscard<R, E, A>(as: Iterable<A>, f: (a: A) => IO<R, E, any>): IO<R, E, void> {
+function foreachConcurrentUnboundedDiscard<R, E, A>(
+  as: Iterable<A>,
+  f: (a: A) => IO<R, E, any>,
+  __tsplusTrace?: string,
+): IO<R, E, void> {
   return IO.defer(() => {
     const arr  = Array.from(as);
     const size = arr.length;
@@ -91,7 +103,11 @@ function foreachConcurrentUnboundedDiscard<R, E, A>(as: Iterable<A>, f: (a: A) =
   });
 }
 
-function foreachConcurrentUnbounded<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>): IO<R, E, Conc<B>> {
+function foreachConcurrentUnbounded<R, E, A, B>(
+  as: Iterable<A>,
+  f: (a: A) => IO<R, E, B>,
+  __tsplusTrace?: string,
+): IO<R, E, Conc<B>> {
   return IO.succeed<B[]>([])
     .flatMap((array) =>
       foreachConcurrentUnboundedDiscard(as.zipWithIndex, ([n, a]) =>
@@ -105,7 +121,11 @@ function foreachConcurrentUnbounded<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO
     .map(Conc.from);
 }
 
-function foreachConcurrentBoundedDiscardWorker<R, E, A>(queue: Queue<A>, f: (a: A) => IO<R, E, any>): IO<R, E, void> {
+function foreachConcurrentBoundedDiscardWorker<R, E, A>(
+  queue: Queue<A>,
+  f: (a: A) => IO<R, E, any>,
+  __tsplusTrace?: string,
+): IO<R, E, void> {
   return queue.poll.flatMap((ma) =>
     ma.match(
       () => IO.unit,
@@ -118,6 +138,7 @@ function foreachConcurrentBoundedDiscard<R, E, A>(
   as: Iterable<A>,
   n: number,
   f: (a: A) => IO<R, E, any>,
+  __tsplusTrace?: string,
 ): IO<R, E, void> {
   return IO.defer(() => {
     const size =
@@ -141,6 +162,7 @@ function foreachConcurrentBoundedWorker<R, E, A, B>(
   queue: Queue<readonly [number, A]>,
   array: Array<any>,
   f: (a: A) => IO<R, E, B>,
+  __tsplusTrace?: string,
 ): IO<R, E, void> {
   return queue.poll.flatMap((ma) =>
     ma.match(
@@ -157,7 +179,12 @@ function foreachConcurrentBoundedWorker<R, E, A, B>(
   );
 }
 
-function foreachConcurrentBounded<R, E, A, B>(as: Iterable<A>, n: number, f: (a: A) => IO<R, E, B>): IO<R, E, Conc<B>> {
+function foreachConcurrentBounded<R, E, A, B>(
+  as: Iterable<A>,
+  n: number,
+  f: (a: A) => IO<R, E, B>,
+  __tsplusTrace?: string,
+): IO<R, E, Conc<B>> {
   return IO.defer(() => {
     const size =
       "length" in as && typeof (as as Iterable<A> & { length: unknown })["length"] === "number"

package/_src/IO/api/foreachExec.ts

@@ -10,6 +10,7 @@ export function foreachExec_<R, E, A, B>(
   as: Iterable<A>,
   es: ExecutionStrategy,
   f: (a: A) => IO<R, E, B>,
+  __tsplusTrace?: string,
 ): IO<R, E, Conc<B>> {
   return es.match(
     () => IO.foreach(as, f),

package/_src/IO/api/forkScoped.ts

@@ -4,7 +4,7 @@
 export function forkScoped<R, E, A>(
   self: IO<R, E, A>,
   __tsplusTrace?: string,
-): IO<R & Has<Scope>, never, Fiber.Runtime<E, A>> {
+): IO<R | Scope, never, Fiber.Runtime<E, A>> {
   return IO.uninterruptibleMask(({ restore }) =>
     restore(self).forkDaemon.tap((fiber) => IO.addFinalizer(fiber.interrupt)),
   );

package/_src/IO/api/fulfill.ts

@@ -5,6 +5,6 @@
  *
  * @tsplus fluent fncts.io.IO fulfill
  */
-export function fulfill_<R, E, A>(effect: IO<R, E, A>, p: Future<E, A>): IO<R, never, boolean> {
+export function fulfill_<R, E, A>(effect: IO<R, E, A>, p: Future<E, A>, __tsplusTrace?: string): IO<R, never, boolean> {
   return IO.uninterruptibleMask(({ restore }) => restore(effect).result.flatMap((exit) => p.done(exit)));
 }

package/_src/IO/api/interrupt.ts

@@ -15,7 +15,7 @@ export function interruptAs(fiberId: FiberId, __tsplusTrace?: string): FIO<never
  *
  * @tsplus static fncts.io.IOOps interrupt
  */
-export const interrupt: IO<unknown, never, never> = IO.fiberId.flatMap(IO.interruptAs);
+export const interrupt: IO<never, never, never> = IO.fiberId.flatMap(IO.interruptAs);
 
 /**
  * Switches the interrupt status for this effect. If `true` is used, then the
@@ -73,7 +73,10 @@ export function uninterruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: stri
  *
  * @tsplus static fncts.io.IOOps uninterruptibleMask
  */
-export function uninterruptibleMask<R, E, A>(f: (restore: InterruptStatusRestore) => IO<R, E, A>): IO<R, E, A> {
+export function uninterruptibleMask<R, E, A>(
+  f: (restore: InterruptStatusRestore) => IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
   return IO.checkInterruptible((flag) => f(new InterruptStatusRestore(flag)).uninterruptible);
 }
 
@@ -84,7 +87,10 @@ export function uninterruptibleMask<R, E, A>(f: (restore: InterruptStatusRestore
  *
  * @tsplus static fncts.io.IOOps interruptibleMask
  */
-export function interruptibleMask<R, E, A>(k: (restore: InterruptStatusRestore) => IO<R, E, A>): IO<R, E, A> {
+export function interruptibleMask<R, E, A>(
+  k: (restore: InterruptStatusRestore) => IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
   return IO.checkInterruptible((flag) => k(new InterruptStatusRestore(flag)).interruptible);
 }
 
@@ -97,7 +103,8 @@ export function interruptibleMask<R, E, A>(k: (restore: InterruptStatusRestore)
 export function onInterrupt_<R, E, A, R1>(
   ma: IO<R, E, A>,
   cleanup: (interruptors: HashSet<FiberId>) => IO<R1, never, any>,
-): IO<R & R1, E, A> {
+  __tsplusTrace?: string,
+): IO<R | R1, E, A> {
   return uninterruptibleMask(({ restore }) =>
     restore(ma).matchCauseIO(
       (cause) =>
@@ -116,7 +123,8 @@ export function onInterrupt_<R, E, A, R1>(
 export function onInterruptExtended_<R, E, A, R2, E2>(
   self: IO<R, E, A>,
   cleanup: Lazy<IO<R2, E2, any>>,
-): IO<R & R2, E | E2, A> {
+  __tsplusTrace?: string,
+): IO<R | R2, E | E2, A> {
   return uninterruptibleMask(({ restore }) =>
     restore(self).matchCauseIO(
       (cause) =>

package/_src/IO/api/memoize.ts

@@ -2,9 +2,9 @@
  * @tsplus getter fncts.io.IO memoize
  */
 export function memoize<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): UIO<IO<R, E, A>> {
-  return IO.gen(function* (_) {
-    const future   = yield* _(Future.make<E, A>());
-    const complete = yield* _(future.fulfill(self).once);
+  return Do((_) => {
+    const future   = _(Future.make<E, A>());
+    const complete = _(future.fulfill(self).once);
     return complete > future.await;
   });
 }

package/_src/IO/api/onExit.ts

@@ -4,7 +4,8 @@
 export function onExit_<R, E, A, R1, E1>(
   self: IO<R, E, A>,
   cleanup: (exit: Exit<E, A>) => IO<R1, E1, any>,
-): IO<R & R1, E | E1, A> {
+  __tsplusTrace?: string,
+): IO<R | R1, E | E1, A> {
   return IO.unit.bracketExit(
     () => self,
     (_, exit) => cleanup(exit),

package/_src/IO/api/onTermination.ts

@@ -4,8 +4,8 @@
 export function onTermination<R, E, A, R1>(
   self: Lazy<IO<R, E, A>>,
   cleanup: (cause: Cause<never>) => URIO<R1, any>,
-  __tsPlusTrace?: string,
-): IO<R & R1, E, A> {
+  __tsplusTrace?: string,
+): IO<R | R1, E, A> {
   return IO.unit.bracketExit(
     () => self(),
     (_, exit: Exit<E, A>) =>

package/_src/IO/api/provideLayer.ts

@@ -4,6 +4,7 @@
 export function provideLayer_<RIn, E, ROut, E1, A>(
   self: IO<ROut, E1, A>,
   layer: Layer<RIn, E, ROut>,
+  __tsplusTrace?: string,
 ): IO<RIn, E | E1, A> {
   return Scope.make.bracketExit(
     (scope) => layer.build(scope).flatMap((r) => self.provideEnvironment(r)),

package/_src/IO/api/provideSomeLayer.ts

@@ -17,7 +17,5 @@ export function provideSomeLayer_<R, E, A, RIn, E1, ROut>(
  * @tsplus static fncts.io.IOAspects provideSomeLayer
  */
 export function provideSomeLayer<RIn, E1, ROut>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string) {
-  return <R, E, A>(self: IO<R & ROut, E, A>): IO<R & RIn, E | E1, A> =>
-    // @ts-expect-error
-    self.provideSomeLayer(layer);
+  return <R, E, A>(self: IO<R | ROut, E, A>): IO<R | RIn, E | E1, A> => self.provideSomeLayer(layer);
 }

package/_src/IO/api/race.ts

@@ -1,4 +1,4 @@
-function maybeDisconnect<R, E, A>(io: IO<R, E, A>): IO<R, E, A> {
+function maybeDisconnect<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
   return IO.uninterruptibleMask((restore) => restore.force(io));
 }
 
@@ -13,7 +13,11 @@ function maybeDisconnect<R, E, A>(io: IO<R, E, A>): IO<R, E, A> {
  *
  * @tsplus fluent fncts.io.IO race
  */
-export function race_<R, E, A, R1, E1, A1>(io: IO<R, E, A>, that: IO<R1, E1, A1>): IO<R & R1, E | E1, A | A1> {
+export function race_<R, E, A, R1, E1, A1>(
+  io: IO<R, E, A>,
+  that: IO<R1, E1, A1>,
+  __tsplusTrace?: string,
+): IO<R | R1, E | E1, A | A1> {
   return IO.descriptorWith((descriptor) =>
     maybeDisconnect(io).raceWith(
       maybeDisconnect(that),

package/_src/IO/api/raceFirst.ts

@@ -12,6 +12,10 @@
  *
  * @tsplus fluent fncts.io.IO raceFirst
  */
-export function raceFirst_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, that: IO<R1, E1, A1>): IO<R & R1, E | E1, A | A1> {
-  return ma.result.race(that.result).flatMap(IO.fromExitNow);
+export function raceFirst_<R, E, A, R1, E1, A1>(
+  ma: IO<R, E, A>,
+  that: IO<R1, E1, A1>,
+  __tsplusTrace?: string,
+): IO<R | R1, E | E1, A | A1> {
+  return ma.result.race(that.result).flatMap((exit) => IO.fromExitNow<E | E1, A | A1>(exit));
 }

package/_src/IO/api/randomWith.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus static fncts.io.IOOps randomWith
  */
-export function randomWith<R, E, A>(f: (random: Random) => IO<R, E, A>): IO<R, E, A> {
+export function randomWith<R, E, A>(f: (random: Random) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
   return IOEnv.services.getWith((services) => f(services.get(Random.Tag)));
 }
 

package/_src/IO/api/repeat.ts

@@ -1,36 +1,36 @@
 /**
  * @tsplus getter fncts.io.IO repeat
  */
-export function repeat_<R, E, A>(self: IO<R, E, A>) {
-  return <R1, B>(schedule0: Lazy<Schedule<R1, A, B>>, __tsplusTrace?: string): IO<R & R1, E, B> =>
+export function repeat_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
+  return <R1, B>(schedule0: Lazy<Schedule<R1, A, B>>, __tsplusTrace?: string): IO<R | R1, E, B> =>
     self.repeatOrElse(schedule0, (e, _) => IO.fail(e));
 }
 
 /**
  * @tsplus getter fncts.io.IO repeatOrElse
  */
-export function repeatOrElse_<R, E, A>(self: IO<R, E, A>) {
+export function repeatOrElse_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
   return <R1, B, R2, E2>(
     schedule0: Lazy<Schedule<R1, A, B>>,
     orElse: (e: E, out: Maybe<B>) => IO<R2, E2, B>,
     __tsplusTrace?: string,
-  ): IO<R & R1 & R2, E2, B> => self.repeatOrElseEither(schedule0, orElse).map((_) => _.value);
+  ): IO<R | R1 | R2, E2, B> => self.repeatOrElseEither(schedule0, orElse).map((_) => _.value);
 }
 
 /**
  * @tsplus getter fncts.io.IO repeatOrElseEither
  */
-export function repeatOrElseEither_<R, E, A>(self: IO<R, E, A>) {
+export function repeatOrElseEither_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
   return <R1, B, R2, E2, C>(
     schedule0: Lazy<Schedule<R1, A, B>>,
     orElse: (e: E, out: Maybe<B>) => IO<R2, E2, C>,
     __tsplusTrace?: string,
-  ): IO<R & R1 & R2, E2, Either<C, B>> =>
+  ): IO<R | R1 | R2, E2, Either<C, B>> =>
     IO.defer(() => {
       const schedule = schedule0();
 
       return schedule.driver.flatMap((driver) => {
-        const loop = (a: A): IO<R & R1 & R2, E2, Either<C, B>> =>
+        const loop = (a: A): IO<R | R1 | R2, E2, Either<C, B>> =>
           driver.next(a).matchIO(
             () => driver.last.orHalt.map(Either.right),
             (b) =>

package/_src/IO/api/retry.ts

@@ -1,35 +1,35 @@
 /**
  * @tsplus getter fncts.io.IO retry
  */
-export function retry<R, E, A>(self: IO<R, E, A>) {
-  return <R1, O>(schedule0: Lazy<Schedule<R1, E, O>>, __tsplusTrace?: string): IO<R & R1, E, A> =>
+export function retry<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
+  return <R1, O>(schedule0: Lazy<Schedule<R1, E, O>>, __tsplusTrace?: string): IO<R | R1, E, A> =>
     self.retryOrElse(schedule0, (e, _) => IO.fail(e));
 }
 
 /**
  * @tsplus getter fncts.io.IO retryOrElse
  */
-export function retryOrElse<R, E, A>(self: IO<R, E, A>) {
+export function retryOrElse<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
   return <R1, O, R2, E2>(
     schedule0: Lazy<Schedule<R1, E, O>>,
     orElse: (e: E, out: O) => IO<R2, E2, A>,
     __tsplusTrace?: string,
-  ): IO<R & R1 & R2, E2, A> => self.retryOrElseEither(schedule0, orElse).map((_) => _.value);
+  ): IO<R | R1 | R2, E2, A> => self.retryOrElseEither(schedule0, orElse).map((_) => _.value);
 }
 
 /**
  * @tsplus getter fncts.io.IO retryOrElseEither
  */
-export function retryOrElseEither_<R, E, A>(self: IO<R, E, A>) {
+export function retryOrElseEither_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string) {
   return <R1, O, R2, E2, B>(
     schedule0: Lazy<Schedule<R1, E, O>>,
     orElse: (e: E, out: O) => IO<R2, E2, B>,
     __tsplusTrace?: string,
-  ): IO<R & R1 & R2, E2, Either<B, A>> =>
+  ): IO<R | R1 | R2, E2, Either<B, A>> =>
     IO.defer(() => {
       const schedule = schedule0();
 
-      const loop = (driver: Schedule.Driver<unknown, R1, E, O>): IO<R & R1 & R2, E2, Either<B, A>> =>
+      const loop = (driver: Schedule.Driver<unknown, R1, E, O>): IO<R | R1 | R2, E2, Either<B, A>> =>
         self.map(Either.right).catchAll((e) =>
           driver.next(e).matchIO(
             () => driver.last.orHalt.flatMap((out) => orElse(e, out).map(Either.left)),

package/_src/IO/api/schedule.ts

@@ -5,11 +5,12 @@ export function scheduleFrom<R, E, A extends A1, R1, A1, B>(
   self: IO<R, E, A>,
   a: Lazy<A>,
   schedule0: Lazy<Schedule<R1, A1, B>>,
-): IO<R & R1, E, B> {
+  __tsplusTrace?: string,
+): IO<R | R1, E, B> {
   return IO.defer(() => {
     const schedule = schedule0();
     return schedule.driver.flatMap((driver) => {
-      const loop = (a: A1): IO<R & R1, E, B> =>
+      const loop = (a: A1): IO<R | R1, E, B> =>
         driver.next(a).matchIO(
           () => driver.last.orHalt,
           () => self.flatMap(loop),
@@ -26,6 +27,6 @@ export function schedule<R, E, A, R1, B>(
   io: IO<R, E, A>,
   schedule: Lazy<Schedule<R1, any, B>>,
   __tsplusTrace?: string,
-): IO<R & R1, E, B> {
+): IO<R | R1, E, B> {
   return io.scheduleFrom(undefined, schedule);
 }

package/_src/IO/api/scope.ts

@@ -1,4 +1,4 @@
 /**
  * @tsplus static fncts.io.IOOps scope
  */
-export const scope: IO<Has<Scope>, never, Scope> = IO.service(Scope.Tag);
+export const scope: IO<Scope, never, Scope> = IO.service(Scope.Tag);

package/_src/IO/api/scopeWith.ts

@@ -1,6 +1,6 @@
 /**
  * @tsplus static fncts.io.IOOps scopeWith
  */
-export function scopeWith<R, E, A>(f: (scope: Scope) => IO<R, E, A>): IO<R & Has<Scope>, E, A> {
+export function scopeWith<R, E, A>(f: (scope: Scope) => IO<R, E, A>, __tsplusTrace?: string): IO<R | Scope, E, A> {
   return IO.serviceWithIO(f, Scope.Tag);
 }

package/_src/IO/api/scoped.ts

@@ -1,13 +1,13 @@
 /**
  * @tsplus static fncts.io.IOOps scoped
  */
-export function scoped<R, E, A>(io: Lazy<IO<R & Has<Scope>, E, A>>): IO<R, E, A> {
+export function scoped<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, A> {
   return Scope.make.flatMap((scope) => scope.use(io));
 }
 
 /**
  * @tsplus getter fncts.io.IO scoped
  */
-export function scoped_<R, E, A>(io: IO<R & Has<Scope>, E, A>): IO<R, E, A> {
+export function scoped_<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, A> {
   return IO.scoped(io);
 }

package/_src/IO/api/sequenceT.ts

@@ -7,6 +7,6 @@ import { identity, unsafeCoerce } from "@fncts/base/data/function";
  */
 export function sequenceT<T extends ReadonlyNonEmptyArray<IO<any, any, any>>>(
   ...ios: T
-): IO<HKT._R<T[number]>, HKT._E<T[number]>, { [K in keyof T]: T[K] extends HKT ? HKT._A<T[K]> : never }> {
+): IO<_R<T[number]>, _E<T[number]>, { [K in keyof T]: _A<T[K]> }> {
   return unsafeCoerce(IO.foreach(ios, identity));
 }

package/_src/IO/api/stateful.ts

@@ -7,7 +7,7 @@ import { State } from "../../State.js";
  */
 export function stateful<S, R, E, A>(
   s: S,
-  io: Lazy<IO<Has<State<S>> & R, E, A>>,
+  io: Lazy<IO<State<S> | R, E, A>>,
   tag: Tag<State<S>>,
   __tsplusTrace?: string,
 ): IO<R, E, A> {

package/_src/IO/api/timeout.ts

@@ -14,6 +14,10 @@ export function timeoutTo<R, E, A, B, B1>(
 /**
  * @tsplus fluent fncts.io.IO timeout
  */
-export function timeout<R, E, A>(self: IO<R, E, A>, duration: Lazy<Duration>): IO<R, E, Maybe<A>> {
+export function timeout<R, E, A>(
+  self: IO<R, E, A>,
+  duration: Lazy<Duration>,
+  __tsplusTrace?: string,
+): IO<R, E, Maybe<A>> {
   return self.timeoutTo(duration, Nothing(), Maybe.just);
 }

package/_src/IO/api/withChildren.ts

@@ -5,7 +5,7 @@ export function withChildren<R, E, A>(
   get: (_: UIO<Conc<Fiber.Runtime<any, any>>>) => IO<R, E, A>,
   __tsplusTrace?: string,
 ): IO<R, E, A> {
-  return Supervisor.track.flatMap((supervisor) =>
+  return Supervisor.track(true).flatMap((supervisor) =>
     get(
       supervisor.value.flatMap((children) => IO.descriptor.map((d) => children.filter((_) => _.id != d.id))),
     ).supervised(supervisor),

package/_src/IO/api/withEarlyRelease.ts

@@ -4,7 +4,10 @@
  *
  * @tsplus getter fncts.io.IO withEarlyRelease
  */
-export function withEarlyRelease<R, E, A>(self: IO<R, E, A>): IO<R & Has<Scope>, E, readonly [UIO<void>, A]> {
+export function withEarlyRelease<R, E, A>(
+  self: IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R | Scope, E, readonly [UIO<void>, A]> {
   return IO.scopeWith((parent) =>
     parent.fork.flatMap((child) =>
       child.extend(self).map((a) => [IO.fiberId.flatMap((fiberId) => child.close(Exit.interrupt(fiberId))), a]),

package/_src/IO/api/withFinalizer.ts

@@ -4,6 +4,7 @@
 export function withFinalizer_<R, E, A, R1>(
   self: IO<R, E, A>,
   finalizer: (a: A) => URIO<R1, any>,
-): IO<R & R1 & Has<Scope>, E, A> {
+  __tsplusTrace?: string,
+): IO<R | R1 | Scope, E, A> {
   return IO.acquireRelease(self, finalizer);
 }

package/_src/IO/api/withFinalizerExit.ts

@@ -4,6 +4,7 @@
 export function withFinalizerExit_<R, E, A, R1>(
   self: IO<R, E, A>,
   finalizer: (a: A, exit: Exit<any, any>) => URIO<R1, any>,
-): IO<R & R1 & Has<Scope>, E, A> {
+  __tsplusTrace?: string,
+): IO<R | R1 | Scope, E, A> {
   return IO.acquireReleaseExit(self, finalizer);
 }

package/_src/IO/api/withRuntimeConfig.ts

@@ -4,7 +4,11 @@
  *
  * @tsplus fluent fncts.io.IO withRuntimeConfig
  */
-export function withRuntimeConfig_<R, E, A>(self: IO<R, E, A>, runtimeConfig: Lazy<RuntimeConfig>): IO<R, E, A> {
+export function withRuntimeConfig_<R, E, A>(
+  self: IO<R, E, A>,
+  runtimeConfig: Lazy<RuntimeConfig>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
   return IO.runtimeConfig.flatMap((currentRuntimeConfig) =>
     IO.setRuntimeConfig(runtimeConfig)
       .apSecond(IO.yieldNow)

package/_src/IO/api/zipC.ts

@@ -4,7 +4,11 @@ import { AtomicReference } from "@fncts/base/internal/AtomicReference";
 /**
  * @tsplus fluent fncts.io.IO zipC
  */
-export function zipC_<R, E, A, R1, E1, B>(self: IO<R, E, A>, that: IO<R1, E1, B>): IO<R & R1, E | E1, readonly [A, B]> {
+export function zipC_<R, E, A, R1, E1, B>(
+  self: IO<R, E, A>,
+  that: IO<R1, E1, B>,
+  __tsplusTrace?: string,
+): IO<R | R1, E | E1, readonly [A, B]> {
   return self.zipWithC(that, tuple);
 }
 
@@ -15,7 +19,8 @@ export function zipWithC_<R, E, A, R1, E1, B, C>(
   self: IO<R, E, A>,
   that: IO<R1, E1, B>,
   f: (a: A, b: B) => C,
-): IO<R & R1, E | E1, C> {
+  __tsplusTrace?: string,
+): IO<R | R1, E | E1, C> {
   return IO.descriptorWith((descriptor) =>
     IO.uninterruptibleMask(({ restore }) => {
       const future = Future.unsafeMake<void, C>(FiberId.none);