@fncts/io 0.0.42 → 0.0.44

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";
 
@@ -20,8 +22,8 @@ export function async<R, E, A>(
   __tsplusTrace?: string,
 ): IO<R, E, A> {
   const io = new IOPrimitive(IOTag.Async) as any;
-  io.i0    = register;
-  io.i1    = () => blockingOn;
+  io.i0 = register;
+  io.i1 = () => blockingOn;
   io.trace = __tsplusTrace;
   return io;
 }
@@ -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,
     );
   };
@@ -315,9 +316,10 @@ export function checkInterruptible<R, E, A>(
 export function flatMap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string) {
   return <R, E>(ma: IO<R, E, A>): IO<R | R1, E | E1, B> => {
     const io = new IOPrimitive(IOTag.OnSuccess) as any;
-    io.i0    = ma;
-    io.i1    = f;
+    io.i0 = ma;
+    io.i1 = f;
     io.trace = __tsplusTrace;
+
     return io;
   };
 }
@@ -363,8 +365,8 @@ export function condIO<R, R1, E, A>(
 
 /**
  * Returns a lazily constructed effect, whose construction may itself require
- * effects. The effect must not throw any exceptions. When no environment is required (i.e., when R == unknown)
- * it is conceptually equivalent to `flatten(succeedWith(io))`. If you wonder if the effect throws exceptions,
+ * effects. The effect must not throw any exceptions. When no environment is required (i.e., when R == never)
+ * it is conceptually equivalent to `flatten(succeed(io))`. If you wonder if the effect throws exceptions,
  * do not use this method, use `IO.deferTryCatch`.
  *
  * @tsplus static fncts.io.IOOps defer
@@ -375,7 +377,7 @@ export function defer<R = never, E = never, A = never>(io: Lazy<IO<R, E, A>>, __
 
 /**
  * Returns a lazily constructed effect, whose construction may itself require effects.
- * When no environment is required (i.e., when R == unknown) it is conceptually equivalent to `flatten(try(io))`.
+ * When no environment is required (i.e., when R == never) it is conceptually equivalent to `flatten(tryCatch(io))`.
  *
  * @tsplus static fncts.io.IOOps deferTry
  */
@@ -396,7 +398,7 @@ export function deferTry<R = never, E = never, A = never>(
  * Returns a lazily constructed effect, whose construction may itself require effects,
  * translating any thrown exceptions into typed failed effects and mapping the error.
  *
- * When no environment is required (i.e., when R == unknown) it is conceptually equivalent to `flatten(effect(io))`.
+ * When no environment is required (i.e., when R == never) it is conceptually equivalent to `flatten(try(io))`.
  *
  * @tsplus static IOOps deferTryCatch
  */
@@ -467,7 +469,7 @@ export function failNow<E>(e: E, __tsplusTrace?: string): FIO<E, never> {
  */
 export function refailCause<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E, never> {
   const io = new IOPrimitive(IOTag.Fail) as any;
-  io.i0    = () => cause;
+  io.i0 = () => cause;
   io.trace = __tsplusTrace;
   return io;
 }
@@ -479,7 +481,7 @@ export function refailCause<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E,
  */
 export function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E, never> {
   const io = new IOPrimitive(IOTag.Fail) as any;
-  io.i0    = () => cause;
+  io.i0 = () => cause;
   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);
 }
 
 /**
@@ -1098,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:
@@ -1240,9 +1249,9 @@ export function matchCauseIO<E, A, R1, E1, A1, R2, E2, A2>(
 ) {
   return <R>(self: IO<R, E, A>): IO<R | R1 | R2, E1 | E2, A1 | A2> => {
     const io = new IOPrimitive(IOTag.OnSuccessAndFailure) as any;
-    io.i0    = self;
-    io.i1    = onFailure;
-    io.i2    = onSuccess;
+    io.i0 = self;
+    io.i1 = onFailure;
+    io.i2 = onSuccess;
     io.trace = __tsplusTrace;
     return io;
   };
@@ -1257,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);
   };
 }
 
@@ -1292,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,
     );
   };
@@ -1689,7 +1695,7 @@ export function sequenceIterableDiscard<R, E, A>(as: Iterable<IO<R, E, A>>, __ts
  */
 export function succeedNow<A>(value: A, __tsplusTrace?: string): IO<never, never, A> {
   const io = new IOPrimitive(IOTag.SucceedNow) as any;
-  io.i0    = value;
+  io.i0 = value;
   io.trace = __tsplusTrace;
   return io;
 }
@@ -1697,14 +1703,14 @@ export function succeedNow<A>(value: A, __tsplusTrace?: string): IO<never, never
 /**
  * Imports a total synchronous effect into a pure `IO` value.
  * The effect must not throw any exceptions. If you wonder if the effect
- * throws exceptions, then do not use this method, use `IO.try`
+ * throws exceptions, then do not use this method, use `IO.tryCatch`
  *
  * @tsplus static fncts.io.IOOps succeed
  * @tsplus static fncts.io.IOOps __call
  */
 export function succeed<A>(effect: Lazy<A>, __tsplusTrace?: string): UIO<A> {
   const io = new IOPrimitive(IOTag.Sync) as any;
-  io.i0    = effect;
+  io.i0 = effect;
   io.trace = __tsplusTrace;
   return io;
 }
@@ -1717,7 +1723,7 @@ export function summarized<R1, E1, B, C>(summary: IO<R1, E1, B>, f: (start: B, e
     return gen(function* (_) {
       const start = yield* _(summary);
       const value = yield* _(ma);
-      const end   = yield* _(summary);
+      const end = yield* _(summary);
       return tuple(f(start, end), value);
     });
   };
@@ -1782,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;
         }
@@ -1797,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));
 }
 
 /**
@@ -1835,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,
     );
 }
@@ -1958,7 +1964,7 @@ export function withFiberRuntime<R, E, A>(
   __tsplusTrace?: string,
 ): IO<R, E, A> {
   const io = new IOPrimitive(IOTag.Stateful) as any;
-  io.i0    = onState;
+  io.i0 = onState;
   io.trace = __tsplusTrace;
   return io;
 }
@@ -1968,7 +1974,7 @@ export function withFiberRuntime<R, E, A>(
  */
 export function updateRuntimeFlags(patch: RuntimeFlags.Patch, __tsplusTrace?: string): IO<never, never, void> {
   const io = new IOPrimitive(IOTag.UpdateRuntimeFlags) as any;
-  io.i0    = patch;
+  io.i0 = patch;
   io.trace = __tsplusTrace;
   return io;
 }
@@ -2045,8 +2051,8 @@ export function gen<T extends GenIO<any, any, any>, A>(
 ): IO<_R<T>, _E<T>, A> {
   return IO.defer(() => {
     const iterator = f(adapter as any);
-    const state    = iterator.next();
-    const run      = (state: IteratorYieldResult<T> | IteratorReturnResult<A>): IO<any, any, A> => {
+    const state = iterator.next();
+    const run = (state: IteratorYieldResult<T> | IteratorReturnResult<A>): IO<any, any, A> => {
       if (state.done) {
         return IO.succeed(state.value);
       }

package/_src/IO/runtime.ts

@@ -96,12 +96,9 @@ export class Runtime<R> {
   };
 
   unsafeRun = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): Exit<E, A> => {
-    return this.unsafeRunOrFork(io).match({
-      Left: () => {
-        throw new Error("Encountered async boundary");
-      },
-      Right: Function.identity,
-    });
+    return this.unsafeRunOrFork(io).match(() => {
+      throw new Error("Encountered async boundary");
+    }, Function.identity);
   };
 }
 

package/_src/IO.ts

@@ -50,6 +50,7 @@ export * from "./IO/api/foreachConcurrent.js";
 export * from "./IO/api/environment.js";
 export * from "./IO/api/ensuringChildren.js";
 export * from "./IO/api/disconnect.js";
+export * from "./IO/api/diffFiberRefs.js";
 export * from "./IO/api/descriptor.js";
 export * from "./IO/api/delay.js";
 export * from "./IO/api/daemonChildren.js";

package/_src/Layer/api.ts

@@ -206,10 +206,7 @@ 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({ Left: failure, Right: Layer.failCauseNow }),
-      success,
-    );
+    return self.matchCauseLayer((cause) => cause.failureOrCause.match(failure, 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({
-            Left: (canceller) => future.await.onInterrupt(canceller),
-            Right: (push) => push.run(sink),
-          }),
+          eitherPush.match(
+            (canceller) => future.await.onInterrupt(canceller),
+            (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({ 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 })),
+            (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)),
           ),
         ),
     );
@@ -54,43 +54,41 @@ 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({ Left: (e) => Either.left(eb(e)), Right: bd }),
+            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
             (c) => (s) =>
               getEither(s)
-                .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 })),
+                .match(
+                  (eb) => Either.left(ec(eb)),
+                  (b) => ca(c)(b),
+                )
+                .flatMap((a) => setEither(a).match((e) => Either.left(ea(e)), Either.right)),
           ),
         ),
     );
   }
 
   get get(): FIO<EB, B> {
-    return this.use((value, getEither) =>
-      value.get.flatMap((s) => getEither(s).match({ Left: IO.failNow, Right: IO.succeedNow })),
-    );
+    return this.use((value, getEither) => value.get.flatMap((s) => getEither(s).match(IO.failNow, IO.succeedNow)));
   }
 
   set(a: A): FIO<EA, void> {
-    return this.use((value, _, setEither) => setEither(a).match({ Left: IO.failNow, Right: (s) => value.set(s) }));
+    return this.use((value, _, setEither) => setEither(a).match(IO.failNow, (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({
-            Left: (e) => tuple(Either.left(e), s),
-            Right: (a1) => {
+          getEither(s).match(
+            (e) => tuple(Either.left(e), s),
+            (a1) => {
               const [b, a2] = f(a1);
-              return setEither(a2).match({
-                Left: (e) => tuple(Either.left(e), s),
-                Right: (s) => tuple(Either.right<EA | EB, C>(b), s),
-              });
+              return setEither(a2).match(
+                (e) => tuple(Either.left(e), s),
+                (s) => tuple(Either.right<EA | EB, C>(b), s),
+              );
             },
-          }),
+          ),
         ).absolve,
     );
   }

package/_src/Ref/DerivedAll.ts

@@ -34,9 +34,8 @@ export class DerivedAll<EA, EB, A, B> extends RefInternal<never, never, EA, EB,
         new DerivedAll((f) =>
           f(
             value,
-            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
-            (c) => (s) =>
-              ca(c).flatMap((a) => setEither(a)(s).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
+            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
+            (c) => (s) => ca(c).flatMap((a) => setEither(a)(s).match((e) => Either.left(ea(e)), Either.right)),
           ),
         ),
     );
@@ -54,30 +53,28 @@ export class DerivedAll<EA, EB, A, B> extends RefInternal<never, never, EA, EB,
         new DerivedAll((f) =>
           f(
             value,
-            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
+            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
             (c) => (s) =>
               getEither(s)
-                .match({ Left: (e) => Either.left(ec(e)), Right: ca(c) })
-                .flatMap((a) => setEither(a)(s).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
+                .match((e) => Either.left(ec(e)), ca(c))
+                .flatMap((a) => setEither(a)(s).match((e) => Either.left(ea(e)), Either.right)),
           ),
         ),
     );
   }
 
   get get(): FIO<EB, B> {
-    return this.use((value, getEither) =>
-      value.get.flatMap((s) => getEither(s).match({ Left: IO.failNow, Right: IO.succeedNow })),
-    );
+    return this.use((value, getEither) => value.get.flatMap((s) => getEither(s).match(IO.failNow, IO.succeedNow)));
   }
 
   set(a: A): FIO<EA, void> {
     return this.use(
       (value, _, setEither) =>
         value.modify((s) =>
-          setEither(a)(s).match({
-            Left: (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
-            Right: (s) => [Either.right(undefined), s],
-          }),
+          setEither(a)(s).match(
+            (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
+            (s) => [Either.right(undefined), s],
+          ),
         ).absolve,
     );
   }
@@ -86,16 +83,16 @@ export class DerivedAll<EA, EB, A, B> extends RefInternal<never, never, EA, EB,
     return this.use(
       (value, getEither, setEither) =>
         value.modify((s) =>
-          getEither(s).match({
-            Left: (e) => tuple(Either.left(e), s),
-            Right: (a1) => {
+          getEither(s).match(
+            (e) => tuple(Either.left(e), s),
+            (a1) => {
               const [b, a2] = f(a1);
-              return setEither(a2)(s).match({
-                Left: (e) => tuple(Either.left(e), s),
-                Right: (s) => tuple(Either.right<EA | EB, C>(b), s),
-              });
+              return setEither(a2)(s).match(
+                (e) => tuple(Either.left(e), s),
+                (s) => tuple(Either.right<EA | EB, C>(b), s),
+              );
             },
-          }),
+          ),
         ).absolve,
     );
   }

package/_src/STM/api/core-api.ts

@@ -65,6 +65,6 @@ export function matchSTM<E, A, R1, E1, B, R2, E2, C>(
     return self
       .map(Either.right)
       .catchAll((e) => g(e).map(Either.left))
-      .flatMap((ca) => ca.match({ Left: STM.succeedNow, Right: f }));
+      .flatMap((ca) => ca.match(STM.succeedNow, f));
   };
 }

package/_src/STM/api.ts

@@ -429,7 +429,7 @@ export function foreach<A, R, E, B>(
  * @tsplus static fncts.io.STMOps fromEither
  */
 export function fromEither<E, A>(e: Lazy<Either<E, A>>, __tsplusTrace?: string): STM<never, E, A> {
-  return STM.defer(e().match({ Left: STM.failNow, Right: STM.succeedNow }));
+  return STM.defer(e().match(STM.failNow, STM.succeedNow));
 }
 
 /**
@@ -438,7 +438,7 @@ export function fromEither<E, A>(e: Lazy<Either<E, A>>, __tsplusTrace?: string):
  * @tsplus static fncts.io.STMOps fromEitherNow
  */
 export function fromEitherNow<E, A>(e: Either<E, A>, __tsplusTrace?: string): STM<never, E, A> {
-  return e.match({ Left: STM.failNow, Right: STM.succeedNow });
+  return e.match(STM.failNow, STM.succeedNow);
 }
 
 /**
@@ -553,7 +553,7 @@ export function isSuccess<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string) {
 export function left<R, E, B, C>(stm: STM<R, E, Either<B, C>>, __tsplusTrace?: string): STM<R, Maybe<E>, B> {
   return stm.matchSTM(
     (e) => STM.fail(Just(e)),
-    (bc) => bc.match({ Left: STM.succeedNow, Right: () => STM.failNow(Nothing()) }),
+    (bc) => bc.match(STM.succeedNow, () => STM.failNow(Nothing())),
   );
 }
 
@@ -564,7 +564,7 @@ export function left<R, E, B, C>(stm: STM<R, E, Either<B, C>>, __tsplusTrace?: s
  */
 export function leftOrFail<C, E1>(orFail: (c: C) => E1, __tsplusTrace?: string) {
   return <R, E, B>(stm: STM<R, E, Either<B, C>>): STM<R, E | E1, B> => {
-    return stm.flatMap((bc) => bc.match({ Left: STM.succeedNow, Right: (c) => STM.fail(orFail(c)) }));
+    return stm.flatMap((bc) => bc.match(STM.succeedNow, (c) => STM.fail(orFail(c))));
   };
 }
 

package/_src/Schedule/api.ts

@@ -618,17 +618,17 @@ export function reconsiderIO<S, O, R1, O1>(
         decision.match(
           () =>
             f(state, out, decision).map((r) =>
-              r.match({
-                Left: (out1) => [state, out1, Decision.Done],
-                Right: ([out1, _]) => [state, out1, Decision.Done],
-              }),
+              r.match(
+                (out1) => [state, out1, Decision.Done],
+                ([out1, _]) => [state, out1, Decision.Done],
+              ),
             ),
           () =>
             f(state, out, decision).map((r) =>
-              r.match({
-                Left: (out1) => [state, out1, Decision.Done],
-                Right: ([out1, interval]) => [state, out1, Decision.continueWith(interval)],
-              }),
+              r.match(
+                (out1) => [state, out1, Decision.Done],
+                ([out1, interval]) => [state, out1, Decision.continueWith(interval)],
+              ),
             ),
         ),
       ),

package/_src/Sink/api.ts

@@ -567,20 +567,20 @@ function fromPushPull<R, E, In, L, Z>(
     (inp: Conc<In>) =>
       Channel.fromIO(push(Just(inp))).matchChannel(
         ([r, leftovers]) =>
-          r.match({
-            Left: (e) => Channel.writeNow(leftovers) > Channel.failNow(e),
-            Right: (z) => Channel.writeNow(leftovers) > Channel.succeedNow(z),
-          }),
+          r.match(
+            (e) => Channel.writeNow(leftovers) > Channel.failNow(e),
+            (z) => Channel.writeNow(leftovers) > Channel.succeedNow(z),
+          ),
         () => fromPushPull(push),
       ),
     Channel.failNow,
     () =>
       Channel.fromIO(push(Nothing())).matchChannel(
         ([r, leftovers]) =>
-          r.match({
-            Left: (e) => Channel.writeNow(leftovers) > Channel.failNow(e),
-            Right: (z) => Channel.writeNow(leftovers) > Channel.succeedNow(z),
-          }),
+          r.match(
+            (e) => Channel.writeNow(leftovers) > Channel.failNow(e),
+            (z) => Channel.writeNow(leftovers) > Channel.succeedNow(z),
+          ),
         () => Channel.fromIO(IO.halt(new Error("empty sink"))),
       ),
   );

package/_src/Stream/api/zipAllWith.ts

@@ -132,8 +132,8 @@ function zipWithChunks<A, B, C>(
   __tsplusTrace?: string,
 ): readonly [Conc<C>, State<A, B>] {
   const [out, r] = zipChunks(leftChunk, rightChunk, f);
-  return r.match({
-    Left: (leftChunk) => (leftChunk.isEmpty ? [out, new PullBoth()] : [out, new PullRight(leftChunk)]),
-    Right: (rightChunk) => (rightChunk.isEmpty ? [out, new PullBoth()] : [out, new PullLeft(rightChunk)]),
-  });
+  return r.match(
+    (leftChunk) => (leftChunk.isEmpty ? [out, new PullBoth()] : [out, new PullRight(leftChunk)]),
+    (rightChunk) => (rightChunk.isEmpty ? [out, new PullBoth()] : [out, new PullLeft(rightChunk)]),
+  );
 }

package/_src/Stream/api/zipWithChunks.ts

@@ -73,10 +73,10 @@ function handleSuccess<A1, A2, A3>(
   __tsplusTrace?: string,
 ): readonly [Conc<A3>, State<A1, A2>] {
   const [out, remaining] = f(leftChunk, rightChunk);
-  return remaining.match({
-    Left: (l) => (leftChunk.isEmpty ? [out, new PullBoth()] : [out, new PullRight(leftChunk)]),
-    Right: (r) => (rightChunk.isEmpty ? [out, new PullBoth()] : [out, new PullLeft(rightChunk)]),
-  });
+  return remaining.match(
+    (l) => (leftChunk.isEmpty ? [out, new PullBoth()] : [out, new PullRight(leftChunk)]),
+    (r) => (rightChunk.isEmpty ? [out, new PullBoth()] : [out, new PullLeft(rightChunk)]),
+  );
 }
 
 /**