@fncts/io 0.0.21 → 0.0.23

package/_src/Cached/internal.ts

@@ -1,10 +1,10 @@
+export const CachedVariance = Symbol.for("fncts.io.Cached.Variance");
+export type CachedVariance = typeof CachedVariance;
+
 export const CachedTypeId = Symbol.for("fncts.io.Cached");
 export type CachedTypeId = typeof CachedTypeId;
 
-export abstract class CachedInternal<Error, Resource> {
-  readonly _E!: () => Error;
-  readonly _A!: () => Resource;
-  readonly _typeId: CachedTypeId = CachedTypeId;
+export abstract class CachedInternal<Error, Resource> extends Cached<Error, Resource> {
   abstract get: FIO<Error, Resource>;
   abstract refresh: FIO<Error, void>;
 }

package/_src/Channel/api/{mapOutIOC.ts → mapOutConcurrentIO.ts}

@@ -1,7 +1,10 @@
 /**
- * @tsplus pipeable fncts.io.Channel mapOutIOC
+ * @tsplus pipeable fncts.io.Channel mapOutConcurrentIO
  */
-export function mapOutIOC<OutElem, Env1, OutErr1, OutElem1>(n: number, f: (_: OutElem) => IO<Env1, OutErr1, OutElem1>) {
+export function mapOutConcurrentIO<OutElem, Env1, OutErr1, OutElem1>(
+  n: number,
+  f: (_: OutElem) => IO<Env1, OutErr1, OutElem1>,
+) {
   return <Env, InErr, InElem, InDone, OutErr, OutDone>(
     self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
   ): Channel<Env | Env1, InErr, InElem, InDone, OutErr | OutErr1, OutElem1, OutDone> => {
@@ -26,7 +29,7 @@ export function mapOutIOC<OutElem, Env1, OutErr1, OutElem1>(n: number, f: (_: Ou
                   (outDone) =>
                     permits
                       .withPermits(n)(IO.unit)
-                      .interruptible.apSecond(queue.offer(IO.succeedNow(Either.left(outDone)))).asUnit,
+                      .interruptible.zipRight(queue.offer(IO.succeedNow(Either.left(outDone)))).asUnit,
                   (outElem) =>
                     Do((Δ) => {
                       const p     = Δ(Future.make<OutErr1, OutElem1>());
@@ -34,7 +37,7 @@ export function mapOutIOC<OutElem, Env1, OutErr1, OutElem1>(n: number, f: (_: Ou
                       Δ(queue.offer(p.await.map(Either.right)));
                       Δ(
                         permits.withPermit(
-                          latch.succeed(undefined).apSecond(
+                          latch.succeed(undefined).zipRight(
                             errorSignal.await
                               .raceFirst(f(outElem))
                               .tapErrorCause((c) => p.failCause(c))
@@ -53,7 +56,7 @@ export function mapOutIOC<OutElem, Env1, OutErr1, OutElem1>(n: number, f: (_: Ou
         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).apSecond(consumer)),
+              r.match(Channel.endNow, (outElem) => Channel.writeNow(outElem).zipRight(consumer)),
             ),
           );
         return consumer;

package/_src/Channel/api/mergeAllWith.ts

@@ -62,16 +62,16 @@ export function mergeAllWith<OutDone>(
             pull
               .matchCauseIO(
                 (cause) =>
-                  getChildren.flatMap(Fiber.interruptAll).apSecond(queue.offer(IO.failCauseNow(cause)).as(false)),
+                  getChildren.flatMap(Fiber.interruptAll).zipRight(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)),
+                          getChildren.flatMap(Fiber.interruptAll).zipRight(permitAcquisition.interrupt.as(false)),
                         (_, failureAwait) =>
-                          failureAwait.interrupt.apSecond(
+                          failureAwait.interrupt.zipRight(
                             lastDone.get
                               .flatMap((maybeDone) =>
                                 maybeDone.match(
@@ -90,7 +90,7 @@ export function mergeAllWith<OutDone>(
                             const raceIOs = channel.toPull.flatMap((io) =>
                               evaluatePull(io).race(errorSignal.await),
                             ).scoped;
-                            Δ(permits.withPermit(latch.succeed(undefined).apSecond(raceIOs)).fork);
+                            Δ(permits.withPermit(latch.succeed(undefined).zipRight(raceIOs)).fork);
                             Δ(latch.await);
                             return Δ(errorSignal.isDone.map((b) => !b));
                           });
@@ -103,7 +103,7 @@ export function mergeAllWith<OutDone>(
                             const raceIOs = channel.toPull.flatMap((io) =>
                               evaluatePull(io).race(errorSignal.await).race(canceler.await),
                             ).scoped;
-                            Δ(permits.withPermit(latch.succeed(undefined).apSecond(raceIOs)).fork);
+                            Δ(permits.withPermit(latch.succeed(undefined).zipRight(raceIOs)).fork);
                             Δ(latch.await);
                             return Δ(errorSignal.isDone.map((b) => !b));
                           });
@@ -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).apSecond(consumer)),
+              out.match(Channel.endNow, (outElem) => Channel.writeNow(outElem).zipRight(consumer)),
             ),
           );
         return consumer;

package/_src/Channel/api/mergeWith.ts

@@ -95,7 +95,7 @@ export function mergeWith<
               decision.concrete();
               switch (decision._tag) {
                 case MergeDecisionTag.Done:
-                  return IO.succeedNow(Channel.fromIO(fiber.interrupt.apSecond(decision.io)));
+                  return IO.succeedNow(Channel.fromIO(fiber.interrupt.zipRight(decision.io)));
                 case MergeDecisionTag.Await:
                   return fiber.await.map((ex) =>
                     ex.match(
@@ -103,7 +103,7 @@ export function mergeWith<
                       (r) =>
                         r.match(
                           (done) => Channel.fromIO(decision.f(Exit.succeed(done))),
-                          (elem) => Channel.writeNow(elem).apSecond(go(single(decision.f))),
+                          (elem) => Channel.writeNow(elem).zipRight(go(single(decision.f))),
                         ),
                     ),
                   );
@@ -115,7 +115,7 @@ export function mergeWith<
                 r.match(
                   (d) => onDecision(done(Exit.succeed(d))),
                   (elem) =>
-                    pull.forkDaemon.map((leftFiber) => Channel.writeNow(elem).apSecond(go(both(leftFiber, fiber)))),
+                    pull.forkDaemon.map((leftFiber) => Channel.writeNow(elem).zipRight(go(both(leftFiber, fiber)))),
                 ),
             );
           };
@@ -160,7 +160,7 @@ export function mergeWith<
                     (r) =>
                       r.match(
                         (d) => Channel.fromIO(state.f(Exit.succeed(d))),
-                        (elem) => Channel.writeNow(elem).apSecond(go(MergeState.LeftDone(state.f))),
+                        (elem) => Channel.writeNow(elem).zipRight(go(MergeState.LeftDone(state.f))),
                       ),
                   ),
                 ),
@@ -173,7 +173,7 @@ export function mergeWith<
                     (r) =>
                       r.match(
                         (d) => Channel.fromIO(state.f(Exit.succeed(d))),
-                        (elem) => Channel.writeNow(elem).apSecond(go(MergeState.RightDone(state.f))),
+                        (elem) => Channel.writeNow(elem).zipRight(go(MergeState.RightDone(state.f))),
                       ),
                   ),
                 ),

package/_src/Channel/api/{zipC.ts → zipConcurrent.ts}

@@ -1,9 +1,9 @@
 import { MergeDecision } from "@fncts/io/Channel/internal/MergeDecision";
 
 /**
- * @tsplus pipeable fncts.io.Channel zipC
+ * @tsplus pipeable fncts.io.Channel zipConcurrent
  */
-export function zipC<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
+export function zipConcurrent<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
   that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
 ) {
   return <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
@@ -19,16 +19,16 @@ export function zipC<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1
   > => {
     return self.mergeWith(
       that,
-      (exit1) => MergeDecision.Await((exit2) => IO.fromExit(exit1.zipC(exit2))),
-      (exit2) => MergeDecision.Await((exit1) => IO.fromExit(exit1.zipC(exit2))),
+      (exit1) => MergeDecision.Await((exit2) => IO.fromExit(exit1.zipConcurrent(exit2))),
+      (exit2) => MergeDecision.Await((exit1) => IO.fromExit(exit1.zipConcurrent(exit2))),
     );
   };
 }
 
 /**
- * @tsplus pipeable fncts.io.Channel zipFirstC
+ * @tsplus pipeable fncts.io.Channel zipLeftConcurrent
  */
-export function zipFirstC<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
+export function zipLeftConcurrent<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
   that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
 ) {
   return <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
@@ -42,14 +42,14 @@ export function zipFirstC<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Out
     OutElem | OutElem1,
     OutDone
   > => {
-    return self.zipC(that).map(([d]) => d);
+    return self.zipConcurrent(that).map(([d]) => d);
   };
 }
 
 /**
- * @tsplus pipeable fncts.io.Channel zipSecondC
+ * @tsplus pipeable fncts.io.Channel zipRightConcurrent
  */
-export function zipSecondC<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
+export function zipRightConcurrent<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
   that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
 ) {
   return <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
@@ -63,6 +63,6 @@ export function zipSecondC<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Ou
     OutElem | OutElem1,
     OutDone1
   > => {
-    return self.zipC(that).map(([_, d1]) => d1);
+    return self.zipConcurrent(that).map(([_, d1]) => d1);
   };
 }

package/_src/Channel/api.ts

@@ -83,21 +83,21 @@ export function acquireReleaseExitWith<Env, InErr, InElem, InDone, OutErr, OutEl
 /**
  * Construct a resource Channel with Acquire / Release
  *
- * @tsplus static fncts.io.ChannelOps acquireReleaseOut
+ * @tsplus static fncts.io.ChannelOps acquireReleaseOutWith
  */
-export function acquireReleaseOut<Env, OutErr, Acquired, Z>(
+export function acquireReleaseOutWith<Env, OutErr, Acquired, Z>(
   acquire: IO<Env, OutErr, Acquired>,
   release: (a: Acquired) => URIO<Env, Z>,
 ): Channel<Env, unknown, unknown, unknown, OutErr, Acquired, void> {
-  return Channel.acquireReleaseOutExit(acquire, (z, _) => release(z));
+  return Channel.acquireReleaseOutExitWith(acquire, (z, _) => release(z));
 }
 
 /**
  * Construct a resource Channel with Acquire / Release
  *
- * @tsplus static fncts.io.ChannelOps acquireReleaseOutExit
+ * @tsplus static fncts.io.ChannelOps acquireReleaseOutExitWith
  */
-export function acquireReleaseOutExit<R, R2, E, Z>(
+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> {
@@ -121,14 +121,14 @@ export function buffer<InElem, InErr, InDone>(
       if (isEmpty(v)) {
         return tuple(
           readWith(
-            (_in: InElem) => Channel.writeNow(_in).apSecond(Channel.buffer<InElem, InErr, InDone>(empty, isEmpty, ref)),
+            (_in: InElem) => Channel.writeNow(_in).zipRight(Channel.buffer<InElem, InErr, InDone>(empty, isEmpty, ref)),
             (err: InErr) => Channel.failNow(err),
             (done: InDone) => Channel.endNow(done),
           ),
           v,
         );
       } else {
-        return tuple(Channel.writeNow(v).apSecond(Channel.buffer<InElem, InErr, InDone>(empty, isEmpty, ref)), empty);
+        return tuple(Channel.writeNow(v).zipRight(Channel.buffer<InElem, InErr, InDone>(empty, isEmpty, ref)), empty);
       }
     }),
   );
@@ -388,7 +388,7 @@ function contramapReader<InErr, InElem, InDone0, InDone>(
   f: (a: InDone0) => InDone,
 ): Channel<never, InErr, InElem, InDone0, InErr, InElem, InDone> {
   return readWith(
-    (_in) => Channel.writeNow(_in).apSecond(contramapReader(f)),
+    (_in) => Channel.writeNow(_in).zipRight(contramapReader(f)),
     Channel.failNow,
     (done) => Channel.endNow(f(done)),
   );
@@ -409,7 +409,7 @@ function contramapInReader<InErr, InElem0, InElem, InDone>(
   f: (a: InElem0) => InElem,
 ): Channel<never, InErr, InElem0, InDone, InErr, InElem, InDone> {
   return readWith(
-    (_in) => Channel.writeNow(f(_in)).apSecond(contramapInReader(f)),
+    (_in) => Channel.writeNow(f(_in)).zipRight(contramapInReader(f)),
     Channel.failNow,
     (done) => Channel.endNow(done),
   );
@@ -429,7 +429,7 @@ function contramapIOReader<Env1, InErr, InElem, InDone0, InDone>(
   f: (i: InDone0) => IO<Env1, InErr, InDone>,
 ): Channel<Env1, InErr, InElem, InDone0, InErr, InElem, InDone> {
   return readWith(
-    (_in) => Channel.writeNow(_in).apSecond(contramapIOReader(f)),
+    (_in) => Channel.writeNow(_in).zipRight(contramapIOReader(f)),
     Channel.failNow,
     (done0) => Channel.fromIO(f(done0)),
   );
@@ -450,7 +450,7 @@ function contramapInIOReader<Env1, InErr, InElem0, InElem, InDone>(
   f: (a: InElem0) => IO<Env1, InErr, InElem>,
 ): Channel<Env1, InErr, InElem0, InDone, InErr, InElem, InDone> {
   return Channel.readWith(
-    (inp) => Channel.fromIO(f(inp)).flatMap(Channel.writeNow).apSecond(contramapInIOReader(f)),
+    (inp) => Channel.fromIO(f(inp)).flatMap(Channel.writeNow).zipRight(contramapInIOReader(f)),
     Channel.failNow,
     Channel.endNow,
   );
@@ -485,7 +485,7 @@ function doneCollectReader<OutErr, OutElem, OutDone>(
         IO.succeed(() => {
           builder.append(out);
         }),
-      ).apSecond(doneCollectReader(builder)),
+      ).zipRight(doneCollectReader(builder)),
     Channel.failNow,
     Channel.endNow,
   );
@@ -653,7 +653,7 @@ export function fromInput<Err, Elem, Done>(
   input: AsyncInputConsumer<Err, Elem, Done>,
 ): Channel<never, unknown, unknown, unknown, Err, Elem, Done> {
   return unwrap(
-    input.takeWith(Channel.failCauseNow, (elem) => Channel.writeNow(elem).apSecond(fromInput(input)), Channel.endNow),
+    input.takeWith(Channel.failCauseNow, (elem) => Channel.writeNow(elem).zipRight(fromInput(input)), Channel.endNow),
   );
 }
 
@@ -677,12 +677,12 @@ export function fromOption<A>(option: Lazy<Maybe<A>>): Channel<never, unknown, u
  * @tsplus static fncts.io.ChannelOps fromQueue
  */
 export function fromQueue<Err, Elem, Done>(
-  queue: Dequeue<Either<Exit<Err, Done>, Elem>>,
+  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).apSecond(Channel.fromQueue(queue)),
+      (elem) => Channel.writeNow(elem).zipRight(Channel.fromQueue(queue)),
     ),
   );
 }
@@ -734,7 +734,7 @@ export function halt(defect: Lazy<unknown>): Channel<never, unknown, unknown, un
  * @tsplus static fncts.io.ChannelOps id
  */
 export function id<Err, Elem, Done>(): Channel<never, Err, Elem, Done, Err, Elem, Done> {
-  return Channel.readWith((_in) => write(_in).apSecond(id<Err, Elem, Done>()), Channel.failNow, Channel.endNow);
+  return Channel.readWith((_in) => write(_in).zipRight(id<Err, Elem, Done>()), Channel.failNow, Channel.endNow);
 }
 
 /**
@@ -752,17 +752,16 @@ export function interrupt(fiberId: FiberId): Channel<never, unknown, unknown, un
 export function scoped<R, E, A>(
   io: Lazy<IO<R, E, A>>,
 ): Channel<Exclude<R, Scope>, unknown, unknown, unknown, E, A, unknown> {
-  return Channel.acquireReleaseOutExit(
-    Scope.make.flatMap((scope) =>
-      IO.uninterruptibleMask(({ restore }) =>
-        restore(scope.extend(io)).matchCauseIO(
-          (cause) => scope.close(Exit.failCause(cause)) > IO.failCauseNow(cause),
-          (out) => IO.succeedNow(tuple(out, scope)),
+  return Channel.unwrap(
+    IO.uninterruptibleMask(({ restore }) =>
+      Scope.make.map((scope) =>
+        Channel.acquireReleaseOutExitWith(
+          restore(scope.extend(io)).tapErrorCause((cause) => scope.close(Exit.failCause(cause))),
+          (_, exit) => scope.close(exit),
         ),
       ),
     ),
-    ([_, scope], exit) => scope.close(exit),
-  ).mapOut(([a]) => a);
+  );
 }
 
 /**
@@ -817,7 +816,7 @@ export function mapOut<OutElem, OutElem2>(f: (o: OutElem) => OutElem2) {
     self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
   ): Channel<Env, InErr, InElem, InDone, OutErr, OutElem2, OutDone> => {
     const reader: Channel<Env, OutErr, OutElem, OutDone, OutErr, OutElem2, OutDone> = readWith(
-      (out) => Channel.writeNow(f(out)).apSecond(reader),
+      (out) => Channel.writeNow(f(out)).zipRight(reader),
       Channel.failNow,
       Channel.endNow,
     );
@@ -829,7 +828,7 @@ const mapOutIOReader = <Env, Env1, OutErr, OutErr1, OutElem, OutElem1, OutDone>(
   f: (o: OutElem) => IO<Env1, OutErr1, OutElem1>,
 ): Channel<Env | Env1, OutErr, OutElem, OutDone, OutErr | OutErr1, OutElem1, OutDone> =>
   Channel.readWith(
-    (out) => Channel.fromIO(f(out)).flatMap(Channel.writeNow).apSecond(mapOutIOReader(f)),
+    (out) => Channel.fromIO(f(out)).flatMap(Channel.writeNow).zipRight(mapOutIOReader(f)),
     Channel.failNow,
     Channel.endNow,
   );
@@ -837,7 +836,7 @@ const mapOutIOReader = <Env, Env1, OutErr, OutErr1, OutElem, OutElem1, OutDone>(
 /**
  * @tsplus pipeable fncts.io.Channel mapOutIO
  */
-export function mapOutIO_<Env1, OutErr1, OutElem, OutElem1>(f: (o: OutElem) => IO<Env1, OutErr1, OutElem1>) {
+export function mapOutIO<Env1, OutErr1, OutElem, OutElem1>(f: (o: OutElem) => IO<Env1, OutErr1, OutElem1>) {
   return <Env, InErr, InElem, InDone, OutErr, OutDone>(
     self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
   ): Channel<Env | Env1, InErr, InElem, InDone, OutErr | OutErr1, OutElem1, OutDone> => {
@@ -1019,12 +1018,12 @@ export function pipeTo<OutErr, OutElem, OutDone, Env1, OutErr1, OutElem1, OutDon
 
 const ChannelFailureTypeId = Symbol.for("@principia/base/Channel/ChannelFailure");
 class ChannelFailure<E> {
-  readonly _typeId = ChannelFailureTypeId;
+  readonly [ChannelFailureTypeId] = ChannelFailureTypeId;
   constructor(readonly error: E) {}
 }
 
 function isChannelFailure<E>(u: unknown): u is ChannelFailure<E> {
-  return hasTypeId(u, ChannelFailureTypeId);
+  return isObject(u) && ChannelFailureTypeId in u;
 }
 
 /**
@@ -1179,11 +1178,11 @@ export function repeated<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
  * @tsplus static fncts.io.ChannelOps toQueue
  */
 export function toQueue<Err, Done, Elem>(
-  queue: Lazy<Enqueue<Either<Exit<Err, Done>, Elem>>>,
+  queue: Lazy<Queue.Enqueue<Either<Exit<Err, Done>, Elem>>>,
 ): Channel<never, Err, Elem, Done, never, never, unknown> {
   return Channel.defer(() => {
     function toQueue<Err, Done, Elem>(
-      queue: Enqueue<Either<Exit<Err, Done>, Elem>>,
+      queue: Queue.Enqueue<Either<Exit<Err, Done>, Elem>>,
     ): Channel<never, Err, Elem, Done, never, never, unknown> {
       return Channel.readWithCause(
         (inp) => Channel.fromIO(queue.offer(Either.right(inp))) > toQueue(queue),
@@ -1217,7 +1216,7 @@ function writeChunkWriter<Out>(
   len: number,
 ): Channel<never, unknown, unknown, unknown, never, Out, void> {
   if (idx === len) return Channel.unit;
-  return Channel.writeNow(outs.unsafeGet(idx)).apSecond(writeChunkWriter(outs, idx + 1, len));
+  return Channel.writeNow(outs.unsafeGet(idx)).zipRight(writeChunkWriter(outs, idx + 1, len));
 }
 
 /**

package/_src/Channel/core-api.ts

@@ -135,9 +135,9 @@ export function cross<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone
  * Returns a new channel that is the sequential composition of this channel and the specified
  * channel. The returned channel terminates with the terminal value of this channel.
  *
- * @tsplus pipeable fncts.io.Channel apFirst
+ * @tsplus pipeable fncts.io.Channel zipLeft
  */
-export function apFirst<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
+export function zipLeft<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
   that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
 ) {
   return <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
@@ -159,10 +159,10 @@ export function apFirst<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDo
  * Returns a new channel that is the sequential composition of this channel and the specified
  * channel. The returned channel terminates with the terminal value of the other channel.
  *
- * @tsplus pipeable fncts.io.Channel apSecond
+ * @tsplus pipeable fncts.io.Channel zipRight
  * @tsplus pipeable-operator fncts.io.Channel >
  */
-export function apSecond<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
+export function zipRight<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
   that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
 ) {
   return <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(

package/_src/Channel/definition.ts

@@ -21,18 +21,27 @@ export const enum ChannelTag {
   Provide = "Provide",
 }
 
+export const ChannelVariance = Symbol.for("fncts.io.Channel.Variance");
+export type ChannelVariance = typeof ChannelVariance;
+
+export const ChannelTypeId = Symbol.for("fncts.io.Channel");
+export type ChannelTypeId = typeof ChannelTypeId;
+
 /**
  * @tsplus type fncts.io.Channel
  * @tsplus companion fncts.io.ChannelOps
  */
 export abstract class Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
-  declare _Env: () => Env;
-  declare _InErr: (_: InErr) => void;
-  declare _InElem: (_: InElem) => void;
-  declare _InDone: (_: InDone) => void;
-  declare _OutErr: () => OutErr;
-  declare _OutElem: () => OutElem;
-  declare _OutDone: () => OutDone;
+  readonly [ChannelTypeId]: ChannelTypeId = ChannelTypeId;
+  declare [ChannelVariance]: {
+    _Env: () => Env;
+    _InErr: (_: InErr) => void;
+    _InElem: (_: InElem) => void;
+    _InDone: (_: InDone) => void;
+    _OutErr: () => OutErr;
+    _OutElem: () => OutElem;
+    _OutDone: () => OutDone;
+  };
 }
 
 /**
@@ -43,49 +52,63 @@ export function unifyChannel<X extends Channel<any, any, any, any, any, any, any
 ): Channel<
   [X] extends [
     {
-      _Env: () => infer Env;
+      [ChannelVariance]: {
+        _Env: () => infer Env;
+      };
     },
   ]
     ? Env
     : never,
   [X] extends [
     {
-      _InErr: (_: infer InErr) => void;
+      [ChannelVariance]: {
+        _InErr: (_: infer InErr) => void;
+      };
     },
   ]
     ? InErr
     : never,
   [X] extends [
     {
-      _InElem: (_: infer InElem) => void;
+      [ChannelVariance]: {
+        _InElem: (_: infer InElem) => void;
+      };
     },
   ]
     ? InElem
     : never,
   [X] extends [
     {
-      _InDone: (_: infer InDone) => void;
+      [ChannelVariance]: {
+        _InDone: (_: infer InDone) => void;
+      };
     },
   ]
     ? InDone
     : never,
   [X] extends [
     {
-      _OutErr: () => infer OutErr;
+      [ChannelVariance]: {
+        _OutErr: () => infer OutErr;
+      };
     },
   ]
     ? OutErr
     : never,
   [X] extends [
     {
-      _OutElem: () => infer OutElem;
+      [ChannelVariance]: {
+        _OutElem: () => infer OutElem;
+      };
     },
   ]
     ? OutElem
     : never,
   [X] extends [
     {
-      _OutDone: () => infer OutDone;
+      [ChannelVariance]: {
+        _OutDone: () => infer OutDone;
+      };
     },
   ]
     ? OutDone