@fncts/io 0.0.21 → 0.0.22

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

@@ -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);
 }
 
 /**
@@ -817,7 +817,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 +829,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 +837,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> => {
@@ -1179,11 +1179,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 +1217,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/internal/ChannelExecutor.ts

@@ -60,7 +60,7 @@ class PullFromUpstream<R> {
           if (next === null) {
             return acc;
           } else {
-            return acc.zipWith(next.result, (a, b) => a.apSecond(b));
+            return acc.zipWith(next.result, (a, b) => a.zipRight(b));
           }
         }
       },
@@ -107,7 +107,7 @@ class PullFromChild<R> {
       if (fin2 === null) {
         return fin1;
       } else {
-        return fin1.result.zipWith(fin2.result, (a, b) => a.apSecond(b)).flatMap(IO.fromExitNow);
+        return fin1.result.zipWith(fin2.result, (a, b) => a.zipRight(b)).flatMap(IO.fromExitNow);
       }
     }
   }
@@ -147,7 +147,7 @@ class DrainChildExecutors<R> {
           if (next === null) {
             return acc;
           } else {
-            return acc.zipWith(next.result, (a, b) => a.apSecond(b));
+            return acc.zipWith(next.result, (a, b) => a.zipRight(b));
           }
         }
       },
@@ -299,7 +299,7 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
                 if (this.input !== null) {
                   const inputExecutor = this.input;
                   this.input          = null;
-                  const drainer: URIO<Env, unknown> = currentChannel.input.awaitRead.apSecond(
+                  const drainer: URIO<Env, unknown> = currentChannel.input.awaitRead.zipRight(
                     IO.defer(() => {
                       const state = inputExecutor.run();
 
@@ -332,7 +332,7 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
                     drainer.fork.flatMap((fiber) =>
                       IO.succeed(() => {
                         this.addFinalizer((exit) =>
-                          fiber.interrupt.apSecond(
+                          fiber.interrupt.zipRight(
                             IO.defer(() => {
                               const effect = this.restorePipe(exit, inputExecutor);
                               if (effect !== null) {
@@ -506,7 +506,7 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
         if (head._tag === ChannelTag.ContinuationK) {
           return unwind(acc, conts.unsafeTail);
         } else {
-          return unwind(acc.apSecond(head.finalizer(exit).result), conts.unsafeTail);
+          return unwind(acc.zipRight(head.finalizer(exit).result), conts.unsafeTail);
         }
       }
     };
@@ -574,7 +574,7 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
         this.ifNotNull(runInProgressFinalizers).result,
         this.ifNotNull(closeSelf).result,
       )
-        .map(([a, b, c]) => a.apSecond(b).apSecond(c))
+        .map(([a, b, c]) => a.zipRight(b).zipRight(c))
         .uninterruptible.flatMap(IO.fromExitNow);
     }
   }
@@ -659,13 +659,13 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
       case "PullAfterNext": {
         return [
           strategy.emitSeparator,
-          !upstreamFinished || queue.exists((_) => _ !== null) ? queue.prepend(null) : queue,
+          !upstreamFinished || queue.some((_) => _ !== null) ? queue.prepend(null) : queue,
         ];
       }
       case "PullAfterAllEnqueued": {
         return [
           strategy.emitSeparator,
-          !upstreamFinished || queue.exists((_) => _ !== null) ? queue.enqueue(null) : queue,
+          !upstreamFinished || queue.some((_) => _ !== null) ? queue.enqueue(null) : queue,
         ];
       }
     }
@@ -717,7 +717,7 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
       (effect) => {
         const closeLast         = this.closeLastSubstream === null ? IO.unit : this.closeLastSubstream;
         this.closeLastSubstream = null;
-        return this.executeCloseLastSubstream(closeLast).apSecond(effect);
+        return this.executeCloseLastSubstream(closeLast).zipRight(effect);
       },
       (emitted) => {
         if (this.closeLastSubstream !== null) {
@@ -789,7 +789,7 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
         }
       },
       (exit) => {
-        if (subexec.activeChildExecutors.exists((_) => _ !== null)) {
+        if (subexec.activeChildExecutors.some((_) => _ !== null)) {
           const drain = new DrainChildExecutors(
             subexec.upstreamExecutor,
             subexec.lastDone,

package/_src/Channel/internal/SingleProducerAsyncInput.ts

@@ -153,7 +153,7 @@ export class SingleProducerAsyncInput<Err, Elem, Done>
               return tuple(
                 state.notifyProducer
                   .succeed(undefined)
-                  .apSecond(p.await.matchCause(onError, (de) => de.match(onDone, onElement))),
+                  .zipRight(p.await.matchCause(onError, (de) => de.match(onDone, onElement))),
                 new StateEmit(Queue.single(p)),
               );
             }

package/_src/CountdownLatch.ts

@@ -0,0 +1,39 @@
+export const CountdownLatchTypeId = Symbol.for("fncts.io.CountdownLatch");
+export type CountdownLatchTypeId = typeof CountdownLatchTypeId;
+
+/**
+ * @tsplus type fncts.io.CountdownLatch
+ * @tsplus companion fncts.io.CountdownLatchOps
+ */
+export class CountdownLatch {
+  readonly _typeId: CountdownLatchTypeId = CountdownLatchTypeId;
+  constructor(private _count: Ref<number>, private _waiters: Future<never, void>) {}
+
+  readonly await: UIO<void> = this._waiters.await;
+
+  readonly countDown: UIO<void> = this._count.modify((n) => {
+    if (n === 0) {
+      return [IO.unit, 0];
+    } else if (n === 1) {
+      return [this._waiters.succeed(undefined), 0];
+    } else {
+      return [IO.unit, n - 1];
+    }
+  }).flatten.asUnit;
+
+  readonly count: UIO<number> = this._count.get;
+
+  readonly increment: UIO<void> = this._count.update((n) => n + 1);
+}
+
+/**
+ * @tsplus static fncts.io.CountdownLatchOps make
+ * @tsplus static fncts.io.CountdownLatchOps __call
+ */
+export function make(n: number): UIO<CountdownLatch> {
+  return Do((Δ) => {
+    const count   = Δ(Ref.make(n));
+    const waiters = Δ(Future.make<never, void>());
+    return new CountdownLatch(count, waiters);
+  });
+}

package/_src/Fiber/FiberMessage.ts

@@ -0,0 +1,78 @@
+import type { FiberStatus } from "../FiberStatus.js";
+import type { FiberRuntime } from "./FiberRuntime.js";
+
+export const enum FiberMessageTag {
+  InterruptSignal,
+  GenStackTrace,
+  Stateful,
+  Resume,
+  YieldNow,
+}
+
+export type FiberMessage = InterruptSignal | GenStackTrace | Stateful | Resume | YieldNow;
+
+/**
+ * @tsplus type fncts.io.FiberMessageOps
+ */
+export interface FiberMessageOps {}
+
+export const FiberMessage: FiberMessageOps = {};
+
+export class InterruptSignal {
+  readonly _tag = FiberMessageTag.InterruptSignal;
+  constructor(readonly cause: Cause<never>) {}
+}
+
+/**
+ * @tsplus static fncts.io.FiberMessageOps InterruptSignal
+ */
+export function mkInterruptSignal(cause: Cause<never>): FiberMessage {
+  return new InterruptSignal(cause);
+}
+
+export class GenStackTrace {
+  readonly _tag = FiberMessageTag.GenStackTrace;
+  constructor(readonly onTrace: (trace: Trace) => void) {}
+}
+
+/**
+ * @tsplus static fncts.io.FiberMessageOps GenStackTrace
+ */
+export function mkGenStackTrace(onTrace: (trace: Trace) => void): FiberMessage {
+  return new GenStackTrace(onTrace);
+}
+
+export class Stateful {
+  readonly _tag = FiberMessageTag.Stateful;
+  constructor(readonly onFiber: (fiber: FiberRuntime<any, any>, status: FiberStatus) => void) {}
+}
+
+/**
+ * @tsplus static fncts.io.FiberMessageOps Stateful
+ */
+export function mkStateful(onFiber: (fiber: FiberRuntime<any, any>, status: FiberStatus) => void): FiberMessage {
+  return new Stateful(onFiber);
+}
+
+export class Resume {
+  readonly _tag = FiberMessageTag.Resume;
+  constructor(readonly cont: IO<any, any, any>) {}
+}
+
+/**
+ * @tsplus static fncts.io.FiberMessageOps Resume
+ */
+export function mkResume(cont: IO<any, any, any>): FiberMessage {
+  return new Resume(cont);
+}
+
+export interface YieldNow {
+  readonly _tag: FiberMessageTag.YieldNow;
+}
+
+/**
+ * @tsplus static fncts.io.FiberMessageOps YieldNow
+ */
+export const YieldNow: FiberMessage = {
+  _tag: FiberMessageTag.YieldNow,
+};