@fncts/io 0.0.33 → 0.0.35

package/_src/Fiber/FiberRuntime.ts

@@ -1,5 +1,6 @@
 import type { FiberStatus } from "../FiberStatus.js";
 import type { OnFailure, OnSuccess, OnSuccessAndFailure, UIO } from "../IO/definition.js";
+import type { WhileLoop } from "../IO/definition.js";
 import type { RuntimeFlags } from "../RuntimeFlags.js";
 
 import { isIOError } from "@fncts/base/data/exceptions";
@@ -12,29 +13,22 @@ import { Done, Suspended } from "../FiberStatus.js";
 import { Running } from "../FiberStatus.js";
 import { FiberStatusTag } from "../FiberStatus.js";
 import { LinkedQueue } from "../internal/MutableQueue.js";
-import { isIO } from "../IO/definition.js";
-import { WhileLoop } from "../IO/definition.js";
-import { IOOpCode } from "../IO/definition.js";
+import { IOPrimitive, isIO } from "../IO/definition.js";
+import { IOTag } from "../IO/definition.js";
 import { RuntimeFlag } from "../RuntimeFlag.js";
 import { FiberMessage, FiberMessageTag } from "./FiberMessage.js";
 
 export class RevertFlags {
-  readonly _tag = IOOpCode.RevertFlags;
+  readonly _tag = IOTag.RevertFlags;
   constructor(readonly patch: RuntimeFlags.Patch, readonly trace?: string) {}
 }
 
 export class UpdateTrace {
-  readonly _tag = IOOpCode.UpdateTrace;
+  readonly _tag = IOTag.UpdateTrace;
   constructor(readonly trace?: string) {}
 }
 
-export type Continuation =
-  | OnSuccess<any, any, any, any, any, any>
-  | OnSuccessAndFailure<any, any, any, any, any, any, any, any, any>
-  | OnFailure<any, any, any, any, any, any>
-  | WhileLoop<any, any, any>
-  | UpdateTrace
-  | RevertFlags;
+export type Continuation = OnSuccess | OnSuccessAndFailure | OnFailure | WhileLoop | UpdateTrace | RevertFlags;
 
 /**
  * @tsplus type fncts.io.Fiber
@@ -268,7 +262,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
           }
         } catch (e) {
           if (isIO(e)) {
-            if (IO.concrete(e)._tag === IOOpCode.YieldNow) {
+            if (IO.concrete(e)._tag === IOTag.YieldNow) {
               if (this._runtimeFlags.cooperativeYielding) {
                 this.tell(FiberMessage.YieldNow);
                 this.tell(FiberMessage.Resume(IO.unit));
@@ -276,7 +270,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
               } else {
                 effect = IO.unit;
               }
-            } else if (IO.concrete(e)._tag === IOOpCode.Async) {
+            } else if (IO.concrete(e)._tag === IOTag.Async) {
               effect = null!;
             } else {
               throw new Error(`Unhandled op ${IO.concrete(e)._tag}`);
@@ -302,6 +296,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
       if (this._runtimeFlags.opSupervision) {
         this.getSupervisor().unsafeOnEffect(this, cur);
       }
+
       const nextTrace = IO.concrete(cur).trace;
       if (nextTrace !== undefined) lastTrace = nextTrace;
 
@@ -317,27 +312,30 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
       }
       try {
         switch (cur._tag) {
-          case IOOpCode.Sync: {
-            const value = cur.evaluate();
+          case IOTag.Sync: {
+            const value = cur.i0();
             const cont  = this.getNextSuccessCont();
             if (cont) {
               switch (cont._tag) {
-                case IOOpCode.OnSuccess:
-                case IOOpCode.OnSuccessAndFailure: {
-                  cur = IO.concrete(cont.successK(value));
+                case IOTag.OnSuccess: {
+                  cur = IO.concrete(cont.i1(value));
+                  break;
+                }
+                case IOTag.OnSuccessAndFailure: {
+                  cur = IO.concrete(cont.i2(value));
                   break;
                 }
-                case IOOpCode.WhileLoop: {
-                  cont.process(value);
-                  if (cont.check()) {
+                case IOTag.WhileLoop: {
+                  cont.i2(value);
+                  if (cont.i0()) {
                     this.stack.push(cont);
-                    cur = IO.concrete(cont.body());
+                    cur = IO.concrete(cont.i1());
                   } else {
                     cur = IO.concrete(IO.unit);
                   }
                   break;
                 }
-                case IOOpCode.RevertFlags: {
+                case IOTag.RevertFlags: {
                   this.patchRuntimeFlags(this._runtimeFlags, cont.patch);
                   if (this._runtimeFlags.interruptible && this.isInterrupted()) {
                     cur = IO.concrete(IO.failCauseNow(this.getInterruptedCause()));
@@ -346,7 +344,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
                   }
                   break;
                 }
-                case IOOpCode.UpdateTrace: {
+                case IOTag.UpdateTrace: {
                   if (cont.trace !== undefined) lastTrace = cont.trace;
                   cur = IO.concrete(IO.unit);
                   break;
@@ -357,26 +355,26 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
             }
             break;
           }
-          case IOOpCode.OnSuccessAndFailure:
-          case IOOpCode.OnFailure:
-          case IOOpCode.OnSuccess: {
+          case IOTag.OnSuccessAndFailure:
+          case IOTag.OnFailure:
+          case IOTag.OnSuccess: {
             this.stack.push(cur);
-            cur = IO.concrete(cur.first);
+            cur = IO.concrete(cur.i0);
             break;
           }
-          case IOOpCode.Async: {
+          case IOTag.Async: {
             this.asyncTrace     = lastTrace;
-            this.asyncBlockinOn = cur.blockingOn();
-            this.initiateAsync(this._runtimeFlags, cur.registerCallback);
+            this.asyncBlockinOn = cur.i1();
+            this.initiateAsync(this._runtimeFlags, cur.i0);
             throw cur;
           }
-          case IOOpCode.UpdateRuntimeFlagsWithin: {
-            const updateFlags     = cur.update;
+          case IOTag.UpdateRuntimeFlagsWithin: {
+            const updateFlags     = cur.i0;
             const oldRuntimeFlags = this._runtimeFlags;
             const newRuntimeFlags = updateFlags.patch(oldRuntimeFlags);
 
             if (newRuntimeFlags === oldRuntimeFlags) {
-              cur = IO.concrete(cur.scope(oldRuntimeFlags));
+              cur = IO.concrete(cur.i1(oldRuntimeFlags));
             } else {
               if (newRuntimeFlags.interruptible && this.isInterrupted()) {
                 cur = IO.concrete(IO.failCauseNow(this.getInterruptedCause()));
@@ -384,84 +382,87 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
                 this.patchRuntimeFlags(this._runtimeFlags, updateFlags);
                 const revertFlags = newRuntimeFlags.diff(oldRuntimeFlags);
                 this.stack.push(new RevertFlags(revertFlags));
-                cur = IO.concrete(cur.scope(oldRuntimeFlags));
+                cur = IO.concrete(cur.i1(oldRuntimeFlags));
               }
             }
             break;
           }
-          case IOOpCode.GenerateStackTrace: {
+          case IOTag.GenerateStackTrace: {
             cur = IO.concrete(IO.succeedNow(this.generateStackTrace()));
             break;
           }
-          case IOOpCode.Stateful: {
-            cur = IO.concrete(cur.onState(this, new Running(this._runtimeFlags, lastTrace)));
+          case IOTag.Stateful: {
+            cur = IO.concrete(cur.i0(this, new Running(this._runtimeFlags, lastTrace)));
             break;
           }
-          case IOOpCode.SucceedNow: {
+          case IOTag.SucceedNow: {
             const oldCur = cur;
             const cont   = this.getNextSuccessCont();
             if (cont) {
               switch (cont._tag) {
-                case IOOpCode.OnSuccess:
-                case IOOpCode.OnSuccessAndFailure: {
-                  cur = IO.concrete(cont.successK(oldCur.value));
+                case IOTag.OnSuccess: {
+                  cur = IO.concrete(cont.i1(oldCur.i0));
+                  break;
+                }
+                case IOTag.OnSuccessAndFailure: {
+                  cur = IO.concrete(cont.i2(oldCur.i0));
                   break;
                 }
-                case IOOpCode.WhileLoop: {
-                  cont.process(oldCur.value);
-                  if (cont.check()) {
+                case IOTag.WhileLoop: {
+                  cont.i2(oldCur.i0);
+                  if (cont.i0()) {
                     this.stack.push(cont);
-                    cur = IO.concrete(cont.body());
+                    cur = IO.concrete(cont.i1());
                   } else {
                     cur = IO.concrete(IO.unit);
                   }
                   break;
                 }
-                case IOOpCode.RevertFlags: {
+                case IOTag.RevertFlags: {
                   this.patchRuntimeFlags(this._runtimeFlags, cont.patch);
                   if (this._runtimeFlags.interruptible && this.isInterrupted()) {
                     cur = IO.concrete(IO.failCauseNow(this.getInterruptedCause()));
                   }
                   break;
                 }
-                case IOOpCode.UpdateTrace: {
+                case IOTag.UpdateTrace: {
                   if (cont.trace !== undefined) lastTrace = cont.trace;
                   cur = IO.concrete(IO.unit);
                   break;
                 }
               }
             } else {
-              return Exit.succeed(oldCur.value);
+              return Exit.succeed(oldCur.i0);
             }
             break;
           }
-          case IOOpCode.Fail: {
-            const cause = cur.cause();
+          case IOTag.Fail: {
+            const cause = cur.i0();
             const cont  = this.getNextFailCont();
             if (cont) {
               switch (cont._tag) {
-                case IOOpCode.OnFailure:
-                case IOOpCode.OnSuccessAndFailure: {
+                case IOTag.OnFailure:
+                case IOTag.OnSuccessAndFailure: {
                   if (!(this._runtimeFlags.interruptible && this.isInterrupted())) {
-                    cur = IO.concrete(cont.failureK(cause));
+                    cur = IO.concrete(cont.i1(cause));
                   } else {
                     cur = IO.concrete(IO.failCauseNow(cause.stripFailures));
                   }
                   break;
                 }
-                case IOOpCode.RevertFlags: {
+                case IOTag.RevertFlags: {
                   this.patchRuntimeFlags(this._runtimeFlags, cont.patch);
                   if (this._runtimeFlags.interruptible && this.isInterrupted()) {
                     const interruptedCause = this.getInterruptedCause();
                     if (cause.contains(interruptedCause)) {
                       cur = IO.concrete(IO.failCauseNow(cause));
                     } else {
-                      cur = IO.concrete(IO.failCauseNow(Cause.then(cause, this.getInterruptedCause())));
+                      cur = IO.concrete(IO.failCauseNow(Cause.sequential(cause, this.getInterruptedCause())));
                     }
                   }
                   break;
                 }
-                case IOOpCode.UpdateTrace: {
+                case IOTag.UpdateTrace: {
                   if (cont.trace !== undefined) lastTrace = cont.trace;
                   cur = IO.concrete(IO.unit);
                   break;
@@ -472,15 +473,15 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
             }
             break;
           }
-          case IOOpCode.UpdateRuntimeFlags: {
-            this.patchRuntimeFlags(this._runtimeFlags, cur.update);
+          case IOTag.UpdateRuntimeFlags: {
+            this.patchRuntimeFlags(this._runtimeFlags, cur.i0);
             cur = IO.concrete(IO.unit);
             break;
           }
-          case IOOpCode.WhileLoop: {
+          case IOTag.WhileLoop: {
             const iterate = cur;
-            const check   = iterate.check;
-            const body    = iterate.body;
+            const check   = iterate.i0;
+            const body    = iterate.i1;
             if (check()) {
               cur = IO.concrete(body());
               this.stack.push(iterate);
@@ -489,10 +490,10 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
             }
             break;
           }
-          case IOOpCode.YieldNow: {
+          case IOTag.YieldNow: {
             throw cur;
           }
-          case IOOpCode.Commit: {
+          case IOTag.Commit: {
             cur = IO.concrete(cur.commit);
             break;
           }
@@ -524,10 +525,10 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
       } catch (e) {
         if (isIOError(e)) {
           cur = IO.concrete(IO.failCauseNow(e.cause));
-        } else if (isIO(e) && (IO.concrete(e)._tag === IOOpCode.Async || IO.concrete(e)._tag === IOOpCode.YieldNow)) {
+        } else if (isIO(e) && (IO.concrete(e)._tag === IOTag.Async || IO.concrete(e)._tag === IOTag.YieldNow)) {
           throw e;
         } else if (isInterruptedException(e)) {
-          cur = IO.concrete(IO.failCauseNow(Cause.both(Cause.halt(e), Cause.interrupt(FiberId.none))));
+          cur = IO.concrete(IO.failCauseNow(Cause.parallel(Cause.halt(e), Cause.interrupt(FiberId.none))));
         } else {
           cur = IO.concrete(IO.failCauseNow(Cause.halt(e, Trace(this.fiberId, Conc(TraceElement.parse(lastTrace))))));
         }
@@ -622,14 +623,14 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
         }
       };
 
-      return new WhileLoop(
-        check,
-        body,
-        () => {
-          //
-        },
-        this.id.location,
-      );
+      const io = new IOPrimitive(IOTag.WhileLoop) as any;
+      io.i0    = check;
+      io.i1    = body;
+      io.i2    = () => {
+        //
+      };
+
+      return io;
     } else {
       return null!;
     }
@@ -663,7 +664,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
     if (oldSC.contains(cause)) {
       return;
     }
-    this.setFiberRef(FiberRef.interruptedCause, Cause.then(oldSC, cause));
+    this.setFiberRef(FiberRef.interruptedCause, Cause.sequential(oldSC, cause));
   }
 
   private processNewInterruptSignal(cause: Cause<never>): void {
@@ -822,7 +823,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
   getNextSuccessCont() {
     while (this.stack.hasNext) {
       const frame = this.stack.pop()!;
-      if (frame._tag !== IOOpCode.OnFailure) {
+      if (frame._tag !== IOTag.OnFailure) {
         return frame;
       }
     }
@@ -831,7 +832,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
   getNextFailCont() {
     while (this.stack.hasNext) {
       const frame = this.stack.pop()!;
-      if (frame._tag !== IOOpCode.OnSuccess && frame._tag !== IOOpCode.WhileLoop) {
+      if (frame._tag !== IOTag.OnSuccess && frame._tag !== IOTag.WhileLoop) {
         return frame;
       }
     }

package/_src/Fiber/api/collectAll.ts

@@ -22,7 +22,7 @@ export function sequenceIterable<E, A>(
           (ra) =>
             b.match(
               () => Nothing(),
-              (rb) => Just(ra.zipWithCause(rb, (a, as) => as.prepend(a), Cause.both)),
+              (rb) => Just(ra.zipWithCause(rb, (a, as) => as.prepend(a), Cause.parallel)),
             ),
         ),
       ),

package/_src/Fiber/api/zipWith.ts

@@ -15,9 +15,9 @@ export function zipWith<A, E1, B, C>(that: Fiber<E1, B>, f: (a: A, b: B) => C, _
       self.children,
       that.inheritRefs > self.inheritRefs,
       self.poll.zipWith(that.poll, (ma, mb) =>
-        ma.isJust() && mb.isJust() ? Just(ma.value.zipWithCause(mb.value, f, Cause.then)) : Nothing(),
+        ma.isJust() && mb.isJust() ? Just(ma.value.zipWithCause(mb.value, f, Cause.sequential)) : Nothing(),
       ),
-      (id) => self.interruptAs(id).zipWith(that.interruptAs(id), (ea, eb) => ea.zipWithCause(eb, f, Cause.then)),
+      (id) => self.interruptAs(id).zipWith(that.interruptAs(id), (ea, eb) => ea.zipWithCause(eb, f, Cause.sequential)),
     );
   };
 }

package/_src/IO/api/all.ts

@@ -0,0 +1,64 @@
+import type { _A, _E, _R } from "@fncts/base/types";
+import type { EnvironmentOf, ErrorOf, IOVariance, ValueOf } from "@fncts/io/IO";
+
+/**
+ * @tsplus static fncts.io.IOOps all
+ */
+export function all<T extends ReadonlyArray<IO<any, any, any>>>(
+  ios: [...T],
+): IO<
+  { [K in number]: EnvironmentOf<T[K]> }[number],
+  { [K in number]: ErrorOf<T[K]> }[number],
+  { [K in keyof T]: ValueOf<T[K]> }
+>;
+export function all<T extends Iterable<IO<any, any, any>>>(
+  ios: T,
+): [T] extends [Iterable<infer A>] ? IO<EnvironmentOf<A>, ErrorOf<A>, Conc<ValueOf<A>>> : never;
+export function all<T extends Record<string, IO<any, any, any>>>(
+  ios: T,
+): IO<
+  { [K in keyof T]: EnvironmentOf<T[K]> }[keyof T],
+  { [K in keyof T]: ErrorOf<T[K]> }[keyof T],
+  { [K in keyof T]: ValueOf<T[K]> }
+>;
+export function all(ios: Record<string, IO<any, any, any>> | Iterable<IO<any, any, any>>): IO<any, any, any> {
+  if (Symbol.iterator in ios) {
+    return IO.foreach(ios, Function.identity);
+  } else {
+    return IO.foreach(
+      Object.entries(ios).map(([k, io]) => io.map((value) => [k, value] as const)),
+      Function.identity,
+    ).map((result) => result.foldLeft({} as Record<string, any>, (b, a) => Object.assign(b, { [a[0]]: a[1] })));
+  }
+}
+
+/**
+ * @tsplus static fncts.io.IOOps allConcurrent
+ */
+export function allConcurrent<T extends ReadonlyArray<IO<any, any, any>>>(
+  ios: [...T],
+): IO<
+  { [K in number]: EnvironmentOf<T[K]> }[number],
+  { [K in number]: ErrorOf<T[K]> }[number],
+  { [K in keyof T]: ValueOf<T[K]> }
+>;
+export function allConcurrent<T extends Iterable<IO<any, any, any>>>(
+  ios: T,
+): [T] extends [Iterable<infer A>] ? IO<EnvironmentOf<A>, ErrorOf<A>, Conc<ValueOf<A>>> : never;
+export function allConcurrent<T extends Record<string, IO<any, any, any>>>(
+  ios: T,
+): IO<
+  { [K in keyof T]: EnvironmentOf<T[K]> }[keyof T],
+  { [K in keyof T]: ErrorOf<T[K]> }[keyof T],
+  { [K in keyof T]: ValueOf<T[K]> }
+>;
+export function allConcurrent(ios: Record<string, IO<any, any, any>> | Iterable<IO<any, any, any>>): IO<any, any, any> {
+  if (Symbol.iterator in ios) {
+    return IO.foreachConcurrent(ios, Function.identity);
+  } else {
+    return IO.foreachConcurrent(
+      Object.entries(ios).map(([k, io]) => io.map((value) => [k, value] as const)),
+      Function.identity,
+    ).map((result) => result.foldLeft({} as Record<string, any>, (b, a) => Object.assign(b, { [a[0]]: a[1] })));
+  }
+}

package/_src/IO/api/bracketExit.ts

@@ -21,7 +21,7 @@ export function bracketExit<R, E, A, E1, R1, A1, R2, E2>(
           (cause2) =>
             IO.failCause(
               exit.match(
-                (cause1) => Cause.then(cause1, cause2),
+                (cause1) => Cause.sequential(cause1, cause2),
                 () => cause2,
               ),
             ),

package/_src/IO/api/concurrency.ts

@@ -41,3 +41,36 @@ export function withConcurrency(n: number, __tsplusTrace?: string) {
 export function withConcurrencyUnbounded<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
   return IO.defer(Concurrency.locally(Nothing())(ma));
 }
+
+export type ConcurrencyRestorer = <R, E, A>(io: IO<R, E, A>) => IO<R, E, A>;
+
+const MakeConcurrent =
+  (n: number): ConcurrencyRestorer =>
+  (io) =>
+    io.withConcurrency(n);
+
+const MakeConcurrentUnbounded: ConcurrencyRestorer = (io) => io.withConcurrencyUnbounded;
+
+/**
+ * @tsplus static fncts.io.IOOps withConcurrencyMask
+ */
+export function withConcurrencyMask<R, E, A>(n: number, f: (restore: ConcurrencyRestorer) => IO<R, E, A>): IO<R, E, A> {
+  return Concurrency.getWith((concurrency) =>
+    concurrency.match(
+      () => Concurrency.locally(Just(n))(f(MakeConcurrentUnbounded)),
+      (n0) => Concurrency.locally(Just(n))(f(MakeConcurrent(n0))),
+    ),
+  );
+}
+
+/**
+ * @tsplus static fncts.io.IOOps withConcurrencyUnboundedMask
+ */
+export function withConcurrencyUnboundedMask<R, E, A>(f: (restore: ConcurrencyRestorer) => IO<R, E, A>): IO<R, E, A> {
+  return Concurrency.getWith((concurrency) =>
+    concurrency.match(
+      () => Concurrency.locally(Nothing())(f(MakeConcurrentUnbounded)),
+      (n0) => Concurrency.locally(Nothing())(f(MakeConcurrent(n0))),
+    ),
+  );
+}

package/_src/IO/api/foreachConcurrent.ts

@@ -89,7 +89,7 @@ function foreachConcurrentUnboundedDiscard<R, E, A>(
                 () => IO.failCauseNow(cause.stripFailures),
                 (exit) =>
                   exit.isFailure()
-                    ? IO.failCauseNow(Cause.both(cause.stripFailures, exit.cause))
+                    ? IO.failCauseNow(Cause.parallel(cause.stripFailures, exit.cause))
                     : IO.failCauseNow(cause.stripFailures),
               ),
             ),

package/_src/IO/api/foreachExec.ts

@@ -14,7 +14,7 @@ export function foreachExec<R, E, A, B>(
 ): IO<R, E, Conc<B>> {
   return es.match(
     () => IO.foreach(as, f),
-    () => IO.foreachConcurrent(as, f).withConcurrencyUnbounded,
-    (fiberBound) => IO.foreachConcurrent(as, f).withConcurrency(fiberBound),
+    () => IO.withConcurrencyUnboundedMask((restore) => IO.foreachConcurrent(as, (a) => restore(f(a)))),
+    (fiberBound) => IO.withConcurrencyMask(fiberBound, (restore) => IO.foreachConcurrent(as, (a) => restore(f(a)))),
   );
 }

package/_src/IO/api/interrupt.ts

@@ -1,4 +1,4 @@
-import { Dynamic, Interruptible, Uninterruptible } from "@fncts/io/IO/definition";
+import { IOPrimitive,IOTag } from "@fncts/io/IO/definition";
 import { RuntimeFlag } from "@fncts/io/RuntimeFlag";
 import { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 
@@ -40,7 +40,11 @@ export const interrupt: IO<never, never, never> = IO.fiberId.flatMap(IO.interrup
  * @tsplus static fncts.io.IOOps interruptible
  */
 export function interruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return new Interruptible(self, __tsplusTrace);
+  const io = new IOPrimitive(IOTag.UpdateRuntimeFlagsWithin) as any;
+  io.i0    = RuntimeFlags.enable(RuntimeFlag.Interruption);
+  io.i1    = () => self;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
@@ -55,7 +59,11 @@ export function interruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string
  * @tsplus static fncts.io.IOOps uninterruptible
  */
 export function uninterruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return new Uninterruptible(self, __tsplusTrace);
+  const io = new IOPrimitive(IOTag.UpdateRuntimeFlagsWithin) as any;
+  io.i0    = RuntimeFlags.disable(RuntimeFlag.Interruption);
+  io.i1    = () => self;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
@@ -65,10 +73,15 @@ 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: InterruptibilityRestorer) => IO<R, E, A>): IO<R, E, A> {
-  return new Dynamic(RuntimeFlags.disable(RuntimeFlag.Interruption), (oldFlags) =>
-    f(oldFlags.interruption ? RestoreInterruptible : RestoreUninterruptible),
-  );
+export function uninterruptibleMask<R, E, A>(
+  f: (restore: InterruptibilityRestorer) => IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
+  const io = new IOPrimitive(IOTag.UpdateRuntimeFlagsWithin) as any;
+  io.i0    = RuntimeFlags.disable(RuntimeFlag.Interruption);
+  io.i1    = (oldFlags: RuntimeFlags) => f(oldFlags.interruption ? RestoreInterruptible : RestoreUninterruptible);
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
@@ -80,7 +93,7 @@ export function ensuring<R1>(finalizer: IO<R1, never, any>, __tsplusTrace?: stri
       restore(self).matchCauseIO(
         (cause1) =>
           finalizer.matchCauseIO(
-            (cause2) => IO.failCauseNow(Cause.then(cause1, cause2)),
+            (cause2) => IO.failCauseNow(Cause.sequential(cause1, cause2)),
             () => IO.failCauseNow(cause1),
           ),
         (a) => finalizer.map(() => a),
@@ -152,7 +165,7 @@ export function onExit<E, A, R1, E1>(cleanup: (exit: Exit<E, A>) => IO<R1, E1, a
         (failure1) => {
           const result = Exit.failCause(failure1);
           return cleanup(result).matchCauseIO(
-            (failure2) => IO.failCauseNow(Cause.then(failure1, failure2)),
+            (failure2) => IO.failCauseNow(Cause.sequential(failure1, failure2)),
             () => IO.fromExitNow(result),
           );
         },

package/_src/IO/api/race.ts

@@ -30,12 +30,12 @@ export function raceAwait<R1, E1, A1>(that: IO<R1, E1, A1>) {
         that,
         (exit, right) =>
           exit.match(
-            (cause) => right.join.mapErrorCause((c) => Cause.both(cause, c)),
+            (cause) => right.join.mapErrorCause((c) => Cause.parallel(cause, c)),
             (a) => right.interruptAs(id).as(a),
           ),
         (exit, left) =>
           exit.match(
-            (cause) => left.join.mapErrorCause((c) => Cause.both(cause, c)),
+            (cause) => left.join.mapErrorCause((c) => Cause.parallel(cause, c)),
             (a1) => left.interruptAs(id).as(a1),
           ),
       ),

package/_src/IO/api/raceWith.ts

@@ -10,6 +10,8 @@ export function raceFibersWith<R, E, A, R1, E1, B, R2, E2, C, R3, E3, D>(
   right: Lazy<IO<R1, E1, B>>,
   leftWins: (winner: FiberRuntime<E, A>, loser: FiberRuntime<E1, B>) => IO<R2, E2, C>,
   rightWins: (winner: FiberRuntime<E1, B>, loser: FiberRuntime<E, A>) => IO<R3, E3, D>,
+  leftScope: FiberScope | null = null,
+  rightScope: FiberScope | null = null,
   __tsplusTrace?: string,
 ) {
   return (left: IO<R, E, A>): IO<R | R1 | R2 | R3, E2 | E3, C | D> => {
@@ -29,8 +31,8 @@ export function raceFibersWith<R, E, A, R1, E1, B, R2, E2, C, R3, E3, D>(
       }
 
       const raceIndicator = new AtomicBoolean(true);
-      const leftFiber     = IO.unsafeMakeChildFiber(left, parentState, parentRuntimeFlags, null, __tsplusTrace);
-      const rightFiber    = IO.unsafeMakeChildFiber(right0, parentState, parentRuntimeFlags, null, __tsplusTrace);
+      const leftFiber     = IO.unsafeMakeChildFiber(left, parentState, parentRuntimeFlags, leftScope, __tsplusTrace);
+      const rightFiber    = IO.unsafeMakeChildFiber(right0, parentState, parentRuntimeFlags, rightScope, __tsplusTrace);
 
       return IO.async((cb) => {
         leftFiber.addObserver(() => complete(leftFiber, rightFiber, leftWins, raceIndicator, cb));

package/_src/IO/api/timeout.ts

@@ -3,7 +3,27 @@
  */
 export function timeoutTo<A, B, B1>(duration: Lazy<Duration>, b: Lazy<B>, f: (a: A) => B1, __tsplusTrace?: string) {
   return <R, E>(self: IO<R, E, A>): IO<R, E, B | B1> => {
-    return self.map(f).raceFirst(IO.sleep(duration).interruptible.as(b));
+    return IO.fiberIdWith((parentFiberId) =>
+      self.raceFibersWith(
+        IO.sleep(duration).interruptible,
+        (winner, loser) =>
+          winner.await.flatMap((exit) =>
+            exit.match(
+              (cause) => loser.interruptAs(parentFiberId) > IO.refailCause(cause),
+              (a) => winner.inheritAll > loser.interruptAs(parentFiberId).as(f(a)),
+            ),
+          ),
+        (winner, loser) =>
+          winner.await.flatMap((exit) =>
+            exit.match(
+              (cause) => loser.interruptAs(parentFiberId) > IO.refailCause(cause),
+              () => winner.inheritAll > loser.interruptAs(parentFiberId).as(b),
+            ),
+          ),
+        null,
+        FiberScope.global,
+      ),
+    );
   };
 }
 

package/_src/IO/api/zipConcurrent.ts

@@ -30,9 +30,9 @@ export function zipWithConcurrent<A, R1, E1, B, C>(that: IO<R1, E1, B>, f: (a: A
                 right.interruptFork >
                 left.await.zip(right.await).flatMap(([left, right]) =>
                   left
-                    .zipWithCause(right, f, (a, b) => Cause.both(a, b))
+                    .zipWithCause(right, f, (a, b) => Cause.parallel(a, b))
                     .match(
-                      (causes) => IO.refailCause(Cause.both(cause.stripFailures, causes)),
+                      (causes) => IO.refailCause(Cause.parallel(cause.stripFailures, causes)),
                       () => IO.refailCause(cause.stripFailures),
                     ),
                 ),