@fncts/io 0.0.38 → 0.0.39

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;
 }
 
 /**

package/_src/Channel/core-api.ts

@@ -1,6 +1,6 @@
 import { tuple } from "@fncts/base/data/function";
 
-import { ContinuationK, Done, Fail, Fold } from "./definition.js";
+import { ChannelPrimitive, ChannelTag, ContinuationK, Done, Fail, Fold } from "./definition.js";
 
 /**
  * Halt a channel with the specified cause
@@ -8,7 +8,9 @@ import { ContinuationK, Done, Fail, Fold } from "./definition.js";
  * @tsplus static fncts.io.ChannelOps failCause
  */
 export function failCause<E>(result: Lazy<Cause<E>>): Channel<never, unknown, unknown, unknown, E, never, never> {
-  return new Fail(result);
+  const op = new ChannelPrimitive(ChannelTag.Halt);
+  op.i0    = result;
+  return op as any;
 }
 
 /**
@@ -26,7 +28,9 @@ export function failCauseNow<E>(result: Cause<E>): Channel<never, unknown, unkno
  * @tsplus static fncts.io.ChannelOps end
  */
 export function end<OutDone>(result: Lazy<OutDone>): Channel<never, unknown, unknown, unknown, never, never, OutDone> {
-  return new Done(result);
+  const op = new ChannelPrimitive(ChannelTag.Done);
+  op.i0    = result;
+  return op as any;
 }
 
 /**
@@ -93,17 +97,16 @@ export function flatMap<OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutEle
     OutElem | OutElem1,
     OutDone2
   > => {
-    return new Fold<
-      Env | Env1,
-      InErr & InErr1,
-      InElem & InElem1,
-      InDone & InDone1,
-      OutErr | OutErr1,
-      OutErr | OutErr1,
-      OutElem | OutElem1,
-      OutDone,
-      OutDone2
-    >(channel, new ContinuationK(f, Channel.failCauseNow));
+    const op = new ChannelPrimitive(ChannelTag.Fold);
+
+    const continuation = new ChannelPrimitive(ChannelTag.ContinuationK);
+    continuation.i0    = f;
+    continuation.i1    = Channel.failCauseNow;
+
+    op.i0 = channel;
+    op.i1 = continuation;
+
+    return op as any;
   };
 }