@fncts/io 0.0.41 → 0.0.43

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);
   };
 }
 
@@ -324,6 +321,16 @@ function retryLoop<RIn, E, ROut, S, RIn1, X>(
   );
 }
 
+/**
+ * @tsplus static fncts.io.LayerOps scopedDiscard
+ */
+export function scopedDiscard<R, E, A>(
+  io: Lazy<IO<R, E, A>>,
+  __tsplusTrace?: string,
+): Layer<Exclude<R, Scope>, E, never> {
+  return Layer.scopedEnvironment(io().as(Environment.empty));
+}
+
 /**
  * @tsplus static fncts.io.LayerOps scoped
  */

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/Queue/api/dimapIO.ts

@@ -1,3 +1,4 @@
+import type { Maybe } from "@fncts/base/data/Maybe";
 import type { UIO } from "@fncts/io/IO";
 import type { PDequeue, PDequeueInternal, PEnqueue, PEnqueueInternal } from "@fncts/io/Queue/definition";
 
@@ -32,6 +33,14 @@ class DimapIO<RA, RB, EA, EB, A, B, RC, EC, C, RD, ED, D> extends QueueInternal<
 
   isShutdown: UIO<boolean> = this.queue.isShutdown;
 
+  get unsafeSize(): Maybe<number> {
+    return this.queue.unsafeSize;
+  }
+
+  unsafeOffer(a: C): boolean {
+    throw new Error("Cannot unsafely offer to an effectful Queue");
+  }
+
   offer(c: C): IO<RC | RA, EA | EC, boolean> {
     return this.f(c).flatMap((a) => this.queue.offer(a));
   }
@@ -151,6 +160,14 @@ class ContramapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PEnqueueInternal<R
 
   isShutdown: UIO<boolean> = this.queue.isShutdown;
 
+  get unsafeSize(): Maybe<number> {
+    return this.queue.unsafeSize;
+  }
+
+  unsafeOffer(a: C): boolean {
+    throw new Error("Cannot unsafely offer to an effectful Queue");
+  }
+
   offer(c: C): IO<RC | RA, EA | EC, boolean> {
     return this.f(c).flatMap((a) => this.queue.offer(a));
   }
@@ -202,6 +219,14 @@ class MapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PDequeueInternal<RA, RB
 
   size: UIO<number> = this.queue.size;
 
+  get unsafeSize(): Maybe<number> {
+    return this.queue.unsafeSize;
+  }
+
+  unsafeOffer(a: C): boolean {
+    throw new Error("Cannot unsafely offer to an effectful Queue");
+  }
+
   take: IO<RB | RC, EB | EC, C> = this.queue.take.flatMap(this.f);
 
   takeAll: IO<RB | RC, EB | EC, Conc<C>> = this.queue.takeAll.flatMap((bs) => IO.foreach(bs, this.f));

package/_src/Queue/api/filterInputIO.ts

@@ -16,6 +16,14 @@ class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends QueueInt
 
   isShutdown: UIO<boolean> = this.queue.isShutdown;
 
+  get unsafeSize(): Maybe<number> {
+    return this.queue.unsafeSize;
+  }
+
+  unsafeOffer(a: A1): boolean {
+    throw new Error("Cannot unsafely offer to an effectful Queue");
+  }
+
   offer(a: A1): IO<RA | R2, EA | E2, boolean> {
     return this.f(a).flatMap((b) => (b ? this.queue.offer(a) : IO.succeedNow(false)));
   }
@@ -92,6 +100,14 @@ class FilterInputEnqueueIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2>
 
   isShutdown: UIO<boolean> = this.queue.isShutdown;
 
+  get unsafeSize(): Maybe<number> {
+    return this.queue.unsafeSize;
+  }
+
+  unsafeOffer(a: A1): boolean {
+    throw new Error("Cannot unsafely offer to an effectful Queue");
+  }
+
   offer(a: A1): IO<RA | R2, EA | E2, boolean> {
     return this.f(a).flatMap((b) => (b ? this.queue.offer(a) : IO.succeedNow(false)));
   }

package/_src/Queue/api/filterOutputIO.ts

@@ -16,6 +16,14 @@ class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInternal<RA, R
 
   isShutdown: UIO<boolean> = this.queue.isShutdown;
 
+  get unsafeSize(): Maybe<number> {
+    return this.queue.unsafeSize;
+  }
+
+  unsafeOffer(a: A): boolean {
+    throw new Error("Cannot unsafely offer to an effectful Queue");
+  }
+
   offer(a: A): IO<RA, EA, boolean> {
     return this.queue.offer(a);
   }
@@ -104,6 +112,14 @@ class FilterOutputDequeueIO<RA, RB, EA, EB, A, B, RB1, EB1>
 
   size: UIO<number> = this.queue.size;
 
+  get unsafeSize(): Maybe<number> {
+    return this.queue.unsafeSize;
+  }
+
+  unsafeOffer(a: A): boolean {
+    throw new Error("Cannot unsafely offer to an effectful Queue");
+  }
+
   take: IO<RB | RB1, EB1 | EB, B> = this.queue.take.flatMap((b) =>
     this.f(b).flatMap((p) => (p ? IO.succeedNow(b) : this.take)),
   );

package/_src/Queue/api/operations.ts

@@ -43,6 +43,18 @@ export function isShutdown<RA, RB, EA, EB, A, B>(
   return queue.isShutdown;
 }
 
+/**
+ * Places one value in the queue.
+ *
+ * @tsplus pipeable fncts.io.Queue unsafeOffer
+ */
+export function unsafeOffer<A>(a: A, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, B>(queue: PEnqueue<RA, RB, EA, EB, A, B>): boolean => {
+    concrete(queue);
+    return queue.unsafeOffer(a);
+  };
+}
+
 /**
  * Places one value in the queue.
  *
@@ -103,6 +115,14 @@ export function size<RA, RB, EA, EB, A, B>(queue: PQueueCommon<RA, RB, EA, EB, A
   return queue.size;
 }
 
+/**
+ * @tsplus getter fncts.io.Queue unsafeSize
+ */
+export function unsafeSize<RA, RB, EA, EB, A, B>(queue: PQueueCommon<RA, RB, EA, EB, A, B>, __tsplusTrace?: string) {
+  concrete(queue);
+  return queue.unsafeSize;
+}
+
 /**
  * Removes the oldest value in the queue. If the queue is empty, this will
  * return a computation that resumes when an item has been added to the queue.

package/_src/Queue/api/zipWithIO.ts

@@ -23,6 +23,14 @@ class ZipWithIO<RA, RB, EA, EB, A, B, RA1, RB1, EA1, EB1, A1 extends A, B1, R3,
 
   isShutdown: UIO<boolean> = this.fa.isShutdown;
 
+  get unsafeSize(): Maybe<number> {
+    return this.fa.unsafeSize.zipWith(this.fb.unsafeSize, (a, b) => Math.max(a, b));
+  }
+
+  unsafeOffer(a: A): boolean {
+    throw new Error("Cannot unsafely offer to an effectful Queue");
+  }
+
   offer(a: A1): IO<RA | RA1, EA1 | EA, boolean> {
     return this.fa.offer(a).zipWithConcurrent(this.fb.offer(a), (x, y) => x && y);
   }

package/_src/Queue/definition.ts

@@ -113,6 +113,7 @@ export abstract class QueueInternal<RA, RB, EA, EB, A, B>
    * `true` if `shutdown` has been called.
    */
   abstract readonly isShutdown: UIO<boolean>;
+  abstract unsafeOffer(a: A): boolean;
   /**
    * Places one value in the queue.
    */
@@ -140,6 +141,7 @@ export abstract class QueueInternal<RA, RB, EA, EB, A, B>
    * Future calls to `offer*` and `take*` will be interrupted immediately.
    */
   abstract readonly shutdown: UIO<void>;
+  abstract readonly unsafeSize: Maybe<number>;
   /**
    * Retrieves the size of the queue, which is equal to the number of elements
    * in the queue. This may be negative if fibers are suspended waiting for
@@ -211,6 +213,7 @@ export interface PQueueCommonInternal<RA, RB, EA, EB, A, B> {
    * Future calls to `offer*` and `take*` will be interrupted immediately.
    */
   readonly shutdown: UIO<void>;
+  readonly unsafeSize: Maybe<number>;
   /**
    * Retrieves the size of the queue, which is equal to the number of elements
    * in the queue. This may be negative if fibers are suspended waiting for
@@ -221,6 +224,7 @@ export interface PQueueCommonInternal<RA, RB, EA, EB, A, B> {
 
 export interface PEnqueueInternal<RA, RB, EA, EB, A, B> extends PQueueCommonInternal<RA, RB, EA, EB, A, B> {
   readonly [EnqueueTypeId]: EnqueueTypeId;
+  unsafeOffer(a: A): boolean;
   /**
    * Places one value in the queue.
    */

package/_src/Queue/internal.ts

@@ -22,6 +22,38 @@ class UnsafeQueue<A> extends QueueInternal<never, never, never, never, A, A> {
 
   isShutdown: UIO<boolean> = IO.succeed(this.shutdownFlag.get);
 
+  get unsafeSize(): Maybe<number> {
+    if (this.shutdownFlag.get) {
+      return Nothing();
+    }
+    return Just(this.queue.size - this.takers.size + this.strategy.surplusSize);
+  }
+
+  unsafeOffer(a: A): boolean {
+    if (this.shutdownFlag.get) {
+      return false;
+    }
+    let noRemaining: boolean;
+    if (this.queue.size === 0) {
+      const taker = this.takers.dequeue(undefined);
+
+      if (taker != null) {
+        unsafeCompletePromise(taker, a);
+        noRemaining = true;
+      } else {
+        noRemaining = false;
+      }
+    } else {
+      noRemaining = false;
+    }
+    if (noRemaining) {
+      return true;
+    }
+    const succeeded = this.queue.enqueue(a);
+    unsafeCompleteTakers(this.strategy, this.queue, this.takers);
+    return succeeded;
+  }
+
   offer(a: A, __tsplusTrace?: string): IO<never, never, boolean> {
     return IO.defer(() => {
       if (this.shutdownFlag.get) {

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/STM/definition.ts

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

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