@fncts/io 0.0.38 → 0.0.40

package/_src/Cached.ts

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

package/_src/Channel/ChildExecutorDecision.ts

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

package/_src/Channel/UpstreamPullRequest.ts

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

package/_src/Channel/UpstreamPullStrategy.ts

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

package/_src/Channel/api/mapOutConcurrentIO.ts

@@ -25,12 +25,12 @@ export function mapOutConcurrentIO<OutElem, Env1, OutErr1, OutElem1>(
             pull.matchCauseIO(
               (cause) => queue.offer(IO.failCauseNow(cause)),
               (r) =>
-                r.match(
-                  (outDone) =>
+                r.match({
+                  Left: (outDone) =>
                     permits
                       .withPermits(n)(IO.unit)
                       .interruptible.zipRight(queue.offer(IO.succeedNow(Either.left(outDone)))).asUnit,
-                  (outElem) =>
+                  Right: (outElem) =>
                     Do((Δ) => {
                       const p     = Δ(Future.make<OutErr1, OutElem1>());
                       const latch = Δ(Future.make<never, void>());
@@ -47,7 +47,7 @@ export function mapOutConcurrentIO<OutElem, Env1, OutErr1, OutElem1>(
                       );
                       Δ(latch.await);
                     }),
-                ),
+                }),
             ).forever.uninterruptible.fork,
           );
           return queue;
@@ -56,7 +56,7 @@ export function mapOutConcurrentIO<OutElem, Env1, OutErr1, OutElem1>(
         const consumer: Channel<Env | Env1, unknown, unknown, unknown, OutErr | OutErr1, OutElem1, OutDone> =
           Channel.unwrap(
             queue.take.flatten.matchCause(Channel.failCauseNow, (r) =>
-              r.match(Channel.endNow, (outElem) => Channel.writeNow(outElem).zipRight(consumer)),
+              r.match({ Left: Channel.endNow, Right: (outElem) => Channel.writeNow(outElem).zipRight(consumer) }),
             ),
           );
         return consumer;

package/_src/Channel/api/mergeAllWith.ts

@@ -40,10 +40,10 @@ export function mergeAllWith<OutDone>(
           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()),
-                ),
+                ea.match({
+                  Left: (outDone) => IO.succeedNow(Just(outDone)),
+                  Right: (outElem) => queue.offer(IO.succeedNow(Either.right(outElem))).as(Nothing()),
+                }),
               )
               .repeatUntil((m) => m.isJust())
               .flatMap((md1) =>
@@ -64,8 +64,8 @@ export function mergeAllWith<OutDone>(
                 (cause) =>
                   getChildren.flatMap(Fiber.interruptAll).zipRight(queue.offer(IO.failCauseNow(cause)).as(false)),
                 (doneOrChannel) =>
-                  doneOrChannel.match(
-                    (outDone) =>
+                  doneOrChannel.match({
+                    Left: (outDone) =>
                       errorSignal.await.raceWith(
                         permits.withPermits(n)(IO.unit),
                         (_, permitAcquisition) =>
@@ -82,7 +82,7 @@ export function mergeAllWith<OutDone>(
                               .as(false),
                           ),
                       ),
-                    (channel) => {
+                    Right: (channel) => {
                       switch (mergeStrategy) {
                         case "BackPressure":
                           return Do((Δ) => {
@@ -109,7 +109,7 @@ export function mergeAllWith<OutDone>(
                           });
                       }
                     },
-                  ),
+                  }),
               )
               .repeatWhile(identity).fork,
           );
@@ -119,7 +119,7 @@ export function mergeAllWith<OutDone>(
         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).zipRight(consumer)),
+              out.match({ Left: Channel.endNow, Right: (outElem) => Channel.writeNow(outElem).zipRight(consumer) }),
             ),
           );
         return consumer;

package/_src/Channel/api/mergeWith.ts

@@ -101,10 +101,10 @@ export function mergeWith<
                     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).zipRight(go(single(decision.f))),
-                        ),
+                        r.match({
+                          Left: (done) => Channel.fromIO(decision.f(Exit.succeed(done))),
+                          Right: (elem) => Channel.writeNow(elem).zipRight(go(single(decision.f))),
+                        }),
                     ),
                   );
               }
@@ -112,11 +112,11 @@ export function mergeWith<
             return exit.match(
               (cause) => onDecision(done(Exit.failCause(cause))),
               (r) =>
-                r.match(
-                  (d) => onDecision(done(Exit.succeed(d))),
-                  (elem) =>
+                r.match({
+                  Left: (d) => onDecision(done(Exit.succeed(d))),
+                  Right: (elem) =>
                     pull.forkDaemon.map((leftFiber) => Channel.writeNow(elem).zipRight(go(both(leftFiber, fiber)))),
-                ),
+                }),
             );
           };
         const go = (
@@ -158,10 +158,10 @@ export function mergeWith<
                   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).zipRight(go(MergeState.LeftDone(state.f))),
-                      ),
+                      r.match({
+                        Left: (d) => Channel.fromIO(state.f(Exit.succeed(d))),
+                        Right: (elem) => Channel.writeNow(elem).zipRight(go(MergeState.LeftDone(state.f))),
+                      }),
                   ),
                 ),
               );
@@ -171,10 +171,10 @@ export function mergeWith<
                   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).zipRight(go(MergeState.RightDone(state.f))),
-                      ),
+                      r.match({
+                        Left: (d) => Channel.fromIO(state.f(Exit.succeed(d))),
+                        Right: (elem) => Channel.writeNow(elem).zipRight(go(MergeState.RightDone(state.f))),
+                      }),
                   ),
                 ),
               );

package/_src/Channel/api.ts

@@ -8,6 +8,8 @@ import {
   BracketOut,
   Bridge,
   Channel,
+  ChannelPrimitive,
+  ChannelTag,
   ConcatAll,
   ContinuationK,
   Defer,
@@ -101,7 +103,10 @@ export function acquireReleaseOutExitWith<R, R2, E, Z>(
   self: IO<R, E, Z>,
   release: (z: Z, e: Exit<unknown, unknown>) => URIO<R2, unknown>,
 ): Channel<R | R2, unknown, unknown, unknown, E, Z, void> {
-  return new BracketOut<R | R2, E, Z, void>(self, release);
+  const op = new ChannelPrimitive(ChannelTag.BracketOut);
+  op.i0    = self;
+  op.i1    = release;
+  return op as any;
 }
 
 /**
@@ -165,10 +170,10 @@ export function catchAll<Env1, InErr1, InElem1, InDone1, OutErr, OutErr1, OutEle
     OutDone | OutDone1
   > => {
     return self.catchAllCause((cause) =>
-      cause.failureOrCause.match(
-        (l) => f(l),
-        (r) => Channel.failCauseNow(r),
-      ),
+      cause.failureOrCause.match({
+        Left: (l) => f(l),
+        Right: (r) => Channel.failCauseNow(r),
+      }),
     );
   };
 }
@@ -194,17 +199,16 @@ export function catchAllCause<Env1, InErr1, InElem1, InDone1, OutErr, OutErr1, O
     OutElem | OutElem1,
     OutDone | OutDone1
   > => {
-    return new Fold<
-      Env | Env1,
-      InErr & InErr1,
-      InElem & InElem1,
-      InDone & InDone1,
-      OutErr,
-      OutErr1,
-      OutElem | OutElem1,
-      OutDone | OutDone1,
-      OutDone | OutDone1
-    >(self, new ContinuationK((_) => Channel.endNow(_), f));
+    const op           = new ChannelPrimitive(ChannelTag.Fold);
+    const continuation = new ChannelPrimitive(ChannelTag.ContinuationK);
+
+    continuation.i0 = Channel.endNow;
+    continuation.i1 = f;
+
+    op.i0 = self;
+    op.i1 = continuation;
+
+    return op as any;
   };
 }
 
@@ -254,25 +258,14 @@ export function concatMapWith<OutElem, OutElem2, OutDone, OutDone2, OutDone3, En
   return <Env, InErr, InElem, InDone, OutErr>(
     channel: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>,
   ): Channel<Env | Env2, InErr & InErr2, InElem & InElem2, InDone & InDone2, OutErr | OutErr2, OutElem2, OutDone3> => {
-    return new ConcatAll<
-      Env | Env2,
-      InErr & InErr2,
-      InElem & InElem2,
-      InDone & InDone2,
-      OutErr | OutErr2,
-      OutElem,
-      OutElem2,
-      OutDone,
-      OutDone2,
-      OutDone3
-    >(
-      g,
-      h,
-      () => UpstreamPullStrategy.PullAfterNext(Nothing()),
-      () => ChildExecutorDecision.Continue,
-      channel,
-      f,
-    );
+    const op = new ChannelPrimitive(ChannelTag.ConcatAll);
+    op.i0    = g;
+    op.i1    = h;
+    op.i2    = () => UpstreamPullStrategy.PullAfterNext(Nothing());
+    op.i3    = () => ChildExecutorDecision.Continue;
+    op.i4    = channel;
+    op.i5    = f;
+    return op as any;
   };
 }
 
@@ -306,18 +299,14 @@ export function concatMapWithCustom<
   return <Env, InErr, InElem, InDone, OutErr>(
     channel: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>,
   ): Channel<Env | Env2, InErr & InErr2, InElem & InElem2, InDone & InDone2, OutErr | OutErr2, OutElem2, OutDone3> => {
-    return new ConcatAll<
-      Env | Env2,
-      InErr & InErr2,
-      InElem & InElem2,
-      InDone & InDone2,
-      OutErr | OutErr2,
-      OutElem,
-      OutElem2,
-      OutDone,
-      OutDone2,
-      OutDone3
-    >(g, h, onPull, onEmit, channel, f);
+    const op = new ChannelPrimitive(ChannelTag.ConcatAll);
+    op.i0    = g;
+    op.i1    = h;
+    op.i2    = onPull;
+    op.i3    = onEmit;
+    op.i4    = channel;
+    op.i5    = f;
+    return op as any;
   };
 }
 
@@ -341,25 +330,14 @@ export function concatAllWith<OutDone, OutDone2, OutDone3>(
       OutDone2
     >,
   ): Channel<Env | Env2, InErr & InErr2, InElem & InElem2, InDone & InDone2, OutErr | OutErr2, OutElem, OutDone3> => {
-    return new ConcatAll<
-      Env | Env2,
-      InErr & InErr2,
-      InElem & InElem2,
-      InDone & InDone2,
-      OutErr | OutErr2,
-      Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem, OutDone>,
-      OutElem,
-      OutDone,
-      OutDone2,
-      OutDone3
-    >(
-      f,
-      g,
-      () => UpstreamPullStrategy.PullAfterNext(Nothing()),
-      () => ChildExecutorDecision.Continue,
-      channels,
-      identity,
-    );
+    const op = new ChannelPrimitive(ChannelTag.ConcatAll);
+    op.i0    = f;
+    op.i1    = g;
+    op.i2    = () => UpstreamPullStrategy.PullAfterNext(Nothing());
+    op.i3    = () => ChildExecutorDecision.Continue;
+    op.i4    = channels;
+    op.i5    = identity;
+    return op as any;
   };
 }
 
@@ -473,7 +451,9 @@ export function contramapInIO<Env1, InErr, InElem0, InElem>(f: (a: InElem0) => I
 export function defer<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
   effect: Lazy<Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>>,
 ): Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
-  return new Defer(effect);
+  const op = new ChannelPrimitive(ChannelTag.Defer);
+  op.i0    = effect;
+  return op as any;
 }
 
 function doneCollectReader<OutErr, OutElem, OutDone>(
@@ -562,7 +542,10 @@ export function ensuringWith<Env2, OutErr, OutDone>(finalizer: (e: Exit<OutErr,
   return <Env, InErr, InElem, InDone, OutElem>(
     channel: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
   ): Channel<Env | Env2, InErr, InElem, InDone, OutErr, OutElem, OutDone> => {
-    return new Ensuring<Env | Env2, InErr, InElem, InDone, OutErr, OutElem, OutDone>(channel, finalizer);
+    const op = new ChannelPrimitive(ChannelTag.Ensuring);
+    op.i0    = channel;
+    op.i1    = finalizer;
+    return op as any;
   };
 }
 
@@ -575,7 +558,10 @@ export function embedInput<InErr, InElem, InDone>(input: AsyncInputProducer<InEr
   return <Env, OutErr, OutElem, OutDone>(
     self: Channel<Env, unknown, unknown, unknown, OutErr, OutElem, OutDone>,
   ): Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> => {
-    return new Bridge(input, self);
+    const op = new ChannelPrimitive(ChannelTag.Bridge);
+    op.i0    = input;
+    op.i1    = self;
+    return op as any;
   };
 }
 
@@ -585,7 +571,9 @@ export function embedInput<InErr, InElem, InDone>(input: AsyncInputProducer<InEr
  * @tsplus static fncts.io.ChannelOps fail
  */
 export function fail<E>(error: Lazy<E>): Channel<never, unknown, unknown, unknown, E, never, never> {
-  return new Fail(() => Cause.fail(error()));
+  const op = new ChannelPrimitive(ChannelTag.Halt);
+  op.i0    = () => Cause.fail(error());
+  return op as any;
 }
 
 /**
@@ -594,7 +582,9 @@ export function fail<E>(error: Lazy<E>): Channel<never, unknown, unknown, unknow
  * @tsplus static fncts.io.ChannelOps failNow
  */
 export function failNow<E>(error: E): Channel<never, unknown, unknown, unknown, E, never, never> {
-  return new Fail(() => Cause.fail(error));
+  const op = new ChannelPrimitive(ChannelTag.Halt);
+  op.i0    = () => Cause.fail(error);
+  return op as any;
 }
 
 /**
@@ -643,7 +633,7 @@ export function flatten<
  * @tsplus static fncts.io.ChannelOps fromEither
  */
 export function fromEither<E, A>(either: Lazy<Either<E, A>>): Channel<never, unknown, unknown, unknown, E, never, A> {
-  return Channel.defer(either().match(Channel.failNow, Channel.succeedNow));
+  return Channel.defer(either().match({ Left: Channel.failNow, Right: Channel.succeedNow }));
 }
 
 /**
@@ -663,7 +653,11 @@ export function fromInput<Err, Elem, Done>(
  * @tsplus static fncts.io.ChannelOps fromIO
  */
 export function fromIO<R, E, A>(io: Lazy<IO<R, E, A>>): Channel<R, unknown, unknown, unknown, E, never, A> {
-  return Channel.defer(new FromIO(io()));
+  return Channel.defer(() => {
+    const op = new ChannelPrimitive(ChannelTag.FromIO) as any;
+    op.i0    = io();
+    return op;
+  });
 }
 
 /**
@@ -680,10 +674,10 @@ export function fromQueue<Err, Elem, Done>(
   queue: Queue.Dequeue<Either<Exit<Err, Done>, Elem>>,
 ): Channel<never, unknown, unknown, unknown, Err, Elem, Done> {
   return Channel.fromIO(queue.take).flatMap((_) =>
-    _.match(
-      (_) => _.match(Channel.failCauseNow, Channel.endNow),
-      (elem) => Channel.writeNow(elem).zipRight(Channel.fromQueue(queue)),
-    ),
+    _.match({
+      Left: (_) => _.match(Channel.failCauseNow, Channel.endNow),
+      Right: (elem) => Channel.writeNow(elem).zipRight(Channel.fromQueue(queue)),
+    }),
   );
 }
 
@@ -697,7 +691,12 @@ export function provideEnvironment<Env>(env: Lazy<Environment<Env>>) {
   return <InErr, InElem, InDone, OutErr, OutElem, OutDone>(
     self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
   ): Channel<never, InErr, InElem, InDone, OutErr, OutElem, OutDone> => {
-    return Channel.defer(new Provide(env(), self));
+    return Channel.defer(() => {
+      const op = new ChannelPrimitive(ChannelTag.Provide);
+      op.i0    = env();
+      op.i1    = self;
+      return op as any;
+    });
   };
 }
 
@@ -718,7 +717,9 @@ export function contramapEnvironment<Env, Env0>(f: (env0: Environment<Env0>) =>
  * @tsplus static fncts.io.ChannelOps haltNow
  */
 export function haltNow(defect: unknown): Channel<never, unknown, unknown, unknown, never, never, never> {
-  return new Fail(() => Cause.halt(defect));
+  const op = new ChannelPrimitive(ChannelTag.Halt);
+  op.i0    = () => Cause.halt(defect);
+  return op as any;
 }
 
 /**
@@ -727,7 +728,9 @@ export function haltNow(defect: unknown): Channel<never, unknown, unknown, unkno
  * @tsplus static fncts.io.ChannelOps halt
  */
 export function halt(defect: Lazy<unknown>): Channel<never, unknown, unknown, unknown, never, never, never> {
-  return new Fail(() => Cause.halt(defect()));
+  const op = new ChannelPrimitive(ChannelTag.Halt);
+  op.i0    = () => Cause.halt(defect());
+  return op as any;
 }
 
 /**
@@ -881,30 +884,16 @@ export function matchCauseChannel<
     OutElem | OutElem1 | OutElem2,
     OutDone2 | OutDone3
   > => {
-    return new Fold<
-      Env | Env1 | Env2,
-      InErr & InErr1 & InErr2,
-      InElem & InElem1 & InElem2,
-      InDone & InDone1 & InDone2,
-      OutErr,
-      OutErr2 | OutErr3,
-      OutElem | OutElem1 | OutElem2,
-      OutDone,
-      OutDone2 | OutDone3
-    >(
-      channel,
-      new ContinuationK<
-        Env | Env1 | Env2,
-        InErr & InErr1 & InErr2,
-        InElem & InElem1 & InElem2,
-        InDone & InDone1 & InDone2,
-        OutErr,
-        OutErr2 | OutErr3,
-        OutElem | OutElem1 | OutElem2,
-        OutDone,
-        OutDone2 | OutDone3
-      >(onSuccess, onError),
-    );
+    const op = new ChannelPrimitive(ChannelTag.Fold);
+    op.i0    = channel;
+
+    const continuation = new ChannelPrimitive(ChannelTag.ContinuationK);
+    continuation.i0    = onSuccess;
+    continuation.i1    = onError;
+
+    op.i1 = continuation;
+
+    return op as any;
   };
 }
 
@@ -945,7 +934,10 @@ export function matchChannel<
     OutElem | OutElem1 | OutElem2,
     OutDone2 | OutDone3
   > => {
-    return channel.matchCauseChannel((cause) => cause.failureOrCause.match(onError, Channel.failCauseNow), onSuccess);
+    return channel.matchCauseChannel(
+      (cause) => cause.failureOrCause.match({ Left: onError, Right: Channel.failCauseNow }),
+      onSuccess,
+    );
   };
 }
 
@@ -1009,10 +1001,10 @@ export function pipeTo<OutErr, OutElem, OutDone, Env1, OutErr1, OutElem1, OutDon
   return <Env, InErr, InElem, InDone>(
     left: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
   ): Channel<Env | Env1, InErr, InElem, InDone, OutErr1, OutElem1, OutDone1> => {
-    return new PipeTo<Env | Env1, InErr, InElem, InDone, OutErr, OutErr1, OutElem, OutElem1, OutDone, OutDone1>(
-      () => left,
-      () => right,
-    );
+    const op = new ChannelPrimitive(ChannelTag.PipeTo);
+    op.i0    = () => left;
+    op.i1    = () => right;
+    return op as any;
   };
 }
 
@@ -1058,13 +1050,16 @@ export function read<In>(): Channel<never, unknown, In, unknown, Nothing, never,
  * @tsplus static fncts.io.ChannelOps readOrFail
  */
 export function readOrFail<In, E>(e: E): Channel<never, unknown, In, unknown, E, never, In> {
-  return new Read<never, unknown, In, unknown, never, E, never, never, In>(
-    Channel.endNow,
-    new ContinuationK(
-      () => Channel.failNow(e),
-      () => Channel.failNow(e),
-    ),
-  );
+  const op = new ChannelPrimitive(ChannelTag.Read);
+  op.i0    = Channel.endNow;
+
+  const continuation = new ChannelPrimitive(ChannelTag.ContinuationK);
+  continuation.i0    = () => Channel.failNow(e);
+  continuation.i1    = () => Channel.failNow(e);
+
+  op.i1 = continuation;
+
+  return op as any;
 }
 
 /**
@@ -1101,30 +1096,16 @@ export function readWithCause<
   OutElem | OutElem1 | OutElem2,
   OutDone | OutDone1 | OutDone2
 > {
-  return new Read<
-    Env | Env1 | Env2,
-    InErr,
-    InElem,
-    InDone,
-    InErr,
-    OutErr | OutErr1 | OutErr2,
-    OutElem | OutElem1 | OutElem2,
-    InDone,
-    OutDone | OutDone1 | OutDone2
-  >(
-    inp,
-    new ContinuationK<
-      Env | Env1 | Env2,
-      InErr,
-      InElem,
-      InDone,
-      InErr,
-      OutErr | OutErr1 | OutErr2,
-      OutElem | OutElem1 | OutElem2,
-      InDone,
-      OutDone | OutDone1 | OutDone2
-    >(done, halt),
-  );
+  const op = new ChannelPrimitive(ChannelTag.Read);
+  op.i0    = inp;
+
+  const continuation = new ChannelPrimitive(ChannelTag.ContinuationK);
+  continuation.i0    = done;
+  continuation.i1    = halt;
+
+  op.i1 = continuation;
+
+  return op as any;
 }
 
 /**
@@ -1161,7 +1142,7 @@ export function readWith<
   OutElem | OutElem1 | OutElem2,
   OutDone | OutDone1 | OutDone2
 > {
-  return Channel.readWithCause(inp, (c) => c.failureOrCause.match(error, Channel.failCauseNow), done);
+  return Channel.readWithCause(inp, (c) => c.failureOrCause.match({ Left: error, Right: Channel.failCauseNow }), done);
 }
 
 /**
@@ -1201,7 +1182,9 @@ export function toQueue<Err, Done, Elem>(
  * @tsplus static fncts.io.ChannelOps write
  */
 export function write<OutElem>(out: Lazy<OutElem>): Channel<never, unknown, unknown, unknown, never, OutElem, void> {
-  return new Emit(out);
+  const op = new ChannelPrimitive(ChannelTag.Emit);
+  op.i0    = out;
+  return op as any;
 }
 
 /**
@@ -1233,7 +1216,9 @@ export function writeChunk<Out>(outs: Conc<Out>): Channel<never, unknown, unknow
  * @tsplus static fncts.io.ChannelOps writeNow
  */
 export function writeNow<OutElem>(out: OutElem): Channel<never, unknown, unknown, unknown, never, OutElem, void> {
-  return new Emit(() => out);
+  const op = new ChannelPrimitive(ChannelTag.Emit);
+  op.i0    = () => out;
+  return op as any;
 }
 
 /**