@fncts/io 0.0.32 → 0.0.34

package/_src/Fiber/FiberRuntime.ts

@@ -2,6 +2,8 @@ import type { FiberStatus } from "../FiberStatus.js";
 import type { OnFailure, OnSuccess, OnSuccessAndFailure, UIO } from "../IO/definition.js";
 import type { RuntimeFlags } from "../RuntimeFlags.js";
 
+import { isIOError } from "@fncts/base/data/exceptions";
+import { ExitTag } from "@fncts/base/data/Exit";
 import { Trace } from "@fncts/base/data/Trace";
 import { FiberTypeId, FiberVariance } from "@fncts/io/Fiber/definition";
 import { StackTraceBuilder } from "@fncts/io/internal/StackTraceBuilder";
@@ -13,17 +15,16 @@ 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 { isIOError } from "../IO/definition.js";
 import { RuntimeFlag } from "../RuntimeFlag.js";
 import { FiberMessage, FiberMessageTag } from "./FiberMessage.js";
 
 export class RevertFlags {
-  readonly ioOpCode = IOOpCode.RevertFlags;
+  readonly _tag = IOOpCode.RevertFlags;
   constructor(readonly patch: RuntimeFlags.Patch, readonly trace?: string) {}
 }
 
 export class UpdateTrace {
-  readonly ioOpCode = IOOpCode.UpdateTrace;
+  readonly _tag = IOOpCode.UpdateTrace;
   constructor(readonly trace?: string) {}
 }
 
@@ -267,7 +268,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
           }
         } catch (e) {
           if (isIO(e)) {
-            if (IO.concrete(e).ioOpCode === IOOpCode.YieldNow) {
+            if (IO.concrete(e)._tag === IOOpCode.YieldNow) {
               if (this._runtimeFlags.cooperativeYielding) {
                 this.tell(FiberMessage.YieldNow);
                 this.tell(FiberMessage.Resume(IO.unit));
@@ -275,10 +276,10 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
               } else {
                 effect = IO.unit;
               }
-            } else if (IO.concrete(e).ioOpCode === IOOpCode.Async) {
+            } else if (IO.concrete(e)._tag === IOOpCode.Async) {
               effect = null!;
             } else {
-              throw new Error(`Unhandled op ${IO.concrete(e).ioOpCode}`);
+              throw new Error(`Unhandled op ${IO.concrete(e)._tag}`);
             }
           } else {
             throw e;
@@ -315,12 +316,12 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
         cur          = IO.concrete(IO.yieldNow.flatMap(() => oldCur, trace));
       }
       try {
-        switch (cur.ioOpCode) {
+        switch (cur._tag) {
           case IOOpCode.Sync: {
             const value = cur.evaluate();
             const cont  = this.getNextSuccessCont();
             if (cont) {
-              switch (cont.ioOpCode) {
+              switch (cont._tag) {
                 case IOOpCode.OnSuccess:
                 case IOOpCode.OnSuccessAndFailure: {
                   cur = IO.concrete(cont.successK(value));
@@ -400,7 +401,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
             const oldCur = cur;
             const cont   = this.getNextSuccessCont();
             if (cont) {
-              switch (cont.ioOpCode) {
+              switch (cont._tag) {
                 case IOOpCode.OnSuccess:
                 case IOOpCode.OnSuccessAndFailure: {
                   cur = IO.concrete(cont.successK(oldCur.value));
@@ -438,7 +439,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
             const cause = cur.cause();
             const cont  = this.getNextFailCont();
             if (cont) {
-              switch (cont.ioOpCode) {
+              switch (cont._tag) {
                 case IOOpCode.OnFailure:
                 case IOOpCode.OnSuccessAndFailure: {
                   if (!(this._runtimeFlags.interruptible && this.isInterrupted())) {
@@ -455,7 +456,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
                     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;
@@ -493,18 +494,40 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
           }
           case IOOpCode.Commit: {
             cur = IO.concrete(cur.commit);
+            break;
+          }
+          case "Just": {
+            cur = IO.concrete(IO.succeedNow(cur.value));
+            break;
+          }
+          case "Nothing": {
+            cur = IO.concrete(IO.failNow(new NoSuchElementError()));
+            break;
+          }
+          case "Left": {
+            cur = IO.concrete(IO.failNow(cur.left));
+            break;
+          }
+          case "Right": {
+            cur = IO.concrete(IO.succeedNow(cur.right));
+            break;
+          }
+          case ExitTag.Failure: {
+            cur = IO.concrete(IO.failCauseNow(cur.cause));
+            break;
+          }
+          case ExitTag.Success: {
+            cur = IO.concrete(IO.succeedNow(cur.value));
+            break;
           }
         }
       } catch (e) {
         if (isIOError(e)) {
           cur = IO.concrete(IO.failCauseNow(e.cause));
-        } else if (
-          isIO(e) &&
-          (IO.concrete(e).ioOpCode === IOOpCode.Async || IO.concrete(e).ioOpCode === IOOpCode.YieldNow)
-        ) {
+        } else if (isIO(e) && (IO.concrete(e)._tag === IOOpCode.Async || IO.concrete(e)._tag === IOOpCode.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))))));
         }
@@ -640,7 +663,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 {
@@ -799,7 +822,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
   getNextSuccessCont() {
     while (this.stack.hasNext) {
       const frame = this.stack.pop()!;
-      if (frame.ioOpCode !== IOOpCode.OnFailure) {
+      if (frame._tag !== IOOpCode.OnFailure) {
         return frame;
       }
     }
@@ -808,7 +831,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
   getNextFailCont() {
     while (this.stack.hasNext) {
       const frame = this.stack.pop()!;
-      if (frame.ioOpCode !== IOOpCode.OnSuccess && frame.ioOpCode !== IOOpCode.WhileLoop) {
+      if (frame._tag !== IOOpCode.OnSuccess && frame._tag !== IOOpCode.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/asyncIO.ts

@@ -10,7 +10,7 @@ export function asyncIO<R, E, A>(
     const r = Δ(IO.runtime<R>());
     const a = Δ(
       IO.uninterruptibleMask((restore) => {
-        const io = register((k) => r.unsafeRunAsync(k.fulfill(f)));
+        const io = register((k) => r.unsafeRunFiber(k.fulfill(f)));
         return restore(io.catchAllCause((cause) => f.failCause(cause))).fork > restore(f.await);
       }),
     );

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/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/interrupt.ts

@@ -80,7 +80,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 +152,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/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),
                     ),
                 ),

package/_src/IO/api.ts

@@ -4,6 +4,7 @@ import type { _E, _R } from "@fncts/base/types";
 import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
 import type { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 
+import { IOError } from "@fncts/base/data/exceptions";
 import { identity, pipe, tuple } from "@fncts/base/data/function";
 import {
   Async,
@@ -15,7 +16,7 @@ import {
   YieldNow,
 } from "@fncts/io/IO/definition";
 import { Stateful } from "@fncts/io/IO/definition";
-import { Fail, IO, IOError, SucceedNow } from "@fncts/io/IO/definition";
+import { Fail, IO, SucceedNow } from "@fncts/io/IO/definition";
 
 /**
  * Imports an asynchronous side-effect into a `IO`
@@ -851,8 +852,8 @@ export function fromMaybe<A>(maybe: Lazy<Maybe<A>>, __tsplusTrace?: string): FIO
  * @tsplus static fncts.io.IOOps fromMaybeNow
  * @tsplus getter fncts.Maybe toIO
  */
-export function fromMaybeNow<A = never>(maybe: Maybe<A>, __tsplusTrace?: string): IO<unknown, Maybe<never>, A> {
-  return maybe.match(() => IO.failNow(Nothing()), IO.succeedNow);
+export function fromMaybeNow<A = never>(maybe: Maybe<A>, __tsplusTrace?: string): IO<never, NoSuchElementError, A> {
+  return maybe.match(() => IO.failNow(new NoSuchElementError("IO.fromMaybeNow")), IO.succeedNow);
 }
 
 /**
@@ -1575,7 +1576,7 @@ export function result<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R,
 /**
  * Recover from the unchecked failure of the `IO`. (opposite of `orHalt`)
  *
- * @trace call
+ * @tsplus getter fncts.io.IO resurrect
  */
 export function resurrect<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, unknown, A> {
   return io.unrefineWith(Maybe.just, identity);

package/_src/IO/definition.ts

@@ -1,6 +1,8 @@
 import type { FiberRuntime } from "../Fiber/FiberRuntime.js";
 import type { Running } from "../FiberStatus.js";
 import type { RuntimeFlagsPatch } from "../RuntimeFlags.js";
+import type { Left, Right } from "@fncts/base/data/Either";
+import type { Failure, Success } from "@fncts/base/data/Exit";
 import type { Trace } from "@fncts/base/data/Trace";
 
 import { RuntimeFlag } from "../RuntimeFlag.js";
@@ -34,6 +36,17 @@ export abstract class IO<R, E, A> {
   };
 }
 
+declare module "@fncts/base/data/Either/definition" {
+  interface Either<E, A> extends IO<never, E, A> {}
+}
+declare module "@fncts/base/data/Maybe/definition" {
+  interface Maybe<A> extends IO<never, NoSuchElementError, A> {}
+}
+declare module "@fncts/base/data/Exit/definition" {
+  interface Success<A> extends IO<never, never, A> {}
+  interface Failure<E> extends IO<never, E, never> {}
+}
+
 /**
  * @tsplus type fncts.io.IOAspects
  */
@@ -87,14 +100,14 @@ export function isIO(u: unknown): u is IO<any, any, any> {
 }
 
 export class Sync<A> extends IO<never, never, A> {
-  readonly ioOpCode = IOOpCode.Sync;
+  readonly _tag = IOOpCode.Sync;
   constructor(readonly evaluate: () => A, readonly trace?: string) {
     super();
   }
 }
 
 export class Async<R, E, A> extends IO<R, E, A> {
-  readonly ioOpCode = IOOpCode.Async;
+  readonly _tag = IOOpCode.Async;
   constructor(
     readonly registerCallback: (f: (_: IO<R, E, A>) => void) => any,
     readonly blockingOn: () => FiberId,
@@ -108,7 +121,7 @@ export class Async<R, E, A> extends IO<R, E, A> {
  * @internal
  */
 export class OnSuccessAndFailure<R, E, A, R1, E1, B, R2, E2, C> extends IO<R | R1 | R2, E1 | E2, B | C> {
-  readonly ioOpCode = IOOpCode.OnSuccessAndFailure;
+  readonly _tag = IOOpCode.OnSuccessAndFailure;
 
   constructor(
     readonly first: IO<R, E, A>,
@@ -128,7 +141,7 @@ export class OnSuccessAndFailure<R, E, A, R1, E1, B, R2, E2, C> extends IO<R | R
 }
 
 export class OnFailure<R, E, A, R1, E1, B> extends IO<R | R1, E1, A | B> {
-  readonly ioOpCode = IOOpCode.OnFailure;
+  readonly _tag = IOOpCode.OnFailure;
   constructor(
     readonly first: IO<R, E, A>,
     readonly failureK: (cause: Cause<E>) => IO<R1, E1, B>,
@@ -149,7 +162,7 @@ export class OnFailure<R, E, A, R1, E1, B> extends IO<R | R1, E1, A | B> {
  * @internal
  */
 export class OnSuccess<R, R1, E, E1, A, A1> extends IO<R | R1, E | E1, A1> {
-  readonly ioOpCode = IOOpCode.OnSuccess;
+  readonly _tag = IOOpCode.OnSuccess;
   constructor(readonly first: IO<R, E, A>, readonly successK: (a: A) => IO<R1, E1, A1>, readonly trace?: string) {
     super();
   }
@@ -165,21 +178,21 @@ export class OnSuccess<R, R1, E, E1, A, A1> extends IO<R | R1, E | E1, A1> {
  * @internal
  */
 export class SucceedNow<A> extends IO<never, never, A> {
-  readonly ioOpCode = IOOpCode.SucceedNow;
+  readonly _tag = IOOpCode.SucceedNow;
   constructor(readonly value: A, readonly trace?: string) {
     super();
   }
 }
 
 export class UpdateRuntimeFlags extends IO<never, never, void> {
-  readonly ioOpCode = IOOpCode.UpdateRuntimeFlags;
+  readonly _tag = IOOpCode.UpdateRuntimeFlags;
   constructor(readonly update: RuntimeFlags.Patch, readonly trace?: string) {
     super();
   }
 }
 
 export class Interruptible<R, E, A> extends IO<R, E, A> {
-  readonly ioOpCode = IOOpCode.UpdateRuntimeFlagsWithin;
+  readonly _tag = IOOpCode.UpdateRuntimeFlagsWithin;
   constructor(readonly effect: IO<R, E, A>, readonly trace?: string) {
     super();
   }
@@ -191,7 +204,7 @@ export class Interruptible<R, E, A> extends IO<R, E, A> {
 }
 
 export class Uninterruptible<R, E, A> extends IO<R, E, A> {
-  readonly ioOpCode = IOOpCode.UpdateRuntimeFlagsWithin;
+  readonly _tag = IOOpCode.UpdateRuntimeFlagsWithin;
   constructor(readonly effect: IO<R, E, A>, readonly trace?: string) {
     super();
   }
@@ -203,7 +216,7 @@ export class Uninterruptible<R, E, A> extends IO<R, E, A> {
 }
 
 export class Dynamic<R, E, A> extends IO<R, E, A> {
-  readonly ioOpCode = IOOpCode.UpdateRuntimeFlagsWithin;
+  readonly _tag = IOOpCode.UpdateRuntimeFlagsWithin;
   constructor(
     readonly update: RuntimeFlagsPatch,
     readonly f: (oldRuntimeFlags: RuntimeFlags) => IO<R, E, A>,
@@ -218,21 +231,21 @@ export class Dynamic<R, E, A> extends IO<R, E, A> {
 }
 
 export class GenerateStackTrace extends IO<never, never, Trace> {
-  readonly ioOpCode = IOOpCode.GenerateStackTrace;
+  readonly _tag = IOOpCode.GenerateStackTrace;
   constructor(readonly trace?: string) {
     super();
   }
 }
 
 export class Stateful<R, E, A> extends IO<R, E, A> {
-  readonly ioOpCode = IOOpCode.Stateful;
+  readonly _tag = IOOpCode.Stateful;
   constructor(readonly onState: (fiber: FiberRuntime<E, A>, status: Running) => IO<R, E, A>, readonly trace?: string) {
     super();
   }
 }
 
 export class WhileLoop<R, E, A> extends IO<R, E, void> {
-  readonly ioOpCode = IOOpCode.WhileLoop;
+  readonly _tag = IOOpCode.WhileLoop;
   constructor(
     readonly check: () => boolean,
     readonly body: () => IO<R, E, A>,
@@ -244,7 +257,7 @@ export class WhileLoop<R, E, A> extends IO<R, E, void> {
 }
 
 export class YieldNow extends IO<never, never, void> {
-  readonly ioOpCode = IOOpCode.YieldNow;
+  readonly _tag = IOOpCode.YieldNow;
   constructor(readonly trace?: string) {
     super();
   }
@@ -254,7 +267,7 @@ export class YieldNow extends IO<never, never, void> {
  * @internal
  */
 export class Fail<E> extends IO<never, E, never> {
-  readonly ioOpCode = IOOpCode.Fail;
+  readonly _tag = IOOpCode.Fail;
 
   constructor(readonly cause: Lazy<Cause<E>>, readonly trace?: string) {
     super();
@@ -275,7 +288,13 @@ export type Concrete =
   | WhileLoop<any, any, any>
   | YieldNow
   | Fail<any>
-  | STM<any, any, any>;
+  | STM<any, any, any>
+  | Left<any>
+  | Right<any>
+  | Nothing
+  | Just<any>
+  | Failure<any>
+  | Success<any>;
 
 /**
  * @tsplus static fncts.io.IOOps concrete
@@ -296,15 +315,3 @@ export type UpdateRuntimeFlagsWithin =
   | Dynamic<any, any, any>;
 
 export type Canceler<R> = URIO<R, void>;
-
-export const IOErrorTypeId = Symbol.for("fncts.io.IO.IOError");
-export type IOErrorTypeId = typeof IOErrorTypeId;
-
-export class IOError<E> {
-  readonly [IOErrorTypeId]: IOErrorTypeId = IOErrorTypeId;
-  constructor(readonly cause: Cause<E>) {}
-}
-
-export function isIOError(u: unknown): u is IOError<unknown> {
-  return isObject(u) && IOErrorTypeId in u;
-}

package/_src/IO/runtime.ts

@@ -1,4 +1,5 @@
-import { FiberMessage, FiberRuntime } from "@fncts/io/Fiber";
+import { IOError } from "@fncts/base/data/exceptions";
+import { FiberRuntime } from "@fncts/io/Fiber";
 import { FiberRefs } from "@fncts/io/FiberRefs";
 import { RuntimeFlag } from "@fncts/io/RuntimeFlag";
 import { RuntimeFlags } from "@fncts/io/RuntimeFlags";
@@ -12,7 +13,7 @@ export class Runtime<R> {
     readonly fiberRefs: FiberRefs,
   ) {}
 
-  unsafeRunFiber = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): FiberRuntime<E, A> => {
+  makeFiber = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): FiberRuntime<E, A> => {
     const fiberId   = FiberId.unsafeMake(__tsplusTrace);
     const fiberRefs = this.fiberRefs.updateAs(fiberId, FiberRef.currentEnvironment, this.environment);
 
@@ -31,33 +32,38 @@ export class Runtime<R> {
 
     FiberScope.global.unsafeAdd(null!, fiber.runtimeFlags0, fiber);
 
-    fiber.start(io);
-
     return fiber;
   };
 
-  unsafeRunWith = <E, A>(
-    io: IO<R, E, A>,
-    k: (exit: Exit<E, A>) => any,
-    __tsplusTrace?: string,
-  ): ((fiberId: FiberId) => (f: (exit: Exit<E, A>) => any) => void) => {
-    const fiber = this.unsafeRunFiber(io);
-    fiber.tell(FiberMessage.Stateful((fiber) => fiber.addObserver(k)));
-    return (fiberId) => (k) => this.unsafeRunAsyncWith(fiber.interruptAs(fiberId), (exit) => k(exit.flatten));
-  };
-
-  unsafeRunAsync = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string) => {
-    this.unsafeRunAsyncWith(io, () => void 0);
+  unsafeRunFiber = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): FiberRuntime<E, A> => {
+    const fiber = this.makeFiber(io);
+    fiber.start(io);
+    return fiber;
   };
 
-  unsafeRunAsyncWith = <E, A>(io: IO<R, E, A>, k: (exit: Exit<E, A>) => any, __tsplusTrace?: string) => {
-    this.unsafeRunWith(io, k);
+  unsafeRunPromiseExit = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): Promise<Exit<E, A>> => {
+    return new Promise((resolve) => {
+      const fiber = this.makeFiber(io);
+      fiber.addObserver((exit) => {
+        resolve(exit);
+      });
+      fiber.start(io);
+    });
   };
 
-  unsafeRunPromiseExit = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): Promise<Exit<E, A>> =>
-    new Promise((resolve) => {
-      this.unsafeRunAsyncWith(io, resolve);
+  unsafeRunPromise = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): Promise<A> => {
+    return new Promise((resolve, reject) => {
+      const fiber = this.makeFiber(io);
+      fiber.addObserver((exit) => {
+        if (exit.isFailure()) {
+          reject(exit.cause.squashWith(Function.identity));
+        } else {
+          resolve(exit.value);
+        }
+      });
+      fiber.start(io);
     });
+  };
 
   unsafeRunOrFork = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): Either<Fiber.Runtime<E, A>, Exit<E, A>> => {
     const fiberId   = FiberId.unsafeMake(__tsplusTrace);
@@ -88,6 +94,12 @@ export class Runtime<R> {
 
     return Either.left(fiber);
   };
+
+  unsafeRun = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): Exit<E, A> => {
+    return this.unsafeRunOrFork(io).match(() => {
+      throw new Error("Encountered async boundary");
+    }, Function.identity);
+  };
 }
 
 /**
@@ -112,27 +124,22 @@ export const defaultRuntime = new Runtime(Environment.empty, RuntimeFlags.defaul
  */
 export const unsafeRunFiber = defaultRuntime.unsafeRunFiber;
 
-/**
- * @tsplus fluent fncts.io.IO unsafeRunAsync
- */
-export const unsafeRunAsync = defaultRuntime.unsafeRunAsync;
-
-/**
- * @tsplus fluent fncts.io.IO unsafeRunAsyncWith
- */
-export const unsafeRunAsyncWith = defaultRuntime.unsafeRunAsyncWith;
-
 /**
  * @tsplus fluent fncts.io.IO unsafeRunPromiseExit
  */
 export const unsafeRunPromiseExit = defaultRuntime.unsafeRunPromiseExit;
 
 /**
- * @tsplus fluent fncts.io.IO unsafeRunWith
+ * @tsplus fluent fncts.io.IO unsafeRunPromise
  */
-export const unsafeRunWith = defaultRuntime.unsafeRunWith;
+export const unsafeRunPromise = defaultRuntime.unsafeRunPromise;
 
 /**
- * @tsplus getter fncts.io.IO unsafeRunSyncExit
+ * @tsplus getter fncts.io.IO unsafeRunOrFork
  */
 export const unsafeRunOrFork = defaultRuntime.unsafeRunOrFork;
+
+/**
+ * @tsplus getter fncts.io.IO unsafeRun
+ */
+export const unsafeRun = defaultRuntime.unsafeRun;

package/_src/RefSubject/Atomic.ts

@@ -53,15 +53,15 @@ export class AtomicRefSubject<E, A> extends RefSubjectInternal<never, E, A, A> {
   end: IO<never, never, void> = this.stream.end;
 
   unsafeEmit(value: A): void {
-    return this.stream.emit(value).unsafeRunAsync();
+    this.stream.emit(value).unsafeRunFiber();
   }
 
   unsafeFailCause(cause: Cause<E>): void {
-    return this.stream.failCause(cause).unsafeRunAsync();
+    this.stream.failCause(cause).unsafeRunFiber();
   }
 
   unsafeEnd(): void {
-    return this.stream.end.unsafeRunAsync();
+    this.stream.end.unsafeRunFiber();
   }
 
   get unsafeGet(): A {
@@ -111,7 +111,7 @@ class AtomicEmitRef<E, A> extends Atomic<A> {
 
   unsafeSet(value: A) {
     this.ref.unsafeSet(value);
-    this.emitter.emit(value).unsafeRunAsync();
+    this.emitter.emit(value).unsafeRunFiber();
   }
 
   set(value: A, __tsplusTrace?: string) {

package/_src/STM/definition.ts

@@ -25,7 +25,7 @@ export type STMTypeId = typeof STMTypeId;
  */
 export abstract class STM<R, E, A> {
   readonly [IOTypeId]: IOTypeId = IOTypeId;
-  readonly ioOpCode             = IOOpCode.Commit;
+  readonly _tag                 = IOOpCode.Commit;
   readonly trace?: string;
   readonly [STMTypeId]: STMTypeId = STMTypeId;
   declare [IOVariance]: {

package/_src/Schedule/api.ts

@@ -131,7 +131,7 @@ export function checkIO<In, Out, Env1>(test: (inp: In, out: Out) => URIO<Env1, b
 }
 
 /**
- * @tsplus pipeable fncts.io.Schedule compose_
+ * @tsplus pipeable fncts.io.Schedule compose
  */
 export function compose<O, S1, R1, O2>(that: Schedule.WithState<S1, R1, O, O2>, __tsplusTrace?: string) {
   return <S, R, I>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<readonly [S, S1], R | R1, I, O2> => {