@fncts/io 0.0.49 → 0.0.51

package/_mjs/internal/StackTraceBuilder.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"StackTraceBuilder.mjs","names":["StackTraceBuilder","constructor","last","undefined","builder","tsplus_module_1","append","trace","tsplus_module_2","NoLocation","result"],"sources":["../../_src/internal/StackTraceBuilder.ts"],"sourcesContent":[null],"mappings":";;AAAA,OAAM,MAAOA,iBAAiB;EAA9BC,YAAA;IACU,KAAAC,IAAI,GAAiCC,SAAS;IAC9C,KAAAC,OAAO,GAA8BC,eAAA,CAAAD,OAAA,EAAc;EAY7D;EAVEE,MAAMA,CAACC,KAA+B;IACpC,IAAIA,KAAK,IAAI,IAAI,IAAIA,KAAK,KAAK,IAAI,CAACL,IAAI,IAAIK,KAAK,KAAAC,eAAA,CAAAC,UAA4B,EAAE;MAC7E,IAAI,CAACL,OAAO,CAACE,MAAM,CAACC,KAAK,CAAC;MAC1B,IAAI,CAACL,IAAI,GAAGK,KAAK;IACnB;EACF;EAEAG,MAAMA,CAAA;IACJ,OAAO,IAAI,CAACN,OAAO,CAACM,MAAM,EAAE;EAC9B","ignoreList":[]}
+{"version":3,"file":"StackTraceBuilder.mjs","names":["StackTraceBuilder","last","undefined","builder","tsplus_module_1","append","trace","tsplus_module_2","NoLocation","result"],"sources":["../../_src/internal/StackTraceBuilder.ts"],"sourcesContent":[null],"mappings":";;AAAA,OAAM,MAAOA,iBAAiB;EACpBC,IAAI,GAAiCC,SAAS;EAC9CC,OAAO,gBAA8BC,eAAA,CAAAD,OAAA,EAAc;EAE3DE,MAAMA,CAACC,KAA+B;IACpC,IAAIA,KAAK,IAAI,IAAI,IAAIA,KAAK,KAAK,IAAI,CAACL,IAAI,IAAIK,KAAK,KAAAC,eAAA,CAAAC,UAA4B,EAAE;MAC7E,IAAI,CAACL,OAAO,CAACE,MAAM,CAACC,KAAK,CAAC;MAC1B,IAAI,CAACL,IAAI,GAAGK,KAAK;IACnB;EACF;EAEAG,MAAMA,CAAA;IACJ,OAAO,IAAI,CAACN,OAAO,CAACM,MAAM,EAAE;EAC9B","ignoreList":[]}

package/_src/Cached/api.ts

@@ -45,8 +45,14 @@ class Manual<Error, Resource> extends CachedInternal<Error, Resource> {
   ) {
     super();
   }
-  get: FIO<Error, Resource> = this.ref.get.flatMap(IO.fromExitNow);
-  refresh: FIO<Error, void> = this.ref.set(this.acquire.map(Exit.succeed));
+
+  get get(): FIO<Error, Resource> {
+    return this.ref.get.flatMap(IO.fromExitNow);
+  }
+
+  get refresh(): FIO<Error, void> {
+    return this.ref.set(this.acquire.map(Exit.succeed));
+  }
 }
 
 /**

package/_src/Channel/internal/SingleProducerAsyncInput.ts

@@ -56,6 +56,10 @@ export class SingleProducerAsyncInput<Err, Elem, Done>
 {
   constructor(readonly ref: Ref<State<Err, Elem, Done>>) {}
 
+  get awaitRead(): UIO<void> {
+    return this.ref.modify((s) => (s._stateTag === StateTag.Empty ? [s.notifyProducer.await, s] : [IO.unit, s]));
+  }
+
   emit(el: Elem): UIO<unknown> {
     return Future.make<never, void>().flatMap(
       (p) =>
@@ -167,10 +171,8 @@ export class SingleProducerAsyncInput<Err, Elem, Done>
     (el) => Exit.succeed(el),
     (d) => Exit.fail(Either.right(d)),
   );
-  close                = IO.fiberId.flatMap((id) => this.error(Cause.interrupt(id)));
-  awaitRead: UIO<void> = this.ref.modify((s) =>
-    s._stateTag === StateTag.Empty ? [s.notifyProducer.await, s] : [IO.unit, s],
-  );
+
+  close = IO.fiberId.flatMap((id) => this.error(Cause.interrupt(id)));
 }
 
 /**

package/_src/CountdownLatch.ts

@@ -7,28 +7,39 @@ export type CountdownLatchTypeId = typeof CountdownLatchTypeId;
  */
 export class CountdownLatch {
   readonly [CountdownLatchTypeId]: CountdownLatchTypeId = CountdownLatchTypeId;
+
   constructor(
     private _count: Ref<number>,
     private _waiters: Future<never, void>,
   ) {}
 
-  readonly await: UIO<void> = this._waiters.await;
+  get await(): UIO<void> {
+    return 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;
+  get countDown(): UIO<void> {
+    return 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;
+  get count(): UIO<number> {
+    return this._count.get;
+  }
 
-  readonly increment: UIO<void> = this._count.update((n) => n + 1);
+  get increment(): UIO<void> {
+    return this._count.update((n) => n + 1);
+  }
 
-  readonly isOpen: UIO<boolean> = this._count.get.map((count) => count === 0);
+  get isOpen(): UIO<boolean> {
+    return this._count.get.map((count) => count === 0);
+  }
 }
 
 /**

package/_src/Fiber/FiberRuntime.ts

@@ -42,8 +42,6 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
     readonly _A: (_: never) => A;
   };
 
-  location = this.fiberId.location;
-
   get await(): UIO<Exit<E, A>> {
     return IO.defer(this.awaitUnsafe());
   }
@@ -82,6 +80,10 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
     });
   }
 
+  get location(): string | undefined {
+    return this.fiberId.location;
+  }
+
   get poll(): UIO<Maybe<Exit<E, A>>> {
     return IO.succeed(Maybe.fromNullable(this.exitValue()));
   }

package/_src/FiberRef/definition.ts

@@ -33,7 +33,7 @@ const fiberRefCounter = globalValue(FiberRefCounterId, () => new AtomicNumber(0)
  * @tsplus type fncts.io.FiberRef
  */
 export class FiberRefInternal<Value, Patch> extends FiberRef<Value> implements Hashable, Equatable {
-  readonly _Patch!: Patch;
+  declare readonly _Patch: Patch;
   private readonly id = fiberRefCounter.getAndIncrement();
   constructor(
     readonly _initial: Value,

package/_src/Hub/api.ts

@@ -63,6 +63,18 @@ export function dimap<A, B, C, D>(f: (c: C) => A, g: (b: B) => D, __tsplusTrace?
   };
 }
 
+/**
+ * Transforms messages taken from the hub using the specified effectual
+ * function.
+ *
+ * @tsplus pipeable fncts.io.Hub mapIO
+ */
+export function mapIO<B, RC, EC, C>(f: (b: B) => IO<RC, EC, C>, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, A>(self: PHub<RA, RB, EA, EB, A, B>): PHub<RA, RC | RB, EA, EB | EC, A, C> => {
+    return self.dimapIO(IO.succeedNow, f);
+  };
+}
+
 class DimapIO<RA, RB, RC, RD, EA, EB, EC, ED, A, B, C, D> extends PHubInternal<
   RC | RA,
   RD | RB,
@@ -71,24 +83,31 @@ class DimapIO<RA, RB, RC, RD, EA, EB, EC, ED, A, B, C, D> extends PHubInternal<
   C,
   D
 > {
+  declare readonly awaitShutdown;
+  declare readonly capacity;
+  declare readonly isShutdown;
+  declare readonly shutdown;
+  declare readonly size;
+
   constructor(
     readonly source: PHubInternal<RA, RB, EA, EB, A, B>,
     readonly f: (c: C) => IO<RC, EC, A>,
     readonly g: (b: B) => IO<RD, ED, D>,
   ) {
     super();
+    this.awaitShutdown = this.source.awaitShutdown;
+    this.capacity      = this.source.capacity;
+    this.isShutdown    = this.source.isShutdown;
+    this.shutdown      = this.source.shutdown;
+    this.size          = this.source.size;
   }
-  awaitShutdown = this.source.awaitShutdown;
-  capacity      = this.source.capacity;
-  isShutdown    = this.source.isShutdown;
-  shutdown      = this.source.shutdown;
-  size          = this.source.size;
+
   get unsafeSize() {
     return this.source.unsafeSize;
   }
-  subscribe: IO<Scope, never, PDequeue<RA | RC, RB | RD, EA | EC, EB | ED, C, D>> = unsafeCoerce(
-    this.source.subscribe.map((queue) => queue.mapIO(this.g)),
-  );
+  get subscribe(): IO<Scope, never, PDequeue<RA | RC, RB | RD, EA | EC, EB | ED, C, D>> {
+    return unsafeCoerce(this.source.subscribe.map((queue) => queue.mapIO(this.g)));
+  }
   publish    = (c: C) => this.f(c).flatMap((a) => this.source.publish(a));
   publishAll = (cs: Iterable<C>) => IO.foreach(cs, this.f).flatMap((as) => this.source.publishAll(as));
 }
@@ -122,21 +141,29 @@ export function filterInput<A>(f: (a: A) => boolean, __tsplusTrace?: string) {
 }
 
 class FilterInputIO<RA, RA1, RB, EA, EA1, EB, A, B> extends PHubInternal<RA | RA1, RB, EA | EA1, EB, A, B> {
+  declare readonly awaitShutdown;
+  declare readonly capacity;
+  declare readonly isShutdown;
+  declare readonly shutdown;
+  declare readonly size;
+
   constructor(
     readonly source: PHubInternal<RA, RB, EA, EB, A, B>,
     readonly f: (a: A) => IO<RA1, EA1, boolean>,
   ) {
     super();
+    this.awaitShutdown = this.source.awaitShutdown;
+    this.capacity      = this.source.capacity;
+    this.isShutdown    = this.source.isShutdown;
+    this.shutdown      = this.source.shutdown;
+    this.size          = this.source.size;
   }
-  awaitShutdown = this.source.awaitShutdown;
-  capacity      = this.source.capacity;
-  isShutdown    = this.source.isShutdown;
-  shutdown      = this.source.shutdown;
-  size          = this.source.size;
   get unsafeSize() {
     return this.source.unsafeSize;
   }
-  subscribe  = this.source.subscribe;
+  get subscribe() {
+    return this.source.subscribe;
+  }
   publish    = (a: A) => this.f(a).flatMap((b) => (b ? this.source.publish(a) : IO.succeedNow(false)));
   publishAll = (as: Iterable<A>) =>
     IO.filter(as, this.f).flatMap((as) => (as.isNonEmpty ? this.source.publishAll(as) : IO.succeedNow(false)));
@@ -166,39 +193,46 @@ export function filterOutput<B>(f: (b: B) => boolean, __tsplusTrace?: string) {
   };
 }
 
+/**
+ * Filters messages taken from the hub using the specified effectual
+ * function.
+ *
+ * @tsplus pipeable fncts.io.Hub filterOutputIO
+ */
+export function filterOutputIO<B, R1, E1>(f: (a: B) => IO<R1, E1, boolean>, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, A>(source: PHub<RA, RB, EA, EB, A, B>): PHub<RA, RB | R1, EA, EB | E1, A, B> => {
+    concrete(source);
+    return new FilterOutputIO(source, f);
+  };
+}
+
 class FilterOutputIO<RA, RB, RB1, EA, EB, EB1, A, B> extends PHubInternal<RA, RB | RB1, EA, EB | EB1, A, B> {
+  declare readonly awaitShutdown;
+  declare readonly capacity;
+  declare readonly isShutdown;
+  declare readonly shutdown;
+  declare readonly size;
   constructor(
     readonly source: PHubInternal<RA, RB, EA, EB, A, B>,
     readonly f: (a: B) => IO<RB1, EB1, boolean>,
   ) {
     super();
+    this.awaitShutdown = this.source.awaitShutdown;
+    this.capacity      = this.source.capacity;
+    this.isShutdown    = this.source.isShutdown;
+    this.shutdown      = this.source.shutdown;
+    this.size          = this.source.size;
   }
-  awaitShutdown = this.source.awaitShutdown;
-  capacity      = this.source.capacity;
-  isShutdown    = this.source.isShutdown;
-  shutdown      = this.source.shutdown;
-  size          = this.source.size;
   get unsafeSize() {
     return this.source.unsafeSize;
   }
-  subscribe  = this.source.subscribe.map((queue) => queue.filterOutputIO(this.f));
+  get subscribe() {
+    return this.source.subscribe.map((queue) => queue.filterOutputIO(this.f));
+  }
   publish    = (a: A) => this.source.publish(a);
   publishAll = (as: Iterable<A>) => this.source.publishAll(as);
 }
 
-/**
- * Filters messages taken from the hub using the specified effectual
- * function.
- *
- * @tsplus pipeable fncts.io.Hub filterOutputIO
- */
-export function filterOutputIO<B, R1, E1>(f: (a: B) => IO<R1, E1, boolean>, __tsplusTrace?: string) {
-  return <RA, RB, EA, EB, A>(source: PHub<RA, RB, EA, EB, A, B>): PHub<RA, RB | R1, EA, EB | E1, A, B> => {
-    concrete(source);
-    return new FilterOutputIO(source, f);
-  };
-}
-
 /**
  * Checks whether the hub is shut down.
  *
@@ -275,18 +309,6 @@ export function map<B, C>(f: (b: B) => C, __tsplusTrace?: string) {
   };
 }
 
-/**
- * Transforms messages taken from the hub using the specified effectual
- * function.
- *
- * @tsplus pipeable fncts.io.Hub mapIO
- */
-export function mapIO<B, RC, EC, C>(f: (b: B) => IO<RC, EC, C>, __tsplusTrace?: string) {
-  return <RA, RB, EA, EB, A>(self: PHub<RA, RB, EA, EB, A, B>): PHub<RA, RC | RB, EA, EB | EC, A, C> => {
-    return self.dimapIO(IO.succeedNow, f);
-  };
-}
-
 /**
  * Publishes a message to the hub, returning whether the message was
  * published to the hub.
@@ -359,15 +381,24 @@ class ToQueue<RA, RB, EA, EB, A, B> implements PEnqueue<RA, RB, EA, EB, A, B> {
     readonly _A: (_: A) => void;
     readonly _B: (_: never) => B;
   };
-  constructor(readonly source: PHubInternal<RA, RB, EA, EB, A, B>) {}
-  awaitShutdown = this.source.awaitShutdown;
-  capacity      = this.source.capacity;
-  isShutdown    = this.source.isShutdown;
-  shutdown      = this.source.shutdown;
-  size          = this.source.size;
-  offer         = (a: A): IO<RA, EA, boolean> => this.source.publish(a);
-  offerAll      = (as: Iterable<A>): IO<RA, EA, boolean> => this.source.publishAll(as);
-  takeUpTo      = (): IO<never, never, Conc<never>> => IO.succeedNow(Conc.empty());
+
+  readonly awaitShutdown;
+  readonly capacity;
+  readonly isShutdown;
+  readonly shutdown;
+  readonly size;
+
+  constructor(readonly source: PHubInternal<RA, RB, EA, EB, A, B>) {
+    this.awaitShutdown = this.source.awaitShutdown;
+    this.capacity      = this.source.capacity;
+    this.isShutdown    = this.source.isShutdown;
+    this.shutdown      = this.source.shutdown;
+    this.size          = this.source.size;
+  }
+
+  offer    = (a: A): IO<RA, EA, boolean> => this.source.publish(a);
+  offerAll = (as: Iterable<A>): IO<RA, EA, boolean> => this.source.publishAll(as);
+  takeUpTo = (): IO<never, never, Conc<never>> => IO.succeedNow(Conc.empty());
 }
 
 /**

package/_src/Hub/internal.ts

@@ -267,20 +267,28 @@ class UnsafeSubscription<A> extends QueueInternal<never, never, never, never, A,
     super();
   }
 
-  awaitShutdown: UIO<void> = this.shutdownHook.await;
+  get awaitShutdown(): UIO<void> {
+    return this.shutdownHook.await;
+  }
 
-  capacity: number = this.hub.capacity;
+  get capacity(): number {
+    return this.hub.capacity;
+  }
 
-  isShutdown: UIO<boolean> = IO.succeed(() => this.shutdownFlag.get);
+  get isShutdown(): UIO<boolean> {
+    return IO.succeed(() => this.shutdownFlag.get);
+  }
 
-  shutdown: UIO<void> = IO.fiberId.flatMap((fiberId) =>
-    IO.defer(() => {
-      this.shutdownFlag.set(true);
-      return IO.foreachConcurrent(this.pollers.unsafeDequeueAll, (fiber) => fiber.interruptAs(fiberId))
-        .zipRight(IO.succeed(this.subscription.unsubscribe()))
-        .whenIO(this.shutdownHook.succeed(undefined));
-    }),
-  );
+  get shutdown(): UIO<void> {
+    return IO.fiberId.flatMap((fiberId) =>
+      IO.defer(() => {
+        this.shutdownFlag.set(true);
+        return IO.foreachConcurrent(this.pollers.unsafeDequeueAll, (fiber) => fiber.interruptAs(fiberId))
+          .zipRight(IO.succeed(this.subscription.unsubscribe()))
+          .whenIO(this.shutdownHook.succeed(undefined));
+      }),
+    );
+  }
 
   get unsafeSize(): Maybe<number> {
     if (this.shutdownFlag.get) {
@@ -418,11 +426,17 @@ class UnsafeHub<A> extends PHubInternal<never, never, never, never, A, A> {
     super();
   }
 
-  awaitShutdown = this.shutdownHook.await;
+  get awaitShutdown() {
+    return this.shutdownHook.await;
+  }
 
-  capacity = this.hub.capacity;
+  get capacity() {
+    return this.hub.capacity;
+  }
 
-  isShutdown = IO.succeed(this.shutdownFlag.get);
+  get isShutdown() {
+    return IO.succeed(this.shutdownFlag.get);
+  }
 
   shutdown = IO.fiberId.flatMap((fiberId) =>
     IO.defer(() => {
@@ -449,12 +463,14 @@ class UnsafeHub<A> extends PHubInternal<never, never, never, never, A, A> {
     return IO.succeed(this.hub.size());
   });
 
-  subscribe: IO<Scope, never, Queue.Dequeue<A>> = IO.acquireRelease(
-    makeSubscription(this.hub, this.subscribers, this.strategy).tap((dequeue) =>
-      this.scope.addFinalizer(dequeue.shutdown),
-    ),
-    (dequeue) => dequeue.shutdown,
-  );
+  get subscribe(): IO<Scope, never, Queue.Dequeue<A>> {
+    return IO.acquireRelease(
+      makeSubscription(this.hub, this.subscribers, this.strategy).tap((dequeue) =>
+        this.scope.addFinalizer(dequeue.shutdown),
+      ),
+      (dequeue) => dequeue.shutdown,
+    );
+  }
 
   publish = (a: A): IO<never, never, boolean> =>
     IO.defer(() => {

package/_src/IO/api/foreachExec.ts

@@ -1,3 +1,28 @@
+/**
+ * Applies the function `f` to each element of the `Iterable<A>` in parallel,
+ * and returns the results in a new `Conc<B>`.
+ *
+ * For a sequential version of this method, see `foreach`.
+ *
+ * @tsplus static fncts.io.IOOps foreachWithIndexDiscardExec
+ */
+export function foreachWithIndexDiscardExec<R, E, A, B>(
+  as: Iterable<A>,
+  es: ExecutionStrategy,
+  f: (index: number, a: A) => IO<R, E, B>,
+  __tsplusTrace?: string,
+): IO<R, E, void> {
+  return es.match(
+    () => IO.foreachWithIndexDiscard(as, f),
+    () =>
+      IO.withConcurrencyUnboundedMask((restore) => IO.foreachConcurrent(as.zipWithIndex, ([i, a]) => restore(f(i, a)))),
+    (fiberBound) =>
+      IO.withConcurrencyMask(fiberBound, (restore) =>
+        IO.foreachConcurrent(as.zipWithIndex, ([i, a]) => restore(f(i, a))),
+      ),
+  );
+}
+
 /**
  * Applies the function `f` to each element of the `Iterable<A>` in parallel,
  * and returns the results in a new `Conc<B>`.
@@ -18,3 +43,25 @@ export function foreachExec<R, E, A, B>(
     (fiberBound) => IO.withConcurrencyMask(fiberBound, (restore) => IO.foreachConcurrent(as, (a) => restore(f(a)))),
   );
 }
+
+/**
+ * Applies the function `f` to each element of the `Iterable<A>` in parallel,
+ * and returns the results in a new `Conc<B>`.
+ *
+ * For a sequential version of this method, see `foreach`.
+ *
+ * @tsplus static fncts.io.IOOps foreachExecDiscard
+ */
+export function foreachDiscardExec<R, E, A, B>(
+  as: Iterable<A>,
+  es: ExecutionStrategy,
+  f: (a: A) => IO<R, E, B>,
+  __tsplusTrace?: string,
+): IO<R, E, void> {
+  return es.match(
+    () => IO.foreachDiscard(as, f),
+    () => IO.withConcurrencyUnboundedMask((restore) => IO.foreachConcurrentDiscard(as, (a) => restore(f(a)))),
+    (fiberBound) =>
+      IO.withConcurrencyMask(fiberBound, (restore) => IO.foreachConcurrentDiscard(as, (a) => restore(f(a)))),
+  );
+}

package/_src/IO/api.ts

@@ -518,13 +518,11 @@ export function filterOrElse<A, B extends A, R1, E1, A1>(
   or: (a: Exclude<A, B>) => IO<R1, E1, A1>,
   __tsplusTrace?: string,
 ): <R, E>(fa: IO<R, E, A>) => IO<R | R1, E | E1, B | A1>;
-
 export function filterOrElse<A, R1, E1, A1>(
   predicate: Predicate<A>,
   or: (a: A) => IO<R1, E1, A1>,
   __tsplusTrace?: string,
 ): <R, E>(fa: IO<R, E, A>) => IO<R | R1, E | E1, A | A1>;
-
 export function filterOrElse<A>(predicate: Predicate<A>, or: unknown, __tsplusTrace?: string) {
   return <R, E, R1, E1, A1>(fa: IO<R, E, A>): IO<R | R1, E | E1, A | A1> => {
     return fa.flatMap(
@@ -542,12 +540,10 @@ export function filterOrFail<A, B extends A, E1>(
   refinement: Refinement<A, B>,
   failWith: (a: Exclude<A, B>) => E1,
 ): <R, E>(fa: IO<R, E, A>) => IO<R, E | E1, B>;
-
 export function filterOrFail<A, E1>(
   predicate: Predicate<A>,
   failWith: (a: A) => E1,
 ): <R, E>(fa: IO<R, E, A>) => IO<R, E | E1, A>;
-
 export function filterOrFail<A>(predicate: Predicate<A>, failWith: unknown, __tsplusTrace?: string) {
   return <R, E, E1>(fa: IO<R, E, A>): IO<R, E | E1, A> => {
     return fa.filterOrElse(predicate, (a) => IO.failNow((failWith as (a: A) => E1)(a)));
@@ -568,7 +564,6 @@ export function filterOrHalt<A>(
   haltWith: (a: A) => unknown,
   __tsplusTrace?: string,
 ): <R, E>(fa: IO<R, E, A>) => IO<R, E, A>;
-
 export function filterOrHalt<A>(predicate: Predicate<A>, haltWith: unknown, __tsplusTrace?: string) {
   return <R, E>(fa: IO<R, E, A>): IO<R, E, A> => {
     return fa.filterOrElse(predicate, (a) => IO.haltNow((haltWith as (a: A) => unknown)(a)));

package/_src/Push/Bounds.ts

@@ -0,0 +1,4 @@
+export interface Bounds {
+  readonly min: number;
+  readonly max: number;
+}

package/_src/Push/FlattenStrategy.ts

@@ -0,0 +1,137 @@
+import { withScope } from "@fncts/io/Push/internal";
+
+type ScopedFork = <R, E, A>(io: IO<R, E, A>) => IO<R | Scope, never, Fiber.Runtime<E, A>>;
+
+type Fork = <R>(io: IO<R, never, void>) => IO<R | Scope, never, void>;
+
+/**
+ * @tsplus type fncts.io.Push.FlattenStrategy
+ * @tsplus companion fncts.io.Push.FlattenStrategyOps
+ */
+export abstract class FlattenStrategy {
+  abstract withFork<R>(
+    f: (fork: Fork, scope: Scope) => IO<R, never, void>,
+    executionStrategy: ExecutionStrategy,
+  ): IO<R | Scope, never, void>;
+}
+
+function withScopedFork<R, E, A>(
+  f: (fork: ScopedFork, scope: Scope.Closeable) => IO<R, E, A>,
+  executionStrategy: ExecutionStrategy,
+): IO<R | Scope, E, A> {
+  return withScope((scope) => f((io) => io.forkIn(scope), scope), executionStrategy);
+}
+
+/**
+ * @tsplus static fncts.io.Push.FlattenStrategyOps Switch
+ */
+export const SwitchStrategy = new (class SwitchStrategy extends FlattenStrategy {
+  withFork<R>(
+    f: (fork: Fork, scope: Scope) => IO<R, never, void>,
+    executionStrategy: ExecutionStrategy,
+  ): IO<R | Scope, never, void> {
+    return withScopedFork(
+      (fork, scope) =>
+        Ref.Synchronized.make<Fiber<never, void>>(Fiber.unit).flatMap(
+          (ref) =>
+            f((io) => ref.updateIO((fiber) => fiber.interrupt > fork(io)), scope) >
+            ref.get.flatMap((fiber) => fiber.join),
+        ),
+      executionStrategy,
+    );
+  }
+})();
+
+/**
+ * @tsplus static fncts.io.Push.FlattenStrategyOps Exhaust
+ */
+export const ExhaustStrategy = new (class ExhaustStrategy extends FlattenStrategy {
+  withFork<R>(
+    f: (fork: Fork, scope: Scope) => IO<R, never, void>,
+    executionStrategy: ExecutionStrategy,
+  ): IO<R | Scope, never, void> {
+    return withScopedFork(
+      (fork, scope) =>
+        Ref.Synchronized.make<Fiber.Runtime<never, void> | null>(null).flatMap(
+          (ref) =>
+            f(
+              (io) =>
+                ref.updateIO((fiber) => {
+                  if (fiber) {
+                    return IO.succeedNow(fiber);
+                  } else {
+                    return fork(io.onExit(() => ref.set(null)));
+                  }
+                }),
+              scope,
+            ) >
+            ref.get.flatMap((fiber) => {
+              if (fiber) {
+                return fiber.join;
+              } else {
+                return IO.unit;
+              }
+            }),
+        ),
+      executionStrategy,
+    );
+  }
+})();
+
+/**
+ * @tsplus static fncts.io.Push.FlattenStrategyOps Unbounded
+ */
+export const UnboundedStrategy = new (class UnboundedStrategy extends FlattenStrategy {
+  withFork<R>(f: (fork: Fork, scope: Scope) => IO<R, never, void>): IO<R | Scope, never, void> {
+    return IO.scopeWith((scope) =>
+      FiberSet.make<never, void>().flatMap((fiberSet) => f((io) => fiberSet.run(io), scope) > Fiber.joinAll(fiberSet)),
+    );
+  }
+})();
+
+/**
+ * @tsplus static fncts.io.Push.FlattenStrategyOps Bounded
+ */
+export function makeBounded(capacity: number): BoundedStrategy {
+  return new BoundedStrategy(capacity);
+}
+
+class BoundedStrategy extends FlattenStrategy {
+  constructor(readonly capacity: number) {
+    super();
+  }
+
+  withFork<R>(
+    f: (fork: Fork, scope: Scope) => IO<R, never, void>,
+    executionStrategy: ExecutionStrategy,
+  ): IO<R | Scope, never, void> {
+    return withScopedFork(
+      (fork, scope) =>
+        Do((Δ) => {
+          const ref       = Δ(Ref.make<HashSet<Fiber.Runtime<never, void>>>(HashSet.empty()));
+          const semaphore = Δ(Semaphore.make(this.capacity));
+          Δ(
+            f(
+              (io) =>
+                Do((Δ) => {
+                  const fiber = Δ(fork(semaphore.withPermit(io)));
+                  Δ(ref.update((set) => set.add(fiber)));
+                  Δ(scope.addFinalizer(ref.update((set) => set.remove(fiber))));
+                }),
+              scope,
+            ),
+          );
+          return ref;
+        }).flatMap((ref) =>
+          ref.get.flatMap((fibers) => {
+            if (fibers.size > 0) {
+              return Fiber.joinAll(fibers);
+            } else {
+              return IO.unit;
+            }
+          }),
+        ),
+      executionStrategy,
+    );
+  }
+}