@fncts/io 0.0.41 → 0.0.43

package/_src/Fiber/FiberRuntime.ts

@@ -3,8 +3,10 @@ import type { OnFailure, OnSuccess, OnSuccessAndFailure, UIO } from "../IO/defin
 import type { WhileLoop } from "../IO/definition.js";
 import type { RuntimeFlags } from "../RuntimeFlags.js";
 
+import { EitherTag } from "@fncts/base/data/Either";
 import { isIOError } from "@fncts/base/data/exceptions";
 import { ExitTag } from "@fncts/base/data/Exit";
+import { MaybeTag } from "@fncts/base/data/Maybe";
 import { Trace } from "@fncts/base/data/Trace";
 import { FiberTypeId, FiberVariance } from "@fncts/io/Fiber/definition";
 import { StackTraceBuilder } from "@fncts/io/internal/StackTraceBuilder";
@@ -19,7 +21,7 @@ import { RuntimeFlag } from "../RuntimeFlag.js";
 import { FiberMessage, FiberMessageTag } from "./FiberMessage.js";
 
 export class RevertFlags {
-  readonly _tag = IOTag.RevertFlags;
+  readonly _ioOpCode = IOTag.RevertFlags;
   constructor(
     readonly patch: RuntimeFlags.Patch,
     readonly trace?: string,
@@ -27,7 +29,7 @@ export class RevertFlags {
 }
 
 export class UpdateTrace {
-  readonly _tag = IOTag.UpdateTrace;
+  readonly _ioOpCode = IOTag.UpdateTrace;
   constructor(readonly trace?: string) {}
 }
 
@@ -269,7 +271,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
           }
         } catch (e) {
           if (isIO(e)) {
-            if (IO.concrete(e)._tag === IOTag.YieldNow) {
+            if (IO.concrete(e)._ioOpCode === IOTag.YieldNow) {
               if (this._runtimeFlags.cooperativeYielding) {
                 this.tell(FiberMessage.YieldNow);
                 this.tell(FiberMessage.Resume(IO.unit));
@@ -277,10 +279,10 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
               } else {
                 effect = IO.unit;
               }
-            } else if (IO.concrete(e)._tag === IOTag.Async) {
+            } else if (IO.concrete(e)._ioOpCode === IOTag.Async) {
               effect = null!;
             } else {
-              throw new Error(`Unhandled op ${IO.concrete(e)._tag}`);
+              throw new Error(`Unhandled op ${IO.concrete(e)._ioOpCode}`);
             }
           } else {
             throw e;
@@ -318,12 +320,12 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
         cur          = IO.concrete(IO.yieldNow.flatMap(() => oldCur, trace));
       }
       try {
-        switch (cur._tag) {
+        switch (cur._ioOpCode) {
           case IOTag.Sync: {
             const value = cur.i0();
             const cont  = this.getNextSuccessCont();
             if (cont) {
-              switch (cont._tag) {
+              switch (cont._ioOpCode) {
                 case IOTag.OnSuccess: {
                   cur = IO.concrete(cont.i1(value));
                   break;
@@ -406,7 +408,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
             const oldCur = cur;
             const cont   = this.getNextSuccessCont();
             if (cont) {
-              switch (cont._tag) {
+              switch (cont._ioOpCode) {
                 case IOTag.OnSuccess: {
                   cur = IO.concrete(cont.i1(oldCur.i0));
                   break;
@@ -447,7 +449,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
             const cause = cur.i0();
             const cont  = this.getNextFailCont();
             if (cont) {
-              switch (cont._tag) {
+              switch (cont._ioOpCode) {
                 case IOTag.OnFailure:
                 case IOTag.OnSuccessAndFailure: {
                   if (!(this._runtimeFlags.interruptible && this.isInterrupted())) {
@@ -504,38 +506,50 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
             cur = IO.concrete(cur.commit);
             break;
           }
-          case "Just": {
-            cur = IO.concrete(IO.succeedNow(cur.value));
+          case IOTag.External: {
+            cur = IO.concrete(cur.toIO);
             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;
-          }
-          case "Tag": {
-            cur = IO.concrete(IO.service(cur));
+          case null: {
+            switch (cur._tag) {
+              case MaybeTag.Just: {
+                cur = IO.concrete(IO.succeedNow(cur.value));
+                break;
+              }
+              case MaybeTag.Nothing: {
+                cur = IO.concrete(IO.failNow(new NoSuchElementError()));
+                break;
+              }
+              case EitherTag.Left: {
+                cur = IO.concrete(IO.failNow(cur.left));
+                break;
+              }
+              case EitherTag.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;
+              }
+              case "Tag": {
+                cur = IO.concrete(IO.service(cur));
+                break;
+              }
+            }
           }
         }
       } catch (e) {
         if (isIOError(e)) {
           cur = IO.concrete(IO.failCauseNow(e.cause));
-        } else if (isIO(e) && (IO.concrete(e)._tag === IOTag.Async || IO.concrete(e)._tag === IOTag.YieldNow)) {
+        } else if (
+          isIO(e) &&
+          (IO.concrete(e)._ioOpCode === IOTag.Async || IO.concrete(e)._ioOpCode === IOTag.YieldNow)
+        ) {
           throw e;
         } else if (isInterruptedException(e)) {
           cur = IO.concrete(IO.failCauseNow(Cause.parallel(Cause.halt(e), Cause.interrupt(FiberId.none))));
@@ -836,7 +850,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
   getNextSuccessCont() {
     while (this.stack.hasNext) {
       const frame = this.stack.pop()!;
-      if (frame._tag !== IOTag.OnFailure) {
+      if (frame._ioOpCode !== IOTag.OnFailure) {
         return frame;
       }
     }
@@ -845,7 +859,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
   getNextFailCont() {
     while (this.stack.hasNext) {
       const frame = this.stack.pop()!;
-      if (frame._tag !== IOTag.OnSuccess && frame._tag !== IOTag.WhileLoop) {
+      if (frame._ioOpCode !== IOTag.OnSuccess && frame._ioOpCode !== IOTag.WhileLoop) {
         return frame;
       }
     }

package/_src/Fiber/definition.ts

@@ -89,6 +89,8 @@ export interface RuntimeFiber<E, A> extends FiberCommon<E, A> {
    * The trace of the Fiber
    */
   readonly trace: UIO<Trace>;
+
+  addObserver(observer: (exit: Exit<E, A>) => void): void;
 }
 
 export class SyntheticFiber<E, A> implements FiberCommon<E, A> {

package/_src/FiberSet.ts

@@ -0,0 +1,115 @@
+export const FiberSetTypeId = Symbol.for("fncts.io.FiberSet");
+export type FiberSetTypeId = typeof FiberSetTypeId;
+
+/**
+ * @tsplus type fncts.io.FiberSet
+ * @tsplus companion fncts.io.FiberSetOps
+ */
+export class FiberSet<E, A> {
+  readonly [FiberSetTypeId]: FiberSetTypeId = FiberSetTypeId;
+  constructor(
+    readonly backing: Set<Fiber.Runtime<E, A>>,
+    readonly future: Future<unknown, never>,
+  ) {}
+}
+
+/**
+ * @tsplus static fncts.io.FiberSetOps unsafeMake
+ */
+export function unsafeMake<E, A>(backing: Set<Fiber.Runtime<E, A>>, future: Future<unknown, never>): FiberSet<E, A> {
+  return new FiberSet(backing, future);
+}
+
+/**
+ * @tsplus static fncts.io.FiberSetOps make
+ */
+export function make<E, A>(): IO<Scope, never, FiberSet<E, A>> {
+  return IO.acquireRelease(
+    Future.make<unknown, never>().map((future) => FiberSet.unsafeMake(new Set<Fiber.Runtime<E, A>>(), future)),
+    (fiberSet) => fiberSet.clear,
+  );
+}
+
+/**
+ * @tsplus static fncts.io.FiberSetOps makeRuntime
+ */
+export function makeRuntime<R, E, A>(): IO<
+  Scope | R,
+  never,
+  <XE extends E, XA extends A>(io: IO<R, XE, XA>) => Fiber.Runtime<XE, XA>
+> {
+  return make<E, A>().flatMap((fiberSet) => fiberSet.runtime());
+}
+
+/**
+ * @tsplus pipeable fncts.io.FiberSet unsafeAdd
+ */
+export function unsafeAdd<XE extends E, XA extends A, E, A>(fiber: Fiber.Runtime<XE, XA>) {
+  return (self: FiberSet<E, A>): void => {
+    if (self.backing.has(fiber)) {
+      return;
+    }
+    self.backing.add(fiber);
+    fiber.addObserver((exit) => {
+      self.backing.delete(fiber);
+      if (exit.isFailure() && !exit.cause.isInterruptedOnly) {
+        self.future.unsafeDone(exit);
+      }
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.io.FiberSet add
+ */
+export function add<XE extends E, XA extends A, E, A>(fiber: Fiber.Runtime<XE, XA>) {
+  return (self: FiberSet<E, A>): UIO<void> => IO(self.unsafeAdd(fiber));
+}
+
+/**
+ * @tsplus pipeable fncts.io.FiberSet runtime
+ */
+export function runtime<R = never>() {
+  return <E, A>(
+    self: FiberSet<E, A>,
+  ): IO<R, never, <XE extends E, XA extends A>(io: IO<R, XE, XA>) => Fiber.Runtime<XE, XA>> => {
+    return IO.runtime<R>().map((runtime) => {
+      const runFork = runtime.unsafeRunFiber;
+      return (io) => {
+        const fiber = runFork(io);
+        self.unsafeAdd(fiber);
+        return fiber;
+      };
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.io.FiberSet run
+ */
+export function run<R, XE extends E, XA extends A, E, A>(io: IO<R, XE, XA>) {
+  return (self: FiberSet<E, A>): IO<R, never, Fiber.Runtime<XE, XA>> => {
+    return io.forkDaemon.tap((fiber) => self.add(fiber));
+  };
+}
+
+/**
+ * @tsplus getter fncts.io.FiberSet size
+ */
+export function size<E, A>(self: FiberSet<E, A>): UIO<number> {
+  return IO(self.backing.size);
+}
+
+/**
+ * @tsplus getter fncts.io.FiberSet join
+ */
+export function join<E, A>(self: FiberSet<E, A>): FIO<E, never> {
+  return (self.future as Future<E, never>).await;
+}
+
+/**
+ * @tsplus getter fncts.io.FiberSet clear
+ */
+export function clear<E, A>(self: FiberSet<E, A>): UIO<void> {
+  return IO.foreach(self.backing, (fiber) => fiber.interrupt) > IO(self.backing.clear());
+}

package/_src/Hub/api.ts

@@ -68,6 +68,9 @@ class DimapIO<RA, RB, RC, RD, EA, EB, EC, ED, A, B, C, D> extends PHubInternal<
   isShutdown    = this.source.isShutdown;
   shutdown      = this.source.shutdown;
   size          = this.source.size;
+  get unsafeSize() {
+    return this.source.unsafeSize;
+  }
   subscribe: IO<Scope, never, PDequeue<RA | RC, RB | RD, EA | EC, EB | ED, C, D>> = unsafeCoerce(
     this.source.subscribe.map((queue) => queue.mapIO(this.g)),
   );
@@ -119,9 +122,12 @@ class FilterInputIO<RA, RA1, RB, EA, EA1, EB, A, B> extends PHubInternal<RA | RA
   isShutdown    = this.source.isShutdown;
   shutdown      = this.source.shutdown;
   size          = this.source.size;
-  subscribe     = this.source.subscribe;
-  publish       = (a: A) => this.f(a).flatMap((b) => (b ? this.source.publish(a) : IO.succeedNow(false)));
-  publishAll    = (as: Iterable<A>) =>
+  get unsafeSize() {
+    return this.source.unsafeSize;
+  }
+  subscribe  = this.source.subscribe;
+  publish    = (a: A) => this.f(a).flatMap((b) => (b ? this.source.publish(a) : IO.succeedNow(false)));
+  publishAll = (as: Iterable<A>) =>
     IO.filter(as, this.f).flatMap((as) => (as.isNonEmpty ? this.source.publishAll(as) : IO.succeedNow(false)));
 }
 
@@ -161,9 +167,12 @@ class FilterOutputIO<RA, RB, RB1, EA, EB, EB1, A, B> extends PHubInternal<RA, RB
   isShutdown    = this.source.isShutdown;
   shutdown      = this.source.shutdown;
   size          = this.source.size;
-  subscribe     = this.source.subscribe.map((queue) => queue.filterOutputIO(this.f));
-  publish       = (a: A) => this.source.publish(a);
-  publishAll    = (as: Iterable<A>) => this.source.publishAll(as);
+  get unsafeSize() {
+    return this.source.unsafeSize;
+  }
+  subscribe  = this.source.subscribe.map((queue) => queue.filterOutputIO(this.f));
+  publish    = (a: A) => this.source.publish(a);
+  publishAll = (as: Iterable<A>) => this.source.publishAll(as);
 }
 
 /**

package/_src/Hub/definition.ts

@@ -84,6 +84,8 @@ export abstract class PHubInternal<RA, RB, EA, EB, A, B>
    */
   abstract isShutdown: UIO<boolean>;
 
+  abstract unsafeSize: Maybe<number>;
+
   /**
    * Publishes a message to the hub, returning whether the message was
    * published to the hub.
@@ -113,6 +115,10 @@ export abstract class PHubInternal<RA, RB, EA, EB, A, B>
    */
   abstract subscribe: IO<Scope, never, PDequeue<RA, RB, EA, EB, A, B>>;
 
+  unsafeOffer(_: never): boolean {
+    throw new Error("Cannot unsafely publish to a Hub");
+  }
+
   offer(a: A, __tsplusTrace?: string): IO<RA, EA, boolean> {
     return this.publish(a);
   }

package/_src/Hub/internal.ts

@@ -1,3 +1,4 @@
+import type { Maybe } from "@fncts/base/data/Maybe";
 import type { Hub as HubInternal } from "@fncts/io/internal/Hub";
 
 import { HashSet } from "@fncts/base/collection/mutable/HashSet";
@@ -282,6 +283,13 @@ class UnsafeSubscription<A> extends QueueInternal<never, never, never, never, A,
     }),
   );
 
+  get unsafeSize(): Maybe<number> {
+    if (this.shutdownFlag.get) {
+      return Nothing();
+    }
+    return Just(this.subscription.size());
+  }
+
   size: UIO<number> = IO.defer(() => {
     if (this.shutdownFlag.get) {
       return IO.interrupt;
@@ -290,6 +298,10 @@ class UnsafeSubscription<A> extends QueueInternal<never, never, never, never, A,
     return IO.succeed(this.subscription.size());
   });
 
+  unsafeOffer(_: never): boolean {
+    return false;
+  }
+
   offer = (_: never): IO<never, never, boolean> => IO.succeedNow(false);
 
   offerAll = (_: Iterable<never>): IO<never, never, boolean> => IO.succeedNow(false);
@@ -423,6 +435,13 @@ class UnsafeHub<A> extends PHubInternal<never, never, never, never, A, A> {
     }),
   ).uninterruptible;
 
+  get unsafeSize(): Maybe<number> {
+    if (this.shutdownFlag.get) {
+      return Nothing();
+    }
+    return Just(this.hub.size());
+  }
+
   size = IO.defer(() => {
     if (this.shutdownFlag.get) {
       return IO.interrupt;

package/_src/IO/api/asyncInterrupt.ts

@@ -25,14 +25,14 @@ export function asyncInterrupt<R, E, A>(
     let cancelerRef: URIO<R, any> = IO.unit!;
     return IO.async<R, E, A>((k) => {
       const result = register(k);
-      result.match({
-        Left: (canceler) => {
+      result.match(
+        (canceler) => {
           cancelerRef = canceler;
         },
-        Right: (done) => {
+        (done) => {
           k(done);
         },
-      });
+      );
     }, blockingOn).onInterrupt(() => cancelerRef);
   });
 }

package/_src/IO/api/diffFiberRefs.ts

@@ -0,0 +1,11 @@
+import { FiberRefsPatch } from "@fncts/io/FiberRefs";
+
+/**
+ * @tsplus getter fncts.io.IO diffFiberRefs
+ */
+export function diffFiberRefs<R, E, A>(
+  self: IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R, E, readonly [FiberRefsPatch, A]> {
+  return self.summarized(IO.getFiberRefs(), FiberRefsPatch.diff);
+}

package/_src/IO/api/memoize.ts

@@ -1,10 +1,12 @@
+import type { FiberRefsPatch } from "@fncts/io/FiberRefs";
+
 /**
  * @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 Do((_) => {
-    const future   = _(Future.make<E, A>());
-    const complete = _(future.fulfill(self).once);
-    return complete > future.await;
+    const future   = _(Future.make<E, readonly [FiberRefsPatch, A]>());
+    const complete = _(self.diffFiberRefs.fulfill(future).once);
+    return complete > future.await.flatMap(([patch, a]) => IO.patchFiberRefs(patch).as(a));
   });
 }

package/_src/IO/api/timeout.ts

@@ -27,6 +27,14 @@ export function timeoutTo<A, B, B1>(duration: Lazy<Duration>, b: Lazy<B>, f: (a:
   };
 }
 
+/**
+ * @tsplus pipeable fncts.io.IO timeoutFail
+ */
+export function timeoutFail<E1>(duration: Lazy<Duration>, b: Lazy<E1>) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R, E | E1, A> =>
+    self.timeoutTo(duration, IO.fail(b), (a) => IO.succeedNow(a)).flatten;
+}
+
 /**
  * @tsplus pipeable fncts.io.IO timeout
  */

package/_src/IO/api.ts

@@ -1,4 +1,5 @@
 import type { Running } from "../FiberStatus.js";
+import type { ShowOptions } from "@fncts/base/data/Showable.js";
 import type * as P from "@fncts/base/typeclass";
 import type { _E, _R } from "@fncts/base/types";
 import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
@@ -6,6 +7,7 @@ import type { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 
 import { IOError } from "@fncts/base/data/exceptions";
 import { identity, pipe, tuple } from "@fncts/base/data/function";
+import { showWithOptions } from "@fncts/base/data/Showable";
 import { IOPrimitive, IOTag } from "@fncts/io/IO/definition";
 import { IO } from "@fncts/io/IO/definition";
 
@@ -122,10 +124,10 @@ export function bitap<E, A, R1, E1, R2, E2>(
   return <R>(self: IO<R, E, A>): IO<R | R1 | R2, E | E1 | E2, A> => {
     return self.matchCauseIO(
       (cause) =>
-        cause.failureOrCause.match({
-          Left: (e) => onFailure(e).flatMap(() => IO.failCauseNow(cause)),
-          Right: () => IO.failCauseNow(cause),
-        }),
+        cause.failureOrCause.match(
+          (e) => onFailure(e).flatMap(() => IO.failCauseNow(cause)),
+          () => IO.failCauseNow(cause),
+        ),
       (a) => onSuccess(a).zipRight(IO.succeedNow(a)),
     );
   };
@@ -200,8 +202,7 @@ export function catchAllCause<R, E, A, R1, E1, A1>(f: (_: Cause<E>) => IO<R1, E1
 export function catchJust<E, R1, E1, A1>(f: (e: E) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string) {
   return <R, A>(ma: IO<R, E, A>): IO<R | R1, E | E1, A | A1> => {
     return ma.matchCauseIO(
-      (cause) =>
-        cause.failureOrCause.match({ Left: (e) => f(e).getOrElse(IO.failCauseNow(cause)), Right: IO.failCauseNow }),
+      (cause) => cause.failureOrCause.match((e) => f(e).getOrElse(IO.failCauseNow(cause)), IO.failCauseNow),
       IO.succeedNow,
     );
   };
@@ -318,6 +319,7 @@ export function flatMap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTrace?
     io.i0    = ma;
     io.i1    = f;
     io.trace = __tsplusTrace;
+
     return io;
   };
 }
@@ -805,7 +807,7 @@ export function forever<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R,
  * @tsplus static fncts.io.IOOps fromEither
  */
 export function fromEither<E, A>(either: Lazy<Either<E, A>>, __tsplusTrace?: string): IO<never, E, A> {
-  return IO.succeed(either).flatMap((ea) => ea.match({ Left: IO.failNow, Right: IO.succeedNow }));
+  return IO.succeed(either).flatMap((ea) => ea.match(IO.failNow, IO.succeedNow));
 }
 
 /**
@@ -815,7 +817,7 @@ export function fromEither<E, A>(either: Lazy<Either<E, A>>, __tsplusTrace?: str
  * @tsplus getter fncts.Either toIO
  */
 export function fromEitherNow<E, A>(either: Either<E, A>, __tsplusTrace?: string): IO<never, E, A> {
-  return either.match({ Left: IO.failNow, Right: IO.succeedNow });
+  return either.match(IO.failNow, IO.succeedNow);
 }
 
 /**
@@ -958,6 +960,13 @@ export function getOrFailUnit<A>(option: Maybe<A>, __tsplusTrace?: string): FIO<
   return IO.getOrFailWith(option, undefined);
 }
 
+/**
+ * @tsplus static fncts.io.IOOps getFiberRefs
+ */
+export function getFiberRefs(__tsplusTrace?: string): UIO<FiberRefs> {
+  return IO.withFiberRuntime((fiberState) => IO.succeed(fiberState.getFiberRefs()));
+}
+
 /**
  * Creates an `IO` that halts with the specified lazily-evaluated defect.
  * This method can be used for terminating a fiber because a defect has been
@@ -1091,6 +1100,13 @@ export function log(message: Lazy<string>, __tsplusTrace?: string): UIO<void> {
   });
 }
 
+/**
+ * @tsplus static fncts.io.IOOps show
+ */
+export function show(message: Lazy<unknown>, options?: Partial<ShowOptions>, __tsplusTrace?: string): UIO<void> {
+  return IO.log(showWithOptions(message, options));
+}
+
 /**
  * Loops with the specified effectual function, collecting the results into a
  * list. The moral equivalent of:
@@ -1250,10 +1266,7 @@ export function matchIO<R1, R2, E, E1, E2, A, A1, A2>(
   __tsplusTrace?: string,
 ) {
   return <R>(self: IO<R, E, A>): IO<R | R1 | R2, E1 | E2, A1 | A2> => {
-    return self.matchCauseIO(
-      (cause) => cause.failureOrCause.match({ Left: onFailure, Right: IO.failCauseNow }),
-      onSuccess,
-    );
+    return self.matchCauseIO((cause) => cause.failureOrCause.match(onFailure, IO.failCauseNow), onSuccess);
   };
 }
 
@@ -1285,7 +1298,7 @@ export function matchTraceIO<E, A, R1, E1, A1, R2, E2, A2>(
 ) {
   return <R>(ma: IO<R, E, A>): IO<R | R1 | R2, E1 | E2, A1 | A2> => {
     return ma.matchCauseIO(
-      (cause) => cause.failureTraceOrCause.match({ Left: ([e, trace]) => onFailure(e, trace), Right: IO.failCauseNow }),
+      (cause) => cause.failureTraceOrCause.match(([e, trace]) => onFailure(e, trace), IO.failCauseNow),
       onSuccess,
     );
   };
@@ -1775,7 +1788,7 @@ export function tryCatch<E, A>(effect: Lazy<A>, onThrow: (error: unknown) => E,
     } catch (u) {
       return IO.withFiberRuntime((fiberState) => {
         if (!fiberState.isFatal(u)) {
-          throw new IOError(Cause.fail(u));
+          throw new IOError(Cause.fail(onThrow(u)));
         } else {
           throw u;
         }
@@ -1790,7 +1803,7 @@ export function tryCatch<E, A>(effect: Lazy<A>, onThrow: (error: unknown) => E,
  * @tsplus getter fncts.io.IO absolve
  */
 export function absolve<R, E, E1, A>(ma: IO<R, E, Either<E1, A>>, __tsplusTrace?: string): IO<R, E | E1, A> {
-  return ma.flatMap((ea) => ea.match({ Left: IO.failNow, Right: IO.succeedNow }));
+  return ma.flatMap((ea) => ea.match(IO.failNow, IO.succeedNow));
 }
 
 /**
@@ -1828,10 +1841,10 @@ export function tapError<E, R1, E1>(f: (e: E) => IO<R1, E1, any>, __tsplusTrace?
   return <R, A>(self: IO<R, E, A>) =>
     self.matchCauseIO(
       (cause) =>
-        cause.failureOrCause.match({
-          Left: (e) => f(e).flatMap(() => IO.failCauseNow(cause)),
-          Right: (_) => IO.failCauseNow(cause),
-        }),
+        cause.failureOrCause.match(
+          (e) => f(e).flatMap(() => IO.failCauseNow(cause)),
+          (_) => IO.failCauseNow(cause),
+        ),
       IO.succeedNow,
     );
 }

package/_src/IO/definition.ts

@@ -51,7 +51,7 @@ declare module "@fncts/base/data/Exit/definition" {
 }
 
 declare module "@fncts/base/data/Tag/definition" {
-  interface Tag<T, Identifier = T> extends IO<never, never, T> {}
+  export interface Tag<T, Identifier = T> extends IO<T, never, T> {}
 }
 
 /**
@@ -100,11 +100,12 @@ export const enum IOTag {
   Commit,
   RevertFlags,
   UpdateTrace,
+  External,
 }
 
 export type IOOp<Tag extends string | number, Body = {}> = IO<never, never, never> &
   Body & {
-    readonly _tag: Tag;
+    readonly _ioOpCode: Tag;
   };
 
 export class IOPrimitive {
@@ -112,8 +113,8 @@ export class IOPrimitive {
   public i1: any                   = undefined;
   public i2: any                   = undefined;
   public trace: string | undefined = undefined;
-  [IOTypeId] = IOTypeId;
-  constructor(readonly _tag: Primitive["_tag"]) {}
+  readonly [IOTypeId]: IOTypeId    = IOTypeId;
+  constructor(readonly _ioOpCode: unknown) {}
 }
 
 export function isIO(u: unknown): u is IO<any, any, any> {
@@ -257,6 +258,7 @@ export type Primitive =
   | WhileLoop
   | YieldNow
   | Fail
+  | External<any, any, any>
   | STM<any, any, any>
   | Left<any>
   | Right<any>
@@ -277,3 +279,17 @@ export function concrete(io: IO<any, any, any>): Primitive {
 export type EvaluationStep = OnSuccessAndFailure | OnFailure | OnSuccess;
 
 export type Canceler<R> = URIO<R, void>;
+
+export abstract class External<R, E, A> extends IOPrimitive implements IO<R, E, A> {
+  declare _ioOpCode: IOTag.External;
+  declare [IOVariance]: {
+    _R: () => R;
+    _E: () => E;
+    _A: () => A;
+  };
+
+  constructor() {
+    super(IOTag.External);
+  }
+  abstract toIO: IO<R, E, A>;
+}