@fncts/io 0.0.38 → 0.0.39

package/_src/Channel/internal/ChannelExecutor.ts

@@ -1,12 +1,12 @@
 import type { ChildExecutorDecision } from "@fncts/io/Channel/ChildExecutorDecision";
-import type { BracketOut, Continuation, Ensuring } from "@fncts/io/Channel/definition";
+import type { BracketOut, Continuation, ContinuationFinalizer, Ensuring } from "@fncts/io/Channel/definition";
 import type { ChannelState } from "@fncts/io/Channel/internal/ChannelState";
 import type { UpstreamPullStrategy } from "@fncts/io/Channel/UpstreamPullStrategy";
 
 import { Queue } from "@fncts/base/collection/immutable/Queue";
 import { identity } from "@fncts/base/data/function";
 import { Stack } from "@fncts/base/internal/Stack";
-import { ChannelTag, concrete, concreteContinuation, ContinuationFinalizer } from "@fncts/io/Channel/definition";
+import { ChannelPrimitive, ChannelTag, concrete, concreteContinuation } from "@fncts/io/Channel/definition";
 import * as State from "@fncts/io/Channel/internal/ChannelState";
 import { UpstreamPullRequest } from "@fncts/io/Channel/UpstreamPullRequest";
 
@@ -14,7 +14,7 @@ type ErasedChannel<R> = Channel<R, unknown, unknown, unknown, unknown, unknown,
 export type ErasedExecutor<R> = ChannelExecutor<R, unknown, unknown, unknown, unknown, unknown, unknown>;
 type ErasedContinuation<R> = Continuation<R, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown>;
 
-type Finalizer<R> = (exit: Exit<unknown, unknown>) => URIO<R, unknown>;
+type Finalizer = (exit: Exit<unknown, unknown>) => URIO<any, any>;
 
 /*
  * -------------------------------------------------------------------------------------------------
@@ -303,7 +303,7 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
                 if (this.input !== null) {
                   const inputExecutor = this.input;
                   this.input          = null;
-                  const drainer: URIO<Env, unknown> = currentChannel.input.awaitRead.zipRight(
+                  const drainer: URIO<Env, unknown> = currentChannel.i0.awaitRead.zipRight(
                     IO.defer(() => {
                       const state = inputExecutor.run();
 
@@ -311,16 +311,16 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
                         case State.ChannelStateTag.Done: {
                           const done = inputExecutor.getDone();
                           return done.match(
-                            (cause) => currentChannel.input.error(cause),
-                            (value) => currentChannel.input.done(value),
+                            (cause) => currentChannel.i0.error(cause),
+                            (value) => currentChannel.i0.done(value),
                           );
                         }
                         case State.ChannelStateTag.Emit: {
-                          return currentChannel.input.emit(inputExecutor.getEmit()).flatMap(() => drainer);
+                          return currentChannel.i0.emit(inputExecutor.getEmit()).flatMap(() => drainer);
                         }
                         case State.ChannelStateTag.Effect: {
                           return state.effect.matchCauseIO(
-                            (cause) => currentChannel.input.error(cause),
+                            (cause) => currentChannel.i0.error(cause),
                             () => drainer,
                           );
                         }
@@ -328,7 +328,7 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
                           return readUpstream(
                             state,
                             () => drainer,
-                            (cause: Cause<any>) => currentChannel.input.error(cause),
+                            (cause: Cause<any>) => currentChannel.i0.error(cause),
                           );
                         }
                       }
@@ -357,7 +357,7 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
               }
               case ChannelTag.PipeTo: {
                 const previousInput = this.input;
-                const leftExec      = new ChannelExecutor(currentChannel.left, this.providedEnv, (_) =>
+                const leftExec      = new ChannelExecutor(currentChannel.i0, this.providedEnv, (_) =>
                   this.executeCloseLastSubstream(_),
                 );
                 leftExec.input = previousInput;
@@ -370,7 +370,7 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
                     return IO.unit;
                   }
                 });
-                this.currentChannel = currentChannel.right();
+                this.currentChannel = currentChannel.i1();
                 break;
               }
               case ChannelTag.Read: {
@@ -379,29 +379,29 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
                   this.input,
                   identity,
                   (out) => {
-                    this.currentChannel = read.more(out);
+                    this.currentChannel = read.i0(out);
                     return null;
                   },
                   (exit) => {
-                    this.currentChannel = read.done.onExit(exit);
+                    this.currentChannel = exit.match(read.i1.i1, read.i1.i0);
                     return null;
                   },
                 );
                 break;
               }
               case ChannelTag.Done: {
-                result = this.doneSucceed(currentChannel.terminal());
+                result = this.doneSucceed(currentChannel.i0());
                 break;
               }
               case ChannelTag.Halt: {
-                result = this.doneHalt(currentChannel.cause());
+                result = this.doneHalt(currentChannel.i0());
                 break;
               }
               case ChannelTag.FromIO: {
                 const pio =
                   this.providedEnv === null
-                    ? currentChannel.io
-                    : currentChannel.io.provideEnvironment(this.providedEnv as Environment<Env>);
+                    ? currentChannel.i0
+                    : currentChannel.i0.provideEnvironment(this.providedEnv as Environment<Env>);
                 result = new State.Effect(
                   pio.matchCauseIO(
                     (cause) => {
@@ -425,11 +425,11 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
                 break;
               }
               case ChannelTag.Defer: {
-                this.currentChannel = currentChannel.effect();
+                this.currentChannel = currentChannel.i0();
                 break;
               }
               case ChannelTag.Emit: {
-                this.emitted        = currentChannel.out();
+                this.emitted        = currentChannel.i0();
                 this.currentChannel = this.activeSubexecutor !== null ? null : Channel.endNow(undefined);
                 result              = State._Emit;
                 break;
@@ -444,25 +444,25 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
                     const prevLastClose     = this.closeLastSubstream === null ? IO.unit : this.closeLastSubstream;
                     this.closeLastSubstream = prevLastClose.flatMap(() => f);
                   });
-                const exec             = new ChannelExecutor(() => currentChannel.value, this.providedEnv, innerExecuteLastClose);
+                const exec             = new ChannelExecutor(() => currentChannel.i4, this.providedEnv, innerExecuteLastClose);
                 exec.input             = this.input;
                 this.activeSubexecutor = new PullFromUpstream(
                   exec,
-                  currentChannel.k,
+                  currentChannel.i5,
                   null,
                   Queue.empty(),
-                  currentChannel.combineInners,
-                  currentChannel.combineAll,
-                  currentChannel.onPull,
-                  currentChannel.onEmit,
+                  currentChannel.i0,
+                  currentChannel.i1,
+                  currentChannel.i2,
+                  currentChannel.i3,
                 );
                 this.closeLastSubstream = null;
                 this.currentChannel     = null;
                 break;
               }
               case ChannelTag.Fold: {
-                this.doneStack      = this.doneStack.prepend(currentChannel.k);
-                this.currentChannel = currentChannel.value;
+                this.doneStack      = this.doneStack.prepend(currentChannel.i1);
+                this.currentChannel = currentChannel.i0;
                 break;
               }
               case ChannelTag.BracketOut: {
@@ -471,8 +471,8 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
               }
               case ChannelTag.Provide: {
                 const previousEnv   = this.providedEnv;
-                this.providedEnv    = currentChannel.environment;
-                this.currentChannel = currentChannel.inner;
+                this.providedEnv    = currentChannel.i0;
+                this.currentChannel = currentChannel.i1;
                 this.addFinalizer(() =>
                   IO.succeed(() => {
                     this.providedEnv = previousEnv;
@@ -500,7 +500,7 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
     /**
      * @tsplus tailRec
      */
-    const unwind = (acc: List<Finalizer<Env>>): List<Finalizer<Env>> => {
+    const unwind = (acc: List<Finalizer>): List<Finalizer> => {
       if (this.doneStack.isEmpty()) {
         return acc.reverse;
       } else {
@@ -510,7 +510,7 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
         if (head._tag === ChannelTag.ContinuationK) {
           return unwind(acc);
         } else {
-          return unwind(acc.prepend(head.finalizer));
+          return unwind(acc.prepend(head.i0));
         }
       }
     };
@@ -520,8 +520,8 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
     return effect;
   }
 
-  private popNextFinalizers(): List<ContinuationFinalizer<Env, unknown, unknown>> {
-    const builder = new ListBuffer<ContinuationFinalizer<Env, unknown, unknown>>();
+  private popNextFinalizers(): List<ContinuationFinalizer> {
+    const builder = new ListBuffer<ContinuationFinalizer>();
     /**
      * @tsplus tailrec
      */
@@ -980,7 +980,7 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
 
     if (head._tag === ChannelTag.ContinuationK) {
       this.doneStack      = this.doneStack.unsafeTail;
-      this.currentChannel = head.onSuccess(z);
+      this.currentChannel = head.i0(z);
       return null;
     } else {
       const finalizers = this.popNextFinalizers();
@@ -992,7 +992,7 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
         return State._Done;
       } else {
         const finalizerEffect = this.runFinalizers(
-          finalizers.map((_) => _.finalizer),
+          finalizers.map((_) => _.i0),
           Exit.succeed(z),
         );
         this.storeInProgressFinalizer(finalizerEffect);
@@ -1020,7 +1020,7 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
 
     if (head._tag === ChannelTag.ContinuationK) {
       this.doneStack      = this.doneStack.unsafeTail;
-      this.currentChannel = head.onHalt(cause);
+      this.currentChannel = head.i1(cause);
       return null;
     } else {
       const finalizers = this.popNextFinalizers();
@@ -1032,7 +1032,7 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
         return State._Done;
       } else {
         const finalizerEffect = this.runFinalizers(
-          finalizers.map((_) => _.finalizer),
+          finalizers.map((_) => _.i0),
           Exit.failCause(cause),
         );
         this.storeInProgressFinalizer(finalizerEffect);
@@ -1049,8 +1049,10 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
     }
   }
 
-  private addFinalizer(f: Finalizer<Env>) {
-    this.doneStack = this.doneStack.prepend(new ContinuationFinalizer(f));
+  private addFinalizer(f: Finalizer) {
+    const op       = new ChannelPrimitive(ChannelTag.ContinuationFinalizer);
+    op.i0          = f;
+    this.doneStack = this.doneStack.prepend(op as any);
   }
 
   private provide<Env, OutErr, OutDone>(
@@ -1064,17 +1066,17 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
     }
   }
 
-  private runBracketOut(bracketOut: BracketOut<Env, unknown, unknown, unknown>): ChannelState<Env, unknown> | null {
+  private runBracketOut(bracketOut: BracketOut): ChannelState<Env, unknown> | null {
     return new State.Effect(
       IO.uninterruptible(
-        this.provide(bracketOut.acquire).matchCauseIO(
+        this.provide(bracketOut.i0).matchCauseIO(
           (cause) =>
             IO.succeed(() => {
               this.currentChannel = Channel.failCause(cause);
             }),
           (out) =>
             IO.succeed(() => {
-              this.addFinalizer((e) => this.provide(bracketOut.finalizer(out, e)));
+              this.addFinalizer((e) => this.provide(bracketOut.i1(out, e)));
               this.currentChannel = Channel.write(() => out);
             }),
         ),
@@ -1082,8 +1084,8 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
     );
   }
 
-  private runEnsuring(ensuring: Ensuring<Env, any, any, any, any, any, any>) {
-    this.addFinalizer(ensuring.finalizer);
-    this.currentChannel = ensuring.channel;
+  private runEnsuring(ensuring: Ensuring) {
+    this.addFinalizer(ensuring.i1);
+    this.currentChannel = ensuring.i0;
   }
 }

package/_src/Channel/internal/SingleProducerAsyncInput.ts

@@ -139,7 +139,7 @@ export class SingleProducerAsyncInput<Err, Elem, Done>
           switch (state._stateTag) {
             case StateTag.Emit: {
               return tuple(
-                p.await.matchCause(onError, (de) => de.match(onDone, onElement)),
+                p.await.matchCause(onError, (de) => de.match({ Left: onDone, Right: onElement })),
                 new StateEmit(state.notifyConsumers.enqueue(p)),
               );
             }
@@ -153,7 +153,7 @@ export class SingleProducerAsyncInput<Err, Elem, Done>
               return tuple(
                 state.notifyProducer
                   .succeed(undefined)
-                  .zipRight(p.await.matchCause(onError, (de) => de.match(onDone, onElement))),
+                  .zipRight(p.await.matchCause(onError, (de) => de.match({ Left: onDone, Right: onElement }))),
                 new StateEmit(Queue.single(p)),
               );
             }

package/_src/Console/live.ts

@@ -8,7 +8,7 @@ export class LiveConsole extends Console {
     return IO(console.log(line));
   }
   error(line: string) {
-    return IO(console.debug(line));
+    return IO(console.error(line));
   }
 }
 

package/_src/Fiber/FiberRuntime.ts

@@ -293,7 +293,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
     let ops       = 0;
 
     while (true) {
-      if (this._runtimeFlags.opSupervision) {
+      if ((this._runtimeFlags & RuntimeFlag.OpSupervision) !== 0) {
         this.getSupervisor().unsafeOnEffect(this, cur);
       }
 
@@ -304,7 +304,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
 
       ops += 1;
 
-      if (ops > 2048) {
+      if (ops > this.getFiberRef(FiberRef.currentMaxFiberOps)) {
         ops          = 0;
         const oldCur = cur;
         const trace  = lastTrace;
@@ -545,7 +545,10 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
   }
 
   getFiberRef<A>(fiberRef: FiberRef<A>): A {
-    return this._fiberRefs.getOrDefault(fiberRef);
+    if (this._fiberRefs.unFiberRefs.has(fiberRef)) {
+      return this._fiberRefs.unFiberRefs.unsafeGet(fiberRef)!.head[1] as A;
+    }
+    return fiberRef.initial;
   }
 
   tell(message: FiberMessage): void {

package/_src/FiberRef/definition.ts

@@ -1,3 +1,4 @@
+import { globalValue } from "@fncts/base/data/Global";
 import { AtomicNumber } from "@fncts/base/internal/AtomicNumber";
 
 export const FiberRefVariance = Symbol.for("fncts.io.FiberRef.Variance");
@@ -24,7 +25,9 @@ export declare namespace FiberRef {
   }
 }
 
-const fiberRefCounter = new AtomicNumber(0);
+const FiberRefCounterId = Symbol.for("fncts.io.FiberRef.FiberRefCounter");
+
+const fiberRefCounter = globalValue(FiberRefCounterId, () => new AtomicNumber(0));
 
 /**
  * @tsplus type fncts.io.FiberRef

package/_src/FiberRef/unsafe.ts

@@ -115,3 +115,8 @@ export const currentIsFatal = FiberRef.unsafeMake<IsFatal>(IsFatal.empty);
 export const currentReportFatal = FiberRef.unsafeMake<(t: unknown) => never>((t) => {
   throw t;
 });
+
+/**
+ * @tsplus static fncts.io.FiberRefOps currentMaxFiberOps
+ */
+export const currentMaxFiberOps = FiberRef.unsafeMake<number>(2048);

package/_src/Future/definition.ts

@@ -1,14 +1,30 @@
+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> {
+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/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.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,
     );
 }

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,
+    });
   };
 }
 

package/_src/Layer/api.ts

@@ -205,7 +205,10 @@ export function matchLayer<E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(
   __tsplusTrace?: string,
 ) {
   return <RIn>(self: Layer<RIn, E, ROut>): Layer<RIn | RIn1 | RIn2, E1 | E2, ROut1 | ROut2> => {
-    return self.matchCauseLayer((cause) => cause.failureOrCause.match(failure, Layer.failCauseNow), success);
+    return self.matchCauseLayer(
+      (cause) => cause.failureOrCause.match({ Left: failure, Right: Layer.failCauseNow }),
+      success,
+    );
   };
 }
 

package/_src/Push/api.ts

@@ -36,10 +36,10 @@ export function asyncInterrupt<R, E, A>(
         };
         const eitherPush = Δ(IO(make(unsafeSink)));
         Δ(
-          eitherPush.match(
-            (canceller) => future.await.onInterrupt(canceller),
-            (push) => push.run(sink),
-          ),
+          eitherPush.match({
+            Left: (canceller) => future.await.onInterrupt(canceller),
+            Right: (push) => push.run(sink),
+          }),
         );
       }).scoped,
   );

package/_src/Ref/Derived.ts

@@ -35,8 +35,8 @@ export class Derived<EA, EB, A, B> extends RefInternal<never, never, EA, EB, A,
         new Derived<EC, ED, C, D>((f) =>
           f(
             value,
-            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
-            (c) => ca(c).flatMap((a) => setEither(a).match((e) => Either.left(ea(e)), Either.right)),
+            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
+            (c) => ca(c).flatMap((a) => setEither(a).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
           ),
         ),
     );
@@ -54,41 +54,43 @@ export class Derived<EA, EB, A, B> extends RefInternal<never, never, EA, EB, A,
         new DerivedAll<EC, ED, C, D>((f) =>
           f(
             value,
-            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
+            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
             (c) => (s) =>
               getEither(s)
-                .match(
-                  (eb) => Either.left(ec(eb)),
-                  (b) => ca(c)(b),
-                )
-                .flatMap((a) => setEither(a).match((e) => Either.left(ea(e)), Either.right)),
+                .match({
+                  Left: (eb) => Either.left(ec(eb)),
+                  Right: (b) => ca(c)(b),
+                })
+                .flatMap((a) => setEither(a).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
           ),
         ),
     );
   }
 
   get get(): FIO<EB, B> {
-    return this.use((value, getEither) => value.get.flatMap((s) => getEither(s).match(IO.failNow, IO.succeedNow)));
+    return this.use((value, getEither) =>
+      value.get.flatMap((s) => getEither(s).match({ Left: IO.failNow, Right: IO.succeedNow })),
+    );
   }
 
   set(a: A): FIO<EA, void> {
-    return this.use((value, _, setEither) => setEither(a).match(IO.failNow, (s) => value.set(s)));
+    return this.use((value, _, setEither) => setEither(a).match({ Left: IO.failNow, Right: (s) => value.set(s) }));
   }
 
   modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): IO<never, EA | EB, C> {
     return this.use(
       (value, getEither, setEither) =>
         value.modify((s) =>
-          getEither(s).match(
-            (e) => tuple(Either.left(e), s),
-            (a1) => {
+          getEither(s).match({
+            Left: (e) => tuple(Either.left(e), s),
+            Right: (a1) => {
               const [b, a2] = f(a1);
-              return setEither(a2).match(
-                (e) => tuple(Either.left(e), s),
-                (s) => tuple(Either.right<EA | EB, C>(b), s),
-              );
+              return setEither(a2).match({
+                Left: (e) => tuple(Either.left(e), s),
+                Right: (s) => tuple(Either.right<EA | EB, C>(b), s),
+              });
             },
-          ),
+          }),
         ).absolve,
     );
   }