@fncts/io 0.0.21 → 0.0.22

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

@@ -1,55 +1,58 @@
+import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
+
 import { ExitTag } from "@fncts/base/data/Exit";
+import { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
+import { unsafeMakeChildFiber } from "@fncts/io/IO/api/fork";
 
 import { FiberScope } from "../../FiberScope.js";
-import { Fork, IO, Race } from "../definition.js";
+import { IO } from "../definition.js";
 
 /**
  * @tsplus getter fncts.io.IO daemonChildren
  */
 export function daemonChildren<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return IO.defer(FiberRef.forkScopeOverride.locally(Just(FiberScope.global))(self));
+  return FiberRef.forkScopeOverride.locally(Just(FiberScope.global))(self);
 }
 
 /**
- * Retrieves the scope that will be used to supervise forked effects.
- *
- * @tsplus static fncts.io.IOOps forkScope
+ * @tsplus pipeable fncts.io.IO raceFibersWith
  */
-export const forkScope: UIO<FiberScope> = IO.withFiberContext((fiber) =>
-  IO(fiber.unsafeGetRef(FiberRef.forkScopeOverride).getOrElse(fiber.scope)),
-);
-
-/**
- * Retrieves the scope that will be used to supervise forked effects.
- *
- * @tsplus static fncts.io.IOOps forkScopeWith
- */
-export function forkScopeWith<R, E, A>(f: (_: FiberScope) => IO<R, E, A>, __tsplusTrace?: string) {
-  return forkScope.flatMap(f);
-}
-
-export class ForkScopeRestore {
-  constructor(private scope: FiberScope) {}
+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>,
+  __tsplusTrace?: string,
+) {
+  return (left: IO<R, E, A>): IO<R | R1 | R2 | R3, E2 | E3, C | D> => {
+    return IO.withFiberRuntime((parentState, parentStatus) => {
+      const right0             = right();
+      const parentRuntimeFlags = parentStatus.runtimeFlags;
+      function complete<E0, E1, A, B, R2, E2, C>(
+        winner: FiberRuntime<E0, A>,
+        loser: FiberRuntime<E1, B>,
+        cont: (winner: FiberRuntime<E0, A>, loser: FiberRuntime<E1, B>) => IO<R2, E2, C>,
+        ab: AtomicBoolean,
+        cb: (_: IO<R2, E2, C>) => any,
+      ): any {
+        if (ab.compareAndSet(true, false)) {
+          cb(cont(winner, loser));
+        }
+      }
 
-  readonly restore = <R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> =>
-    FiberRef.forkScopeOverride.locally(Just(this.scope))(ma);
-}
+      const raceIndicator = new AtomicBoolean(true);
+      const leftFiber     = unsafeMakeChildFiber(left, parentState, parentRuntimeFlags, null, __tsplusTrace);
+      const rightFiber    = unsafeMakeChildFiber(right0, parentState, parentRuntimeFlags, null, __tsplusTrace);
+      leftFiber.setFiberRef(FiberRef.forkScopeOverride, Just(parentState.scope));
+      rightFiber.setFiberRef(FiberRef.forkScopeOverride, Just(parentState.scope));
 
-/**
- * Captures the fork scope, before overriding it with the specified new
- * scope, passing a function that allows restoring the fork scope to
- * what it was originally.
- *
- * @tsplus static fncts.io.IOOps forkScopeMask
- */
-export function forkScopeMask<R, E, A>(
-  newScope: FiberScope,
-  f: (restore: ForkScopeRestore) => IO<R, E, A>,
-  __tsplusTrace?: string,
-): IO<R, E, A> {
-  return IO.forkScopeWith((scope) =>
-    FiberRef.forkScopeOverride.locally(Just(newScope))(f(new ForkScopeRestore(scope))),
-  );
+      return IO.async((cb) => {
+        leftFiber.addObserver(() => complete(leftFiber, rightFiber, leftWins, raceIndicator, cb));
+        rightFiber.addObserver(() => complete(rightFiber, leftFiber, rightWins, raceIndicator, cb));
+        leftFiber.startFork(left);
+        rightFiber.startFork(right0);
+      });
+    });
+  };
 }
 
 /**
@@ -58,37 +61,33 @@ export function forkScopeMask<R, E, A>(
  *
  * @tsplus pipeable fncts.io.IO raceWith
  */
-export function raceWith<E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(
+export function raceWith<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(
   right: Lazy<IO<R1, E1, A1>>,
   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,
 ) {
-  return <R>(left: IO<R, E, A>): IO<R | R1 | R2 | R3, E2 | E3, A2 | A3> => {
-    return IO.defer(
-      () =>
-        new Race(
-          left,
-          right(),
-          (winner, loser) =>
-            winner.await.flatMap((exit) => {
-              switch (exit._tag) {
-                case ExitTag.Success:
-                  return winner.inheritRefs.flatMap(() => leftWins(exit, loser));
-                case ExitTag.Failure:
-                  return leftWins(exit, loser);
-              }
-            }),
-          (winner, loser) =>
-            winner.await.flatMap((exit) => {
-              switch (exit._tag) {
-                case ExitTag.Success:
-                  return winner.inheritRefs.flatMap(() => rightWins(exit, loser));
-                case ExitTag.Failure:
-                  return rightWins(exit, loser);
-              }
-            }),
-        ),
+  return (left: IO<R, E, A>): IO<R | R1 | R2 | R3, E2 | E3, A2 | A3> => {
+    return left.raceFibersWith(
+      right,
+      (winner, loser) =>
+        winner.await.flatMap((exit) => {
+          switch (exit._tag) {
+            case ExitTag.Success:
+              return winner.inheritAll.flatMap(() => leftWins(exit, loser));
+            case ExitTag.Failure:
+              return leftWins(exit, loser);
+          }
+        }),
+      (winner, loser) =>
+        winner.await.flatMap((exit) => {
+          switch (exit._tag) {
+            case ExitTag.Success:
+              return winner.inheritAll.flatMap(() => rightWins(exit, loser));
+            case ExitTag.Failure:
+              return rightWins(exit, loser);
+          }
+        }),
     );
   };
 }
@@ -106,7 +105,11 @@ export type Grafter = <R, E, A>(effect: IO<R, E, A>) => IO<R, E, A>;
  * @tsplus static fncts.io.IOOps transplant
  */
 export function transplant<R, E, A>(f: (_: Grafter) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return forkScopeWith((scope) => f((e) => FiberRef.forkScopeOverride.locally(Just(scope))(e)));
+  return IO.withFiberRuntime((fiberState) => {
+    const scopeOverride = fiberState.getFiberRef(FiberRef.forkScopeOverride);
+    const scope         = scopeOverride.getOrElse(fiberState.scope);
+    return f(FiberRef.forkScopeOverride.locally(Just(scope)));
+  });
 }
 
 /**
@@ -116,28 +119,6 @@ export function transplant<R, E, A>(f: (_: Grafter) => IO<R, E, A>, __tsplusTrac
  *
  * @tsplus getter fncts.io.IO forkDaemon
  */
-export function forkDaemon<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R, Fiber.Runtime<E, A>> {
-  return new Fork(ma, Just(FiberScope.global), __tsplusTrace);
-}
-
-/**
- * Returns a new effect that will utilize the specified scope to supervise
- * any fibers forked within the original effect.
- *
- * @tsplus pipeable fncts.io.IO overrideForkScope
- */
-export function overrideForkScope(scope: FiberScope, __tsplusTrace?: string) {
-  return <R, E, A>(ma: IO<R, E, A>): IO<R, E, A> => {
-    return FiberRef.forkScopeOverride.locally(Just(scope))(ma);
-  };
-}
-
-/**
- * Returns a new effect that will utilize the default scope (fiber scope) to
- * supervise any fibers forked within the original effect.
- *
- * @tsplus getter fncts.io.IO defaultForkScope
- */
-export function defaultForkScope<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return FiberRef.forkScopeOverride.locally(Nothing())(ma);
+export function forkDaemon<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R, FiberRuntime<E, A>> {
+  return ma.fork.daemonChildren;
 }

package/_src/IO/api/delay.ts

@@ -0,0 +1,8 @@
+/**
+ * @tsplus pipeable fncts.io.IO delay
+ */
+export function delay(duration: Lazy<Duration>) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R, E, A> => {
+    return IO.sleep(duration) > self;
+  };
+}

package/_src/IO/api/{foreachC.ts → foreachConcurrent.ts}

@@ -13,10 +13,10 @@ import { AtomicNumber } from "@fncts/base/internal/AtomicNumber";
  *
  * Additionally, interrupts all effects on any failure.
  *
- * @tsplus static fncts.io.IOOps foreachDiscardC
- * @tsplus fluent fncts.Iterable traverseIODiscardC
+ * @tsplus static fncts.io.IOOps foreachConcurrentDiscard
+ * @tsplus fluent fncts.Iterable traverseIOConcurrentDiscard
  */
-export function foreachDiscardC<R, E, A>(
+export function foreachConcurrentDiscard<R, E, A>(
   as: Iterable<A>,
   f: (a: A) => IO<R, E, any>,
   __tsplusTrace?: string,
@@ -35,10 +35,10 @@ export function foreachDiscardC<R, E, A>(
  *
  * For a sequential version of this method, see `IO.foreach`.
  *
- * @tsplus static fncts.io.IOOps foreachC
- * @tsplus fluent fncts.Iterable traverseIOC
+ * @tsplus static fncts.io.IOOps foreachConcurrent
+ * @tsplus fluent fncts.Iterable traverseIOConcurrent
  */
-export function foreachC<R, E, A, B>(
+export function foreachConcurrent<R, E, A, B>(
   as: Iterable<A>,
   f: (a: A) => IO<R, E, B>,
   __tsplusTrace?: string,
@@ -71,7 +71,7 @@ function foreachConcurrentUnboundedDiscard<R, E, A>(
           (a) =>
             graft(
               restore(IO.defer(f(a))).matchCauseIO(
-                (cause) => future.fail(undefined).apSecond(IO.failCauseNow(cause)),
+                (cause) => future.fail(undefined).zipRight(IO.failCauseNow(cause)),
                 () => {
                   if (ref.incrementAndGet() === size) {
                     future.unsafeDone(IO.unit);
@@ -85,7 +85,7 @@ function foreachConcurrentUnboundedDiscard<R, E, A>(
         restore(future.await).matchCauseIO(
           (cause) =>
             foreachConcurrentUnbounded(fibers, (f) => f.interrupt).flatMap((exits) =>
-              Exit.collectAllC(exits).match(
+              Exit.collectAllConcurrent(exits).match(
                 () => IO.failCauseNow(cause.stripFailures),
                 (exit) =>
                   exit.isFailure()

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.foreachC(as, f).withConcurrencyUnbounded,
-    (fiberBound) => IO.foreachC(as, f).withConcurrency(fiberBound),
+    () => IO.foreachConcurrent(as, f).withConcurrencyUnbounded,
+    (fiberBound) => IO.foreachConcurrent(as, f).withConcurrency(fiberBound),
   );
 }

package/_src/IO/api/fork.ts

@@ -0,0 +1,83 @@
+import type { RuntimeFlags } from "@fncts/io/RuntimeFlags";
+
+import { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
+
+/**
+ * Returns an IO that forks this IO into its own separate fiber,
+ * returning the fiber immediately, without waiting for it to begin executing
+ * the IO.
+ *
+ * You can use the `fork` method whenever you want to execute an IO in a
+ * new fiber, concurrently and without "blocking" the fiber executing other
+ * IOs. Using fibers can be tricky, so instead of using this method
+ * directly, consider other higher-level methods, such as `raceWith`,
+ * `zipPar`, and so forth.
+ *
+ * The fiber returned by this method has methods interrupt the fiber and to
+ * wait for it to finish executing the IO. See `Fiber` for more
+ * information.
+ *
+ * Whenever you use this method to launch a new fiber, the new fiber is
+ * attached to the parent fiber's scope. This means when the parent fiber
+ * terminates, the child fiber will be terminated as well, ensuring that no
+ * fibers leak. This behavior is called "None supervision", and if this
+ * behavior is not desired, you may use the `forkDaemon` or `forkIn`
+ * methods.
+ *
+ * @tsplus getter fncts.io.IO fork
+ */
+export function fork<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R, FiberRuntime<E, A>> {
+  return IO.withFiberRuntime((fiberState, status) =>
+    IO.succeedNow(unsafeFork(ma, fiberState, status.runtimeFlags, null, __tsplusTrace)),
+  );
+}
+
+/**
+ * @tsplus pipeable fncts.io.IO forkWithScopeOverride
+ */
+export function forkWithScopeOverride(scopeOverride: FiberScope | null, __tsplusTrace?: string) {
+  return <R, E, A>(self: IO<R, E, A>): URIO<R, FiberRuntime<E, A>> => {
+    return IO.withFiberRuntime((parentFiber, parentStatus) =>
+      IO.succeedNow(unsafeFork(self, parentFiber, parentStatus.runtimeFlags, scopeOverride, __tsplusTrace)),
+    );
+  };
+}
+
+export function unsafeFork<R, E, A, E1, B>(
+  effect: IO<R, E, A>,
+  parentFiber: FiberRuntime<E1, B>,
+  parentRuntimeFlags: RuntimeFlags,
+  overrideScope: FiberScope | null,
+  trace?: string,
+): FiberRuntime<E, A> {
+  const fiber = unsafeMakeChildFiber(effect, parentFiber, parentRuntimeFlags, overrideScope, trace);
+  fiber.resume(effect);
+  return fiber;
+}
+
+export function unsafeMakeChildFiber<R, E, A, E1, B>(
+  effect: IO<R, E, A>,
+  parentFiber: FiberRuntime<E1, B>,
+  parentRuntimeFlags: RuntimeFlags,
+  overrideScope: FiberScope | null,
+  trace?: string,
+): FiberRuntime<E, A> {
+  const childId         = FiberId.unsafeMake(trace);
+  const parentFiberRefs = parentFiber.getFiberRefs();
+  const childFiberRefs  = parentFiberRefs.forkAs(childId);
+
+  const childFiber = new FiberRuntime<E, A>(childId, childFiberRefs, parentRuntimeFlags);
+
+  const childEnvironment = childFiberRefs.getOrDefault(FiberRef.currentEnvironment);
+
+  const supervisor = childFiber.getSupervisor();
+  if (supervisor !== Supervisor.none) {
+    supervisor.unsafeOnStart(childEnvironment, effect as IO<any, any, any>, Just(parentFiber), childFiber);
+    childFiber.addObserver((exit) => supervisor.unsafeOnEnd(exit, childFiber));
+  }
+
+  const parentScope = overrideScope ?? parentFiber.getFiberRef(FiberRef.forkScopeOverride).getOrElse(parentFiber.scope);
+  parentScope.unsafeAdd(parentFiber, parentRuntimeFlags, childFiber);
+
+  return childFiber;
+}

package/_src/IO/api/interrupt.ts

@@ -1,3 +1,7 @@
+import { Dynamic, Interruptible, Uninterruptible } from "@fncts/io/IO/definition";
+import { RuntimeFlag } from "@fncts/io/RuntimeFlag";
+import { RuntimeFlags } from "@fncts/io/RuntimeFlags";
+
 /**
  * Returns an effect that is interrupted as if by the specified fiber.
  *
@@ -15,26 +19,21 @@ export function interruptAs(fiberId: FiberId, __tsplusTrace?: string): FIO<never
  */
 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
- * effect becomes interruptible (the default), while if `false` is used, then
- * the effect becomes uninterruptible. These changes are compositional, so
- * they only affect regions of the effect.
- *
- * @tsplus pipeable fncts.io.IO setInterruptStatus
- */
-export function setInterruptStatus(flag: InterruptStatus, __tsplusTrace?: string) {
-  return <R, E, A>(self: IO<R, E, A>): IO<R, E, A> => {
-    return IO.withFiberContext((fiber) => {
-      const b = flag.toBoolean;
-      if (fiber.unsafeIsInterruptible !== b) {
-        fiber.interruptStatus.push(b);
-        fiber.unsafeRestoreInterruptStatus();
-      }
-      return self;
-    });
-  };
-}
+// /**
+//  * Switches the interrupt status for this effect. If `true` is used, then the
+//  * effect becomes interruptible (the default), while if `false` is used, then
+//  * the effect becomes uninterruptible. These changes are compositional, so
+//  * they only affect regions of the effect.
+//  *
+//  * @tsplus fluent fncts.io.IO setInterruptStatus
+//  */
+// export function setInterruptStatus_<R, E, A>(
+//   self: IO<R, E, A>,
+//   flag: InterruptStatus,
+//   __tsplusTrace?: string,
+// ): IO<R, E, A> {
+//   return new SetInterrupt(self, flag, __tsplusTrace);
+// }
 
 /**
  * Returns a new effect that performs the same operations as this effect, but
@@ -51,7 +50,8 @@ export function setInterruptStatus(flag: InterruptStatus, __tsplusTrace?: string
  * @tsplus static fncts.io.IOOps interruptible
  */
 export function interruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return self.setInterruptStatus(InterruptStatus.interruptible);
+  return new Interruptible(self, __tsplusTrace);
+  // return self.setInterruptStatus(InterruptStatus.interruptible);
 }
 
 /**
@@ -66,7 +66,8 @@ 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 self.setInterruptStatus(InterruptStatus.uninterruptible);
+  return new Uninterruptible(self, __tsplusTrace);
+  // return self.setInterruptStatus(InterruptStatus.uninterruptible);
 }
 
 /**
@@ -76,11 +77,28 @@ 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>,
-  __tsplusTrace?: string,
-): IO<R, E, A> {
-  return IO.checkInterruptible((flag) => f(new InterruptStatusRestore(flag)).uninterruptible);
+export function uninterruptibleMask<R, E, A>(f: (restore: InterruptStatusRestore) => IO<R, E, A>): IO<R, E, A> {
+  return new Dynamic(RuntimeFlags.disable(RuntimeFlag.Interruption), (oldFlags) =>
+    f(new InterruptStatusRestore(InterruptStatus.fromBoolean(oldFlags.interruption))),
+  );
+}
+
+/**
+ * @tsplus pipeable fncts.io.IO ensuring
+ */
+export function ensuring<R1>(finalizer: IO<R1, never, any>, __tsplusTrace?: string) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E, A> => {
+    return IO.uninterruptibleMask(({ restore }) =>
+      restore(self).matchCauseIO(
+        (cause1) =>
+          finalizer.matchCauseIO(
+            (cause2) => IO.failCauseNow(Cause.then(cause1, cause2)),
+            () => IO.failCauseNow(cause1),
+          ),
+        (a) => finalizer.map(() => a),
+      ),
+    );
+  };
 }
 
 /**
@@ -101,41 +119,42 @@ export function interruptibleMask<R, E, A>(
  * Calls the specified function, and runs the effect it returns, if this
  * effect is interrupted.
  *
- * @tsplus pipeable fncts.io.IO onInterrupt
+ * @tsplus fluent fncts.io.IO onInterrupt
  */
-export function onInterrupt_<R1>(
+export function onInterrupt_<R, E, A, R1>(
+  ma: IO<R, E, A>,
   cleanup: (interruptors: HashSet<FiberId>) => IO<R1, never, any>,
   __tsplusTrace?: string,
-) {
-  return <R, E, A>(ma: IO<R, E, A>): IO<R | R1, E, A> => {
-    return uninterruptibleMask(({ restore }) =>
-      restore(ma).matchCauseIO(
-        (cause) =>
-          cause.interrupted ? cleanup(cause.interruptors).apSecond(IO.failCauseNow(cause)) : IO.failCauseNow(cause),
-        IO.succeedNow,
-      ),
-    );
-  };
+): IO<R | R1, E, A> {
+  return uninterruptibleMask(({ restore }) =>
+    restore(ma).matchCauseIO(
+      (cause) =>
+        cause.interrupted ? cleanup(cause.interruptors).zipRight(IO.failCauseNow(cause)) : IO.failCauseNow(cause),
+      IO.succeedNow,
+    ),
+  );
 }
 
 /**
  * Calls the specified function, and runs the effect it returns, if this
  * effect is interrupted (allows for expanding error).
  *
- * @tsplus pipeable fncts.io.IO onInterruptExtended
+ * @tsplus fluent fncts.io.IO onInterruptExtended
  */
-export function onInterruptExtended_<R2, E2>(cleanup: Lazy<IO<R2, E2, any>>, __tsplusTrace?: string) {
-  return <R, E, A>(self: IO<R, E, A>): IO<R | R2, E | E2, A> => {
-    return uninterruptibleMask(({ restore }) =>
-      restore(self).matchCauseIO(
-        (cause) =>
-          cause.interrupted
-            ? cleanup().matchCauseIO(IO.failCauseNow, () => IO.failCauseNow(cause))
-            : IO.failCauseNow(cause),
-        IO.succeedNow,
-      ),
-    );
-  };
+export function onInterruptExtended_<R, E, A, R2, E2>(
+  self: IO<R, E, A>,
+  cleanup: Lazy<IO<R2, E2, any>>,
+  __tsplusTrace?: string,
+): IO<R | R2, E | E2, A> {
+  return uninterruptibleMask(({ restore }) =>
+    restore(self).matchCauseIO(
+      (cause) =>
+        cause.interrupted
+          ? cleanup().matchCauseIO(IO.failCauseNow, () => IO.failCauseNow(cause))
+          : IO.failCauseNow(cause),
+      IO.succeedNow,
+    ),
+  );
 }
 
 /**
@@ -169,12 +188,13 @@ export function disconnect<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string):
 export class InterruptStatusRestore {
   constructor(readonly flag: InterruptStatus) {}
 
-  restore = <R, E, A>(io: IO<R, E, A>): IO<R, E, A> => io.setInterruptStatus(this.flag);
+  restore = <R, E, A>(io: IO<R, E, A>): IO<R, E, A> =>
+    this.flag.isInterruptible ? io.interruptible : io.uninterruptible;
 
   force = <R, E, A>(io: IO<R, E, A>): IO<R, E, A> => {
     if (this.flag.isUninteruptible) {
       return io.uninterruptible.disconnect.interruptible;
     }
-    return io.setInterruptStatus(this.flag);
+    return io.interruptible;
   };
 }

package/_src/IO/api/race.ts

@@ -13,20 +13,20 @@ function maybeDisconnect<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R
  *
  * @tsplus pipeable fncts.io.IO race
  */
-export function race<R1, E1, A1>(that: IO<R1, E1, A1>, __tsplusTrace?: string) {
+export function race<R1, E1, A1>(that: IO<R1, E1, A1>) {
   return <R, E, A>(io: IO<R, E, A>): IO<R | R1, E | E1, A | A1> => {
-    return IO.descriptorWith((descriptor) =>
+    return IO.fiberId.flatMap((id) =>
       maybeDisconnect(io).raceWith(
         maybeDisconnect(that),
         (exit, right) =>
           exit.match(
             (cause) => right.join.mapErrorCause((c) => Cause.both(cause, c)),
-            (a) => right.interruptAs(descriptor.id).as(a),
+            (a) => right.interruptAs(id).as(a),
           ),
         (exit, left) =>
           exit.match(
             (cause) => left.join.mapErrorCause((c) => Cause.both(cause, c)),
-            (a1) => left.interruptAs(descriptor.id).as(a1),
+            (a1) => left.interruptAs(id).as(a1),
           ),
       ),
     );

package/_src/IO/api/supervised.ts

@@ -1,12 +1,10 @@
 /**
- *
- * Returns an IO with the behavior of this one, but where all child
- * fibers forked in the effect are reported to the specified supervisor.
- *
- * @tsplus pipeable fncts.io.IO supervised
+ * @tsplus fluent fncts.io.IO supervised
  */
-export function supervised(supervisor: Supervisor<any>, __tsplusTrace?: string) {
-  return <R, E, A>(fa: IO<R, E, A>): IO<R, E, A> => {
-    return FiberRef.currentSupervisor.locally(supervisor)(fa);
-  };
+export function supervised<R, E, A>(
+  self: IO<R, E, A>,
+  supervisor: Lazy<Supervisor<any>>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
+  return FiberRef.currentSupervisor.locallyWith((_) => _.zip(supervisor()))(self);
 }

package/_src/IO/api/withChildren.ts

@@ -5,9 +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(true).flatMap((supervisor) =>
-    get(
-      supervisor.value.flatMap((children) => IO.descriptor.map((d) => children.filter((_) => _.id != d.id))),
-    ).supervised(supervisor),
+  return Supervisor.track(false).flatMap((supervisor) =>
+    get(supervisor.value.flatMap((children) => IO.fiberId.map((id) => children.filter((_) => _.id != id)))),
   );
 }

package/_src/IO/api/{zipC.ts → zipConcurrent.ts}

@@ -2,20 +2,20 @@ import { tuple } from "@fncts/base/data/function";
 import { AtomicReference } from "@fncts/base/internal/AtomicReference";
 
 /**
- * @tsplus pipeable fncts.io.IO zipC
+ * @tsplus pipeable fncts.io.IO zipConcurrent
  */
-export function zipC<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: string) {
+export function zipConcurrent<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: string) {
   return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E | E1, readonly [A, B]> => {
-    return self.zipWithC(that, tuple);
+    return self.zipWithConcurrent(that, tuple);
   };
 }
 
 /**
- * @tsplus pipeable fncts.io.IO zipWithC
+ * @tsplus pipeable fncts.io.IO zipWithConcurrent
  */
-export function zipWithC<A, R1, E1, B, C>(that: IO<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string) {
+export function zipWithConcurrent<A, R1, E1, B, C>(that: IO<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string) {
   return <R, E>(self: IO<R, E, A>): IO<R | R1, E | E1, C> => {
-    return IO.descriptorWith((descriptor) =>
+    return IO.fiberId.flatMap((fiberId) =>
       IO.uninterruptibleMask(({ restore }) => {
         const future = Future.unsafeMake<void, C>(FiberId.none);
         const ref    = new AtomicReference<Maybe<Either<A, B>>>(Nothing());
@@ -54,10 +54,10 @@ export function zipWithC<A, R1, E1, B, C>(that: IO<R1, E1, B>, f: (a: A, b: B) =
               restore(future.await).matchCauseIO(
                 (cause) =>
                   left
-                    .interruptAs(descriptor.id)
-                    .zipC(right.interruptAs(descriptor.id))
+                    .interruptAs(fiberId)
+                    .zipConcurrent(right.interruptAs(fiberId))
                     .flatMap(([left, right]) =>
-                      left.zipC(right).match(IO.failCauseNow, () => IO.failCauseNow(cause.stripFailures)),
+                      left.zipConcurrent(right).match(IO.failCauseNow, () => IO.failCauseNow(cause.stripFailures)),
                     ),
                 (c) => left.inheritRefs.zip(right.inheritRefs).as(c),
               ),