@fncts/io 0.0.38 → 0.0.40

package/_src/FiberRefs/Patch.ts

@@ -0,0 +1,145 @@
+export const enum FiberRefsPatchTag {
+  Empty,
+  Add,
+  Remove,
+  Update,
+  AndThen,
+}
+
+export const FiberRefsPatchTypeId = Symbol.for("fncts.io.FiberRefs.Patch");
+export type FiberRefsPatchTypeId = typeof FiberRefsPatchTypeId;
+
+/**
+ * @tsplus type fncts.io.FiberRefs.Patch
+ * @tsplus companion fncts.io.FiberRefs.PatchOps
+ */
+export abstract class FiberRefsPatch {
+  readonly [FiberRefsPatchTypeId]: FiberRefsPatchTypeId = FiberRefsPatchTypeId;
+}
+
+export class Empty extends FiberRefsPatch {
+  readonly _tag = FiberRefsPatchTag.Empty;
+}
+
+export class Add<Value> extends FiberRefsPatch {
+  readonly _tag = FiberRefsPatchTag.Add;
+
+  constructor(
+    readonly fiberRef: FiberRef<Value>,
+    readonly value: Value,
+  ) {
+    super();
+  }
+}
+
+export class AndThen extends FiberRefsPatch {
+  readonly _tag = FiberRefsPatchTag.AndThen;
+
+  constructor(
+    readonly first: FiberRefsPatch,
+    readonly second: FiberRefsPatch,
+  ) {
+    super();
+  }
+}
+
+export class Remove<Value> extends FiberRefsPatch {
+  readonly _tag = FiberRefsPatchTag.Remove;
+
+  constructor(readonly fiberRef: FiberRef<Value>) {
+    super();
+  }
+}
+
+export class Update<Value, Patch> extends FiberRefsPatch {
+  readonly _tag = FiberRefsPatchTag.Update;
+
+  constructor(
+    readonly fiberRef: FiberRef.WithPatch<Value, Patch>,
+    readonly patch: Patch,
+  ) {
+    super();
+  }
+}
+
+export const empty: FiberRefsPatch = new Empty();
+
+/**
+ * @tsplus pipeable fncts.io.FiberRefs.Patch combine
+ */
+export function combine(second: FiberRefsPatch) {
+  return (first: FiberRefsPatch): FiberRefsPatch => {
+    return new AndThen(first, second);
+  };
+}
+
+/**
+ * @tsplus static fncts.io.FiberRefs.PatchOps diff
+ */
+export function diff(oldValue: FiberRefs, newValue: FiberRefs): FiberRefsPatch {
+  const [removed, patch] = newValue.unFiberRefs.foldLeftWithIndex(
+    [oldValue, empty] as const,
+    (fiberRef, [fiberRefs, patch], values) => {
+      const newValue = values.head[1];
+      return fiberRefs.get(fiberRef).match(
+        () => [fiberRefs.delete(fiberRef), patch.combine(new Add(fiberRef, newValue))],
+        (oldValue) => {
+          if (oldValue === newValue) {
+            return [fiberRefs.delete(fiberRef), patch];
+          } else {
+            return [fiberRefs.delete(fiberRef), patch.combine(new Update(fiberRef, fiberRef.diff(oldValue, newValue)))];
+          }
+        },
+      );
+    },
+  );
+
+  return removed.unFiberRefs.foldLeftWithIndex(patch, (fiberRef, patch) => patch.combine(new Remove(fiberRef)));
+}
+
+/**
+ * @tsplus pipeable fncts.io.FiberRefs.Patch __call
+ */
+export function apply(fiberId: FiberId.Runtime, fiberRefs: FiberRefs) {
+  return (self: FiberRefsPatch): FiberRefs => {
+    return applyLoop(fiberId, fiberRefs, Cons(self));
+  };
+}
+
+/**
+ * @tsplus tailRec
+ */
+function applyLoop(fiberId: FiberId.Runtime, fiberRefs: FiberRefs, patches: List<FiberRefsPatch>): FiberRefs {
+  if (patches.isEmpty()) {
+    return fiberRefs;
+  }
+  const patch = patches.head;
+  const rest  = patches.tail;
+  concrete(patch);
+  switch (patch._tag) {
+    case FiberRefsPatchTag.Add:
+      return applyLoop(fiberId, fiberRefs.updateAs(fiberId, patch.fiberRef, patch.value), rest);
+    case FiberRefsPatchTag.AndThen:
+      return applyLoop(fiberId, fiberRefs, Cons(patch.first, Cons(patch.second, rest)));
+    case FiberRefsPatchTag.Empty:
+      return applyLoop(fiberId, fiberRefs, rest);
+    case FiberRefsPatchTag.Remove:
+      return applyLoop(fiberId, fiberRefs.delete(patch.fiberRef), rest);
+    case FiberRefsPatchTag.Update:
+      return applyLoop(
+        fiberId,
+        fiberRefs.updateAs(
+          fiberId,
+          patch.fiberRef,
+          patch.fiberRef.patch(patch.patch)(fiberRefs.getOrDefault(patch.fiberRef)),
+        ),
+        rest,
+      );
+  }
+}
+
+type Concrete = Empty | Add<any> | Remove<any> | Update<any, any> | AndThen;
+
+function concrete(patch: FiberRefsPatch): asserts patch is Concrete {
+  //
+}

package/_src/FiberRefs.ts

@@ -1,4 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./FiberRefs/*.ts }
-export * from "./FiberRefs/api.js";
 export * from "./FiberRefs/definition.js";
+export * from "./FiberRefs/api.js";
+export * from "./FiberRefs/Patch.js";
 // codegen:end

package/_src/FiberScope/definition.ts

@@ -32,7 +32,10 @@ export class Global extends FiberScope {
 }
 
 export class Local extends FiberScope {
-  constructor(readonly fiberId: FiberId, private parentRef: WeakRef<FiberRuntime<unknown, unknown>>) {
+  constructor(
+    readonly fiberId: FiberId,
+    private parentRef: WeakRef<FiberRuntime<unknown, unknown>>,
+  ) {
     super();
   }
   unsafeAdd(currentFiber: FiberRuntime<any, any>, _runtimeFlags: RuntimeFlags, child: FiberRuntime<any, any>): void {

package/_src/FiberScope.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: FiberScope/*.ts }
-export * from "./FiberScope/constructors.js";
 export * from "./FiberScope/definition.js";
+export * from "./FiberScope/constructors.js";
 // codegen:end

package/_src/FiberStatus/definition.ts

@@ -20,7 +20,10 @@ export class Done {
  */
 export class Running {
   readonly _tag = FiberStatusTag.Running;
-  constructor(readonly runtimeFlags: RuntimeFlags, readonly trace?: string) {}
+  constructor(
+    readonly runtimeFlags: RuntimeFlags,
+    readonly trace?: string,
+  ) {}
   readonly isFinished = false;
 }
 
@@ -29,7 +32,11 @@ export class Running {
  */
 export class Suspended {
   readonly _tag = FiberStatusTag.Suspended;
-  constructor(readonly runtimeFlags: RuntimeFlags, readonly blockingOn: FiberId, readonly trace?: string) {}
+  constructor(
+    readonly runtimeFlags: RuntimeFlags,
+    readonly blockingOn: FiberId,
+    readonly trace?: string,
+  ) {}
   readonly isFinished = false;
 }
 

package/_src/FiberStatus.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: FiberStatus/*.ts }
-export * from "./FiberStatus/constructors.js";
 export * from "./FiberStatus/definition.js";
+export * from "./FiberStatus/constructors.js";
 // codegen:end

package/_src/Future/definition.ts

@@ -1,14 +1,33 @@
+export const FutureTypeId = Symbol.for("fncts.io.Future");
+export type FutureTypeId = typeof FutureTypeId;
+
+export const FutureVariance = Symbol.for("fncts.io.Future.Variance");
+export type FutureVariance = typeof FutureVariance;
+
 /**
  * @tsplus type fncts.io.Future
  * @tsplus companion fncts.io.FutureOps
  */
-export class Future<E, A> {
-  constructor(public state: State<E, A>, readonly blockingOn: FiberId) {}
+export class Future<in out E, in out A> {
+  readonly [FutureTypeId]: FutureTypeId = FutureTypeId;
+  declare FutureVariance: {
+    readonly _A: (_: A) => A;
+    readonly _E: (_: E) => E;
+  };
+  constructor(
+    public state: State<E, A>,
+    readonly blockingOn: FiberId,
+  ) {}
+}
+
+export declare namespace Future {
+  type ErrorOf<X> = [X] extends [{ [FutureVariance]: { _E: (_: infer E) => infer E } }] ? E : never;
+  type ValueOf<X> = [X] extends [{ [FutureVariance]: { _A: (_: infer A) => infer A } }] ? A : never;
 }
 
 export const enum FutureStateTag {
-  Done = "Done",
-  Pending = "Pending",
+  Done,
+  Pending,
 }
 
 export class Pending<E, A> {

package/_src/Future.ts

@@ -1,5 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Future/*.ts }
-export * from "./Future/api.js";
-export * from "./Future/constructors.js";
 export * from "./Future/definition.js";
+export * from "./Future/constructors.js";
+export * from "./Future/api.js";
 // codegen:end

package/_src/Hub/api.ts

@@ -108,7 +108,10 @@ export function dimapIO<A, B, RC, EC, C, RD, ED, D>(
 }
 
 class FilterInputIO<RA, RA1, RB, EA, EA1, EB, A, B> extends PHubInternal<RA | RA1, RB, EA | EA1, EB, A, B> {
-  constructor(readonly source: PHubInternal<RA, RB, EA, EB, A, B>, readonly f: (a: A) => IO<RA1, EA1, boolean>) {
+  constructor(
+    readonly source: PHubInternal<RA, RB, EA, EB, A, B>,
+    readonly f: (a: A) => IO<RA1, EA1, boolean>,
+  ) {
     super();
   }
   awaitShutdown = this.source.awaitShutdown;
@@ -147,7 +150,10 @@ export function filterInput<A>(f: (a: A) => boolean, __tsplusTrace?: string) {
 }
 
 class FilterOutputIO<RA, RB, RB1, EA, EB, EB1, A, B> extends PHubInternal<RA, RB | RB1, EA, EB | EB1, A, B> {
-  constructor(readonly source: PHubInternal<RA, RB, EA, EB, A, B>, readonly f: (a: B) => IO<RB1, EB1, boolean>) {
+  constructor(
+    readonly source: PHubInternal<RA, RB, EA, EB, A, B>,
+    readonly f: (a: B) => IO<RB1, EB1, boolean>,
+  ) {
     super();
   }
   awaitShutdown = this.source.awaitShutdown;

package/_src/Hub.ts

@@ -1,4 +1,5 @@
-// codegen:start { preset: barrel, include: ./Hub/*.ts, exclude: ./Hub/*internal.ts }
-export * from "./Hub/api.js";
+/* eslint-disable simple-import-sort/exports */
+// codegen:start { preset: barrel, include: ./Hub/*.ts, exclude: Hub/*internal.ts }
 export * from "./Hub/definition.js";
+export * from "./Hub/api.js";
 // codegen:end

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(
-        (canceler) => {
+      result.match({
+        Left: (canceler) => {
           cancelerRef = canceler;
         },
-        (done) => {
+        Right: (done) => {
           k(done);
         },
-      );
+      });
     }, blockingOn).onInterrupt(() => cancelerRef);
   });
 }

package/_src/IO/api/concurrentFinalizers.ts

@@ -1,11 +1,78 @@
+/**
+ * @tsplus getter fncts.io.IO sequentialFinalizers
+ */
+export function sequentialFinalizers<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+  return IO.environmentWithIO((environment) =>
+    environment.getMaybe(Scope.Tag).match(
+      () => IO.defer(io),
+      (scope) => {
+        if (scope.executionStrategy._tag === "Sequential") {
+          return IO.defer(io);
+        } else {
+          return scope.forkWith(ExecutionStrategy.sequential).flatMap((scope) => scope.extend(io));
+        }
+      },
+    ),
+  );
+}
+
 /**
  * @tsplus getter fncts.io.IO concurrentFinalizers
  */
-export function concurrentFinalizers<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R | Scope, E, A> {
-  return Do((Δ) => {
-    const outerScope = Δ(IO.scope);
-    const innerScope = Δ(Scope.concurrent);
-    Δ(outerScope.addFinalizerExit(Finalizer.get((exit) => innerScope.close(exit))));
-    return Δ(innerScope.extend(io));
-  });
+export function concurrentFinalizers<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+  return IO.environmentWithIO((environment) =>
+    environment.getMaybe(Scope.Tag).match(
+      () => IO.defer(io),
+      (scope) => {
+        if (scope.executionStrategy._tag === "Concurrent") {
+          return IO.defer(io);
+        } else {
+          return scope.forkWith(ExecutionStrategy.concurrent).flatMap((scope) => scope.extend(io));
+        }
+      },
+    ),
+  );
+}
+
+/**
+ * @tsplus static fncts.io.IOOps concurrentFinalizersMask
+ */
+export function concurrentFinalizersMask<R, E, A>(
+  f: (restore: <R, E, A>(io: IO<R, E, A>) => IO<R, E, A>) => IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
+  return IO.environmentWithIO((environment) =>
+    environment.getMaybe(Scope.Tag).match(
+      () => f(Function.identity),
+      (scope) =>
+        scope.executionStrategy.match(
+          () => f(sequentialFinalizersRestorer).concurrentFinalizers,
+          () => f(concurrentFinalizersRestorer).concurrentFinalizers,
+          (n) => f((io) => concurrentBoundedFinalizersRestorer(io, n)).concurrentFinalizers,
+        ),
+    ),
+  );
+}
+
+function sequentialFinalizersRestorer<R, E, A>(io: IO<R, E, A>): IO<R, E, A> {
+  return io.sequentialFinalizers;
+}
+
+function concurrentFinalizersRestorer<R, E, A>(io: IO<R, E, A>): IO<R, E, A> {
+  return io.concurrentFinalizers;
+}
+
+function concurrentBoundedFinalizersRestorer<R, E, A>(io: IO<R, E, A>, n: number): IO<R, E, A> {
+  return IO.environmentWithIO((environment) =>
+    environment.getMaybe(Scope.Tag).match(
+      () => io,
+      (scope) => {
+        if (scope.executionStrategy._tag === "ConcurrentBounded") {
+          return io;
+        } else {
+          return scope.forkWith(ExecutionStrategy.concurrentBounded(n)).flatMap((scope) => scope.extend(io));
+        }
+      },
+    ),
+  );
 }

package/_src/IO/api/foreachConcurrent.ts

@@ -66,20 +66,22 @@ function foreachConcurrentUnboundedDiscard<R, E, A>(
       const future = Future.unsafeMake<void, void>(FiberId.none);
       const ref    = new AtomicNumber(0);
       return IO.transplant((graft) =>
-        IO.foreach(
-          as,
-          (a) =>
-            graft(
-              restore(IO.defer(f(a))).matchCauseIO(
-                (cause) => future.fail(undefined).zipRight(IO.failCauseNow(cause)),
-                () => {
-                  if (ref.incrementAndGet() === size) {
-                    future.unsafeDone(IO.unit);
-                  }
-                  return IO.unit;
-                },
-              ),
-            ).forkDaemon,
+        IO.concurrentFinalizersMask((restoreFinalizers) =>
+          IO.foreach(
+            as,
+            (a) =>
+              graft(
+                restore(restoreFinalizers(IO.defer(f(a)))).matchCauseIO(
+                  (cause) => future.fail(undefined).zipRight(IO.failCauseNow(cause)),
+                  () => {
+                    if (ref.incrementAndGet() === size) {
+                      future.unsafeDone(IO.unit);
+                    }
+                    return IO.unit;
+                  },
+                ),
+              ).forkDaemon,
+          ),
         ),
       ).flatMap((fibers) =>
         restore(future.await).matchCauseIO(

package/_src/IO/api/interrupt.ts

@@ -1,4 +1,4 @@
-import { IOPrimitive,IOTag } 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";
 

package/_src/IO/api/patchFiberRefs.ts

@@ -0,0 +1,8 @@
+import type { FiberRefsPatch } from "@fncts/io/FiberRefs";
+
+/**
+ * @tsplus static fncts.io.IOOps patchFiberRefs
+ */
+export function patchFiberRefs(patch: FiberRefsPatch): UIO<void> {
+  return IO.updateFiberRefs((fiberId, fiberRefs) => patch(fiberId, fiberRefs));
+}

package/_src/IO/api/provideSomeRuntime.ts

@@ -0,0 +1,22 @@
+import type { Runtime } from "@fncts/io/IO";
+
+import { FiberRefsPatch } from "@fncts/io/FiberRefs";
+import { defaultRuntime } from "@fncts/io/IO";
+
+/**
+ * @tsplus pipeable fncts.io.IO provideSomeRuntime
+ */
+export function provideSomeRuntime<R>(runtime: Runtime<R>) {
+  return <R1, E, A>(self: IO<R1, E, A>): IO<Exclude<R1, R>, E, A> => {
+    const patchFlags        = defaultRuntime.runtimeFlags.diff(runtime.runtimeFlags);
+    const inversePatchFlags = runtime.runtimeFlags.diff(defaultRuntime.runtimeFlags);
+    const patchRefs         = FiberRefsPatch.diff(defaultRuntime.fiberRefs, runtime.fiberRefs);
+    const inversePatchRefs  = FiberRefsPatch.diff(runtime.fiberRefs, defaultRuntime.fiberRefs);
+
+    return IO.bracket(
+      IO.updateRuntimeFlags(patchFlags) > IO.patchFiberRefs(patchRefs),
+      () => self.provideSomeEnvironment(runtime.environment),
+      () => IO.updateRuntimeFlags(inversePatchFlags) > IO.patchFiberRefs(inversePatchRefs),
+    );
+  };
+}

package/_src/IO/api.ts

@@ -6,7 +6,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 { IOPrimitive,IOTag } from "@fncts/io/IO/definition";
+import { IOPrimitive, IOTag } from "@fncts/io/IO/definition";
 import { IO } from "@fncts/io/IO/definition";
 
 /**
@@ -122,10 +122,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(
-          (e) => onFailure(e).flatMap(() => IO.failCauseNow(cause)),
-          () => IO.failCauseNow(cause),
-        ),
+        cause.failureOrCause.match({
+          Left: (e) => onFailure(e).flatMap(() => IO.failCauseNow(cause)),
+          Right: () => IO.failCauseNow(cause),
+        }),
       (a) => onSuccess(a).zipRight(IO.succeedNow(a)),
     );
   };
@@ -200,7 +200,8 @@ 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((e) => f(e).getOrElse(IO.failCauseNow(cause)), IO.failCauseNow),
+      (cause) =>
+        cause.failureOrCause.match({ Left: (e) => f(e).getOrElse(IO.failCauseNow(cause)), Right: IO.failCauseNow }),
       IO.succeedNow,
     );
   };
@@ -804,7 +805,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(IO.failNow, IO.succeedNow));
+  return IO.succeed(either).flatMap((ea) => ea.match({ Left: IO.failNow, Right: IO.succeedNow }));
 }
 
 /**
@@ -814,7 +815,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(IO.failNow, IO.succeedNow);
+  return either.match({ Left: IO.failNow, Right: IO.succeedNow });
 }
 
 /**
@@ -1249,7 +1250,10 @@ 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(onFailure, IO.failCauseNow), onSuccess);
+    return self.matchCauseIO(
+      (cause) => cause.failureOrCause.match({ Left: onFailure, Right: IO.failCauseNow }),
+      onSuccess,
+    );
   };
 }
 
@@ -1281,7 +1285,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(([e, trace]) => onFailure(e, trace), IO.failCauseNow),
+      (cause) => cause.failureTraceOrCause.match({ Left: ([e, trace]) => onFailure(e, trace), Right: IO.failCauseNow }),
       onSuccess,
     );
   };
@@ -1786,7 +1790,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(IO.failNow, IO.succeedNow));
+  return ma.flatMap((ea) => ea.match({ Left: IO.failNow, Right: IO.succeedNow }));
 }
 
 /**
@@ -1824,10 +1828,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(
-          (e) => f(e).flatMap(() => IO.failCauseNow(cause)),
-          (_) => IO.failCauseNow(cause),
-        ),
+        cause.failureOrCause.match({
+          Left: (e) => f(e).flatMap(() => IO.failCauseNow(cause)),
+          Right: (_) => IO.failCauseNow(cause),
+        }),
       IO.succeedNow,
     );
 }
@@ -2003,7 +2007,10 @@ export class GenIO<R, E, A> {
   readonly _E!: () => E;
   readonly _A!: () => A;
 
-  constructor(readonly effect: IO<R, E, A>, readonly _trace?: string) {}
+  constructor(
+    readonly effect: IO<R, E, A>,
+    readonly _trace?: string,
+  ) {}
 
   *[Symbol.iterator](): Generator<GenIO<R, E, A>, A, any> {
     return yield this;

package/_src/IO/definition.ts

@@ -50,6 +50,10 @@ declare module "@fncts/base/data/Exit/definition" {
   interface Failure<E> extends IO<never, E, never> {}
 }
 
+declare module "@fncts/base/data/Tag/definition" {
+  interface Tag<T, Identifier = T> extends IO<never, never, T> {}
+}
+
 /**
  * @tsplus type fncts.io.IOAspects
  */
@@ -259,7 +263,8 @@ export type Primitive =
   | Nothing
   | Just<any>
   | Failure<any>
-  | Success<any>;
+  | Success<any>
+  | Tag<any>;
 
 /**
  * @tsplus static fncts.io.IOOps concrete

package/_src/IO/runtime.ts

@@ -96,9 +96,12 @@ export class Runtime<R> {
   };
 
   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);
+    return this.unsafeRunOrFork(io).match({
+      Left: () => {
+        throw new Error("Encountered async boundary");
+      },
+      Right: Function.identity,
+    });
   };
 }