@fncts/io 0.0.20 → 0.0.21

package/_src/Channel/api/mergeAllWith.ts

@@ -3,139 +3,127 @@ import { identity } from "@fncts/base/data/function";
 export type MergeStrategy = "BackPressure" | "BufferSliding";
 
 /**
- * @tsplus fluent fncts.io.Channel mergeAllWith
+ * @tsplus pipeable fncts.io.Channel mergeAllWith
  */
-export function mergeAllWith_<
-  Env,
-  InErr,
-  InElem,
-  InDone,
-  OutErr,
-  OutDone,
-  Env1,
-  InErr1,
-  InElem1,
-  InDone1,
-  OutErr1,
-  OutElem,
->(
-  channels: Channel<
-    Env,
-    InErr,
-    InElem,
-    InDone,
-    OutErr,
-    Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem, OutDone>,
-    OutDone
-  >,
+export function mergeAllWith<OutDone>(
   n: number,
   f: (x: OutDone, y: OutDone) => OutDone,
   bufferSize = 16,
   mergeStrategy: MergeStrategy = "BackPressure",
-): Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem, OutDone> {
-  return Channel.unwrapScoped(
-    IO.withChildren((getChildren) =>
-      Do((Δ) => {
-        Δ(IO.addFinalizer(getChildren.flatMap(Fiber.interruptAll)));
-        const queue = Δ(
-          IO.acquireRelease(
-            Queue.makeBounded<IO<Env, OutErr | OutErr1, Either<OutDone, OutElem>>>(bufferSize),
-            (queue) => queue.shutdown,
-          ),
-        );
-        const cancelers   = Δ(IO.acquireRelease(Queue.makeUnbounded<Future<never, void>>(), (queue) => queue.shutdown));
-        const lastDone    = Δ(Ref.make<Maybe<OutDone>>(Nothing()));
-        const errorSignal = Δ(Future.make<never, void>());
-        const permits     = Δ(TSemaphore.make(n).commit);
-        const pull        = Δ(channels.toPull);
-
-        const evaluatePull = (pull: IO<Env | Env1, OutErr | OutErr1, Either<OutDone, OutElem>>) =>
-          pull
-            .flatMap((ea) =>
-              ea.match(
-                (outDone) => IO.succeedNow(Just(outDone)),
-                (outElem) => queue.offer(IO.succeedNow(Either.right(outElem))).as(Nothing()),
-              ),
-            )
-            .repeatUntil((m) => m.isJust())
-            .flatMap((md1) =>
-              md1.match(
-                () => IO.unit,
-                (outDone) =>
-                  lastDone.update((md2) =>
-                    md2.match(
-                      () => Just(outDone),
-                      (lastDone) => Just(f(lastDone, outDone)),
-                    ),
-                  ),
-              ),
-            );
-
-        Δ(
-          pull
-            .matchCauseIO(
-              (cause) =>
-                getChildren.flatMap(Fiber.interruptAll).apSecond(queue.offer(IO.failCauseNow(cause)).as(false)),
-              (doneOrChannel) =>
-                doneOrChannel.match(
+) {
+  return <Env, InErr, InElem, InDone, OutErr, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem>(
+    channels: Channel<
+      Env,
+      InErr,
+      InElem,
+      InDone,
+      OutErr,
+      Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem, OutDone>,
+      OutDone
+    >,
+  ): Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem, OutDone> => {
+    return Channel.unwrapScoped(
+      IO.withChildren((getChildren) =>
+        Do((Δ) => {
+          Δ(IO.addFinalizer(getChildren.flatMap(Fiber.interruptAll)));
+          const queue = Δ(
+            IO.acquireRelease(
+              Queue.makeBounded<IO<Env, OutErr | OutErr1, Either<OutDone, OutElem>>>(bufferSize),
+              (queue) => queue.shutdown,
+            ),
+          );
+          const cancelers    = Δ(IO.acquireRelease(Queue.makeUnbounded<Future<never, void>>(), (queue) => queue.shutdown));
+          const lastDone     = Δ(Ref.make<Maybe<OutDone>>(Nothing()));
+          const errorSignal  = Δ(Future.make<never, void>());
+          const permits      = Δ(TSemaphore.make(n).commit);
+          const pull         = Δ(channels.toPull);
+          const evaluatePull = (pull: IO<Env | Env1, OutErr | OutErr1, Either<OutDone, OutElem>>) =>
+            pull
+              .flatMap((ea) =>
+                ea.match(
+                  (outDone) => IO.succeedNow(Just(outDone)),
+                  (outElem) => queue.offer(IO.succeedNow(Either.right(outElem))).as(Nothing()),
+                ),
+              )
+              .repeatUntil((m) => m.isJust())
+              .flatMap((md1) =>
+                md1.match(
+                  () => IO.unit,
                   (outDone) =>
-                    errorSignal.await.raceWith(
-                      permits.withPermits(n)(IO.unit),
-                      (_, permitAcquisition) =>
-                        getChildren.flatMap(Fiber.interruptAll).apSecond(permitAcquisition.interrupt.as(false)),
-                      (_, failureAwait) =>
-                        failureAwait.interrupt.apSecond(
-                          lastDone.get
-                            .flatMap((maybeDone) =>
-                              maybeDone.match(
-                                () => queue.offer(IO.succeedNow(Either.left(outDone))),
-                                (lastDone) => queue.offer(IO.succeedNow(Either.left(f(lastDone, outDone)))),
-                              ),
-                            )
-                            .as(false),
-                        ),
+                    lastDone.update((md2) =>
+                      md2.match(
+                        () => Just(outDone),
+                        (lastDone) => Just(f(lastDone, outDone)),
+                      ),
                     ),
-                  (channel) => {
-                    switch (mergeStrategy) {
-                      case "BackPressure":
-                        return Do((Δ) => {
-                          const latch   = Δ(Future.make<never, void>());
-                          const raceIOs = channel.toPull.flatMap((io) =>
-                            evaluatePull(io).race(errorSignal.await),
-                          ).scoped;
-                          Δ(permits.withPermit(latch.succeed(undefined).apSecond(raceIOs)).fork);
-                          Δ(latch.await);
-                          return Δ(errorSignal.isDone.map((b) => !b));
-                        });
-                      case "BufferSliding":
-                        return Do((Δ) => {
-                          const canceler = Δ(Future.make<never, void>());
-                          const latch    = Δ(Future.make<never, void>());
-                          const size     = Δ(cancelers.size);
-                          Δ(cancelers.take.flatMap((f) => f.succeed(undefined)).when(size >= 0));
-                          const raceIOs = channel.toPull.flatMap((io) =>
-                            evaluatePull(io).race(errorSignal.await).race(canceler.await),
-                          ).scoped;
-                          Δ(permits.withPermit(latch.succeed(undefined).apSecond(raceIOs)).fork);
-                          Δ(latch.await);
-                          return Δ(errorSignal.isDone.map((b) => !b));
-                        });
-                    }
-                  },
                 ),
-            )
-            .repeatWhile(identity).fork,
-        );
-        return queue;
+              );
+          Δ(
+            pull
+              .matchCauseIO(
+                (cause) =>
+                  getChildren.flatMap(Fiber.interruptAll).apSecond(queue.offer(IO.failCauseNow(cause)).as(false)),
+                (doneOrChannel) =>
+                  doneOrChannel.match(
+                    (outDone) =>
+                      errorSignal.await.raceWith(
+                        permits.withPermits(n)(IO.unit),
+                        (_, permitAcquisition) =>
+                          getChildren.flatMap(Fiber.interruptAll).apSecond(permitAcquisition.interrupt.as(false)),
+                        (_, failureAwait) =>
+                          failureAwait.interrupt.apSecond(
+                            lastDone.get
+                              .flatMap((maybeDone) =>
+                                maybeDone.match(
+                                  () => queue.offer(IO.succeedNow(Either.left(outDone))),
+                                  (lastDone) => queue.offer(IO.succeedNow(Either.left(f(lastDone, outDone)))),
+                                ),
+                              )
+                              .as(false),
+                          ),
+                      ),
+                    (channel) => {
+                      switch (mergeStrategy) {
+                        case "BackPressure":
+                          return Do((Δ) => {
+                            const latch   = Δ(Future.make<never, void>());
+                            const raceIOs = channel.toPull.flatMap((io) =>
+                              evaluatePull(io).race(errorSignal.await),
+                            ).scoped;
+                            Δ(permits.withPermit(latch.succeed(undefined).apSecond(raceIOs)).fork);
+                            Δ(latch.await);
+                            return Δ(errorSignal.isDone.map((b) => !b));
+                          });
+                        case "BufferSliding":
+                          return Do((Δ) => {
+                            const canceler = Δ(Future.make<never, void>());
+                            const latch    = Δ(Future.make<never, void>());
+                            const size     = Δ(cancelers.size);
+                            Δ(cancelers.take.flatMap((f) => f.succeed(undefined)).when(size >= 0));
+                            const raceIOs = channel.toPull.flatMap((io) =>
+                              evaluatePull(io).race(errorSignal.await).race(canceler.await),
+                            ).scoped;
+                            Δ(permits.withPermit(latch.succeed(undefined).apSecond(raceIOs)).fork);
+                            Δ(latch.await);
+                            return Δ(errorSignal.isDone.map((b) => !b));
+                          });
+                      }
+                    },
+                  ),
+              )
+              .repeatWhile(identity).fork,
+          );
+          return queue;
+        }),
+      ).map((queue) => {
+        const consumer: Channel<Env | Env1, unknown, unknown, unknown, OutErr | OutErr1, OutElem, OutDone> =
+          Channel.unwrap(
+            queue.take.flatten.matchCause(Channel.failCauseNow, (out) =>
+              out.match(Channel.endNow, (outElem) => Channel.writeNow(outElem).apSecond(consumer)),
+            ),
+          );
+        return consumer;
       }),
-    ).map((queue) => {
-      const consumer: Channel<Env | Env1, unknown, unknown, unknown, OutErr | OutErr1, OutElem, OutDone> =
-        Channel.unwrap(
-          queue.take.flatten.matchCause(Channel.failCauseNow, (out) =>
-            out.match(Channel.endNow, (outElem) => Channel.writeNow(outElem).apSecond(consumer)),
-          ),
-        );
-      return consumer;
-    }),
-  );
+    );
+  };
 }

package/_src/Channel/api/mergeMap.ts

@@ -1,27 +1,17 @@
 import type { MergeStrategy } from "@fncts/io/Channel/api/mergeAllWith";
 
 /**
- * @tsplus fluent fncts.io.Channel mergeMap
+ * @tsplus pipeable fncts.io.Channel mergeMap
  */
-export function mergeMap_<
-  Env,
-  InErr,
-  InElem,
-  InDone,
-  OutErr,
-  OutElem,
-  Env1,
-  InErr1,
-  InElem1,
-  InDone1,
-  OutErr1,
-  OutElem1,
->(
-  self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, any>,
+export function mergeMap<OutElem, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1>(
   f: (elem: OutElem) => Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, any>,
   n: number,
   bufferSize = 16,
   mergeStrategy: MergeStrategy = "BackPressure",
-): Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem1, unknown> {
-  return self.mapOut(f).mergeAll(n, bufferSize, mergeStrategy);
+) {
+  return <Env, InErr, InElem, InDone, OutErr>(
+    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, any>,
+  ): Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem1, unknown> => {
+    return self.mapOut(f).mergeAll(n, bufferSize, mergeStrategy);
+  };
 }

package/_src/Channel/api/mergeWith.ts

@@ -9,192 +9,188 @@ import { SingleProducerAsyncInput } from "@fncts/io/Channel/internal/SingleProdu
  * the behavior of the returned channel on left or right early termination is decided by the
  * specified `leftDone` and `rightDone` merge decisions.
  *
- * @tsplus fluent fncts.io.Channel mergeWith
+ * @tsplus pipeable fncts.io.Channel mergeWith
  */
-export function mergeWith_<
-  Env,
+export function mergeWith<
   Env1,
   Env2,
   Env3,
-  InErr,
   InErr1,
-  InElem,
   InElem1,
-  InDone,
   InDone1,
   OutErr,
   OutErr1,
   OutErr2,
   OutErr3,
-  OutElem,
   OutElem1,
   OutDone,
   OutDone1,
   OutDone2,
   OutDone3,
 >(
-  self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
   that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
   leftDone: (ex: Exit<OutErr, OutDone>) => MergeDecision<Env2, OutErr1, OutDone1, OutErr2, OutDone2>,
   rightDone: (ex: Exit<OutErr1, OutDone1>) => MergeDecision<Env3, OutErr, OutDone, OutErr3, OutDone3>,
-): Channel<
-  Env | Env1 | Env2 | Env3,
-  InErr & InErr1,
-  InElem & InElem1,
-  InDone & InDone1,
-  OutErr2 | OutErr3,
-  OutElem | OutElem1,
-  OutDone2 | OutDone3
-> {
-  return Channel.unwrapScoped(
-    Do((_) => {
-      const input       = _(SingleProducerAsyncInput<InErr & InErr1, InElem & InElem1, InDone & InDone1>());
-      const queueReader = Channel.fromInput(input);
-      const pullL       = _(queueReader.pipeTo(self).toPull);
-      const pullR       = _(queueReader.pipeTo(that).toPull);
-      type LocalMergeState = MergeState<
-        Env | Env1 | Env2 | Env3,
-        OutErr,
-        OutErr1,
-        OutErr2 | OutErr3,
-        OutElem | OutElem1,
-        OutDone,
-        OutDone1,
-        OutDone2 | OutDone3
-      >;
-
-      const handleSide =
-        <Err, Done, Err2, Done2>(
-          exit: Exit<Err, Either<Done, OutElem | OutElem1>>,
-          fiber: Fiber<Err2, Either<Done2, OutElem | OutElem1>>,
-          pull: IO<Env | Env1 | Env2 | Env3, Err, Either<Done, OutElem | OutElem1>>,
-        ) =>
-        (
-          done: (
-            ex: Exit<Err, Done>,
-          ) => MergeDecision<Env | Env1 | Env2 | Env3, Err2, Done2, OutErr2 | OutErr3, OutDone2 | OutDone3>,
-          both: (
-            f1: Fiber<Err, Either<Done, OutElem | OutElem1>>,
-            f2: Fiber<Err2, Either<Done2, OutElem | OutElem1>>,
-          ) => LocalMergeState,
-          single: (
-            f: (ex: Exit<Err2, Done2>) => IO<Env | Env1 | Env2 | Env3, OutErr2 | OutErr3, OutDone2 | OutDone3>,
-          ) => LocalMergeState,
-        ): IO<
+) {
+  return <Env, InErr, InElem, InDone, OutElem>(
+    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): Channel<
+    Env | Env1 | Env2 | Env3,
+    InErr & InErr1,
+    InElem & InElem1,
+    InDone & InDone1,
+    OutErr2 | OutErr3,
+    OutElem | OutElem1,
+    OutDone2 | OutDone3
+  > => {
+    return Channel.unwrapScoped(
+      Do((_) => {
+        const input       = _(SingleProducerAsyncInput<InErr & InErr1, InElem & InElem1, InDone & InDone1>());
+        const queueReader = Channel.fromInput(input);
+        const pullL       = _(queueReader.pipeTo(self).toPull);
+        const pullR       = _(queueReader.pipeTo(that).toPull);
+        type LocalMergeState = MergeState<
           Env | Env1 | Env2 | Env3,
-          never,
-          Channel<
+          OutErr,
+          OutErr1,
+          OutErr2 | OutErr3,
+          OutElem | OutElem1,
+          OutDone,
+          OutDone1,
+          OutDone2 | OutDone3
+        >;
+        const handleSide =
+          <Err, Done, Err2, Done2>(
+            exit: Exit<Err, Either<Done, OutElem | OutElem1>>,
+            fiber: Fiber<Err2, Either<Done2, OutElem | OutElem1>>,
+            pull: IO<Env | Env1 | Env2 | Env3, Err, Either<Done, OutElem | OutElem1>>,
+          ) =>
+          (
+            done: (
+              ex: Exit<Err, Done>,
+            ) => MergeDecision<Env | Env1 | Env2 | Env3, Err2, Done2, OutErr2 | OutErr3, OutDone2 | OutDone3>,
+            both: (
+              f1: Fiber<Err, Either<Done, OutElem | OutElem1>>,
+              f2: Fiber<Err2, Either<Done2, OutElem | OutElem1>>,
+            ) => LocalMergeState,
+            single: (
+              f: (ex: Exit<Err2, Done2>) => IO<Env | Env1 | Env2 | Env3, OutErr2 | OutErr3, OutDone2 | OutDone3>,
+            ) => LocalMergeState,
+          ): IO<
             Env | Env1 | Env2 | Env3,
-            unknown,
-            unknown,
-            unknown,
-            OutErr2 | OutErr3,
-            OutElem | OutElem1,
-            OutDone2 | OutDone3
-          >
+            never,
+            Channel<
+              Env | Env1 | Env2 | Env3,
+              unknown,
+              unknown,
+              unknown,
+              OutErr2 | OutErr3,
+              OutElem | OutElem1,
+              OutDone2 | OutDone3
+            >
+          > => {
+            const onDecision = (
+              decision: MergeDecision<Env | Env1 | Env2 | Env3, Err2, Done2, OutErr2 | OutErr3, OutDone2 | OutDone3>,
+            ) => {
+              decision.concrete();
+              switch (decision._tag) {
+                case MergeDecisionTag.Done:
+                  return IO.succeedNow(Channel.fromIO(fiber.interrupt.apSecond(decision.io)));
+                case MergeDecisionTag.Await:
+                  return fiber.await.map((ex) =>
+                    ex.match(
+                      (cause) => Channel.fromIO(decision.f(Exit.failCause(cause))),
+                      (r) =>
+                        r.match(
+                          (done) => Channel.fromIO(decision.f(Exit.succeed(done))),
+                          (elem) => Channel.writeNow(elem).apSecond(go(single(decision.f))),
+                        ),
+                    ),
+                  );
+              }
+            };
+            return exit.match(
+              (cause) => onDecision(done(Exit.failCause(cause))),
+              (r) =>
+                r.match(
+                  (d) => onDecision(done(Exit.succeed(d))),
+                  (elem) =>
+                    pull.forkDaemon.map((leftFiber) => Channel.writeNow(elem).apSecond(go(both(leftFiber, fiber)))),
+                ),
+            );
+          };
+        const go = (
+          state: LocalMergeState,
+        ): Channel<
+          Env | Env1 | Env2 | Env3,
+          unknown,
+          unknown,
+          unknown,
+          OutErr2 | OutErr3,
+          OutElem | OutElem1,
+          OutDone2 | OutDone3
         > => {
-          const onDecision = (
-            decision: MergeDecision<Env | Env1 | Env2 | Env3, Err2, Done2, OutErr2 | OutErr3, OutDone2 | OutDone3>,
-          ) => {
-            decision.concrete();
-            switch (decision._tag) {
-              case MergeDecisionTag.Done:
-                return IO.succeedNow(Channel.fromIO(fiber.interrupt.apSecond(decision.io)));
-              case MergeDecisionTag.Await:
-                return fiber.await.map((ex) =>
-                  ex.match(
-                    (cause) => Channel.fromIO(decision.f(Exit.failCause(cause))),
+          switch (state._tag) {
+            case MergeStateTag.BothRunning: {
+              const lj: IO<Env2, OutErr, Either<OutDone, OutElem | OutElem1>>   = state.left.join;
+              const rj: IO<Env3, OutErr1, Either<OutDone1, OutElem | OutElem1>> = state.right.join;
+              return Channel.unwrap(
+                lj.raceWith(
+                  rj,
+                  (leftEx, _) =>
+                    handleSide(leftEx, state.right, pullL)(
+                      leftDone,
+                      (l, r) => MergeState.BothRunning(l, r),
+                      (f) => MergeState.LeftDone(f),
+                    ),
+                  (rightEx, _) =>
+                    handleSide(rightEx, state.left, pullR)(
+                      rightDone,
+                      (l, r) => MergeState.BothRunning(r, l),
+                      (f) => MergeState.RightDone(f),
+                    ),
+                ),
+              );
+            }
+            case MergeStateTag.LeftDone:
+              return Channel.unwrap(
+                pullR.result.map((exit) =>
+                  exit.match(
+                    (cause) => Channel.fromIO(state.f(Exit.failCause(cause))),
                     (r) =>
                       r.match(
-                        (done) => Channel.fromIO(decision.f(Exit.succeed(done))),
-                        (elem) => Channel.writeNow(elem).apSecond(go(single(decision.f))),
+                        (d) => Channel.fromIO(state.f(Exit.succeed(d))),
+                        (elem) => Channel.writeNow(elem).apSecond(go(MergeState.LeftDone(state.f))),
                       ),
                   ),
-                );
-            }
-          };
-          return exit.match(
-            (cause) => onDecision(done(Exit.failCause(cause))),
-            (r) =>
-              r.match(
-                (d) => onDecision(done(Exit.succeed(d))),
-                (elem) =>
-                  pull.forkDaemon.map((leftFiber) => Channel.writeNow(elem).apSecond(go(both(leftFiber, fiber)))),
-              ),
-          );
-        };
-
-      const go = (
-        state: LocalMergeState,
-      ): Channel<
-        Env | Env1 | Env2 | Env3,
-        unknown,
-        unknown,
-        unknown,
-        OutErr2 | OutErr3,
-        OutElem | OutElem1,
-        OutDone2 | OutDone3
-      > => {
-        switch (state._tag) {
-          case MergeStateTag.BothRunning: {
-            const lj: IO<Env2, OutErr, Either<OutDone, OutElem | OutElem1>>   = state.left.join;
-            const rj: IO<Env3, OutErr1, Either<OutDone1, OutElem | OutElem1>> = state.right.join;
-            return Channel.unwrap(
-              lj.raceWith(
-                rj,
-                (leftEx, _) =>
-                  handleSide(leftEx, state.right, pullL)(
-                    leftDone,
-                    (l, r) => MergeState.BothRunning(l, r),
-                    (f) => MergeState.LeftDone(f),
-                  ),
-                (rightEx, _) =>
-                  handleSide(rightEx, state.left, pullR)(
-                    rightDone,
-                    (l, r) => MergeState.BothRunning(r, l),
-                    (f) => MergeState.RightDone(f),
-                  ),
-              ),
-            );
-          }
-          case MergeStateTag.LeftDone:
-            return Channel.unwrap(
-              pullR.result.map((exit) =>
-                exit.match(
-                  (cause) => Channel.fromIO(state.f(Exit.failCause(cause))),
-                  (r) =>
-                    r.match(
-                      (d) => Channel.fromIO(state.f(Exit.succeed(d))),
-                      (elem) => Channel.writeNow(elem).apSecond(go(MergeState.LeftDone(state.f))),
-                    ),
                 ),
-              ),
-            );
-          case MergeStateTag.RightDone:
-            return Channel.unwrap(
-              pullL.result.map((exit) =>
-                exit.match(
-                  (cause) => Channel.fromIO(state.f(Exit.failCause(cause))),
-                  (r) =>
-                    r.match(
-                      (d) => Channel.fromIO(state.f(Exit.succeed(d))),
-                      (elem) => Channel.writeNow(elem).apSecond(go(MergeState.RightDone(state.f))),
-                    ),
+              );
+            case MergeStateTag.RightDone:
+              return Channel.unwrap(
+                pullL.result.map((exit) =>
+                  exit.match(
+                    (cause) => Channel.fromIO(state.f(Exit.failCause(cause))),
+                    (r) =>
+                      r.match(
+                        (d) => Channel.fromIO(state.f(Exit.succeed(d))),
+                        (elem) => Channel.writeNow(elem).apSecond(go(MergeState.RightDone(state.f))),
+                      ),
+                  ),
                 ),
-              ),
-            );
-        }
-      };
-      return Channel.fromIO(
-        pullL.forkDaemon.zipWith(pullR.forkDaemon, (a, b) =>
-          MergeState.BothRunning<unknown, OutErr, OutErr1, unknown, OutElem | OutElem1, OutDone, OutDone1, unknown>(
-            a,
-            b,
+              );
+          }
+        };
+        return Channel.fromIO(
+          pullL.forkDaemon.zipWith(pullR.forkDaemon, (a, b) =>
+            MergeState.BothRunning<unknown, OutErr, OutErr1, unknown, OutElem | OutElem1, OutDone, OutDone1, unknown>(
+              a,
+              b,
+            ),
           ),
-        ),
-      )
-        .flatMap(go)
-        .embedInput(input);
-    }),
-  );
+        )
+          .flatMap(go)
+          .embedInput(input);
+      }),
+    );
+  };
 }

package/_src/Channel/api/toPull.ts

@@ -14,7 +14,7 @@ export function toPull<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
 ): IO<Env | Scope, never, IO<Env, OutErr, Either<OutDone, OutElem>>> {
   return IO.acquireReleaseExit(
     IO.succeed(new ChannelExecutor(() => self, null, identity)),
-    (exec, exit) => exec.close(exit) || IO.unit,
+    (exec, exit) => exec.close(exit) ?? IO.unit,
   ).map((exec) => IO.defer(toPullInterpret(exec.run(), exec)));
 }