@fncts/io 0.0.19 → 0.0.21

package/_src/Hub/internal.ts

@@ -1,11 +1,11 @@
 import type { Hub as HubInternal } from "@fncts/io/internal/Hub";
+import type { Dequeue } from "@fncts/io/Queue";
 
 import { HashSet } from "@fncts/base/collection/mutable/HashSet";
 import { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
-import { PHubInternal } from "@fncts/io/Hub/definition";
 import { HashedPair } from "@fncts/io/internal/HashedPair";
 import { MutableQueue } from "@fncts/io/internal/MutableQueue";
-import { QueueInternal } from "@fncts/io/Queue";
+import { QueueTypeId } from "@fncts/io/Queue";
 
 /**
  * A `Strategy<A>` describes the protocol for how publishers and subscribers
@@ -128,7 +128,7 @@ export class BackPressure<A> extends Strategy<A> {
     return Do((_) => {
       const fiberId    = _(IO.fiberId);
       const publishers = _(IO.succeed(self.publishers.unsafeDequeueAll));
-      _(IO.foreachC(publishers, ([_, future, last]) => (last ? future.interruptAs(fiberId) : IO.unit)));
+      _(publishers.traverseIOC(([_, future, last]) => (last ? future.interruptAs(fiberId) : IO.unit)));
     });
   }
 
@@ -254,7 +254,9 @@ export class Sliding<A> extends Strategy<A> {
   }
 }
 
-class UnsafeSubscription<A> extends QueueInternal<never, never, unknown, never, never, A> {
+class UnsafeSubscription<A> implements Dequeue<A> {
+  readonly [QueueTypeId]: QueueTypeId = QueueTypeId;
+  declare _Out: (_: never) => A;
   constructor(
     readonly hub: HubInternal<A>,
     readonly subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>,
@@ -263,83 +265,92 @@ class UnsafeSubscription<A> extends QueueInternal<never, never, unknown, never,
     readonly shutdownHook: Future<never, void>,
     readonly shutdownFlag: AtomicBoolean,
     readonly strategy: Strategy<A>,
-  ) {
-    super();
-  }
-
-  awaitShutdown: UIO<void> = this.shutdownHook.await;
-
-  capacity: number = this.hub.capacity;
-
-  isShutdown: UIO<boolean> = IO.succeed(() => this.shutdownFlag.get);
+  ) {}
 
-  shutdown: UIO<void> = IO.fiberId.flatMap((fiberId) =>
-    IO.defer(() => {
-      this.shutdownFlag.set(true);
-      return IO.foreachC(this.pollers.unsafeDequeueAll, (fiber) => fiber.interruptAs(fiberId))
-        .apSecond(IO.succeed(this.subscription.unsubscribe()))
-        .whenIO(this.shutdownHook.succeed(undefined));
-    }),
-  );
-
-  size: UIO<number> = IO.defer(() => {
-    if (this.shutdownFlag.get) {
-      return IO.interrupt;
-    }
+  get awaitShutdown(): UIO<void> {
+    return this.shutdownHook.await;
+  }
 
-    return IO.succeed(this.subscription.size());
-  });
+  get capacity(): number {
+    return this.hub.capacity;
+  }
 
-  offer = (_: never): IO<never, unknown, boolean> => IO.succeedNow(false);
+  get isShutdown(): UIO<boolean> {
+    return IO.succeed(() => this.shutdownFlag.get);
+  }
 
-  offerAll = (_: Iterable<never>): IO<never, unknown, boolean> => IO.succeedNow(false);
+  get shutdown(): UIO<void> {
+    return IO.fiberId.flatMap((fiberId) =>
+      IO.defer(() => {
+        this.shutdownFlag.set(true);
+        return this.pollers.unsafeDequeueAll
+          .traverseIOC((fiber) => fiber.interruptAs(fiberId))
+          .apSecond(IO.succeed(this.subscription.unsubscribe()))
+          .whenIO(this.shutdownHook.succeed(undefined));
+      }),
+    );
+  }
 
-  take: IO<never, never, A> = IO.fiberId.flatMap((fiberId) =>
-    IO.defer(() => {
+  get size(): UIO<number> {
+    return IO.defer(() => {
       if (this.shutdownFlag.get) {
         return IO.interrupt;
       }
 
-      const empty   = null as unknown as A;
-      const message = this.pollers.isEmpty ? this.subscription.poll(empty) : empty;
+      return IO.succeed(this.subscription.size());
+    });
+  }
 
-      if (message == null) {
-        const future = Future.unsafeMake<never, A>(fiberId);
+  get take(): IO<never, never, A> {
+    return IO.fiberId.flatMap((fiberId) =>
+      IO.defer(() => {
+        if (this.shutdownFlag.get) {
+          return IO.interrupt;
+        }
 
-        return IO.defer(() => {
-          this.pollers.enqueue(future);
-          this.subscribers.add(new HashedPair(this.subscription, this.pollers));
-          this.strategy.unsafeCompletePollers(this.hub, this.subscribers, this.subscription, this.pollers);
-          if (this.shutdownFlag.get) {
-            return IO.interrupt;
-          } else {
-            return future.await;
-          }
-        }).onInterrupt(() =>
-          IO.succeed(() => {
-            this.pollers.unsafeRemove(future);
-          }),
-        );
-      } else {
-        this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
-        return IO.succeedNow(message);
-      }
-    }),
-  );
+        const empty   = null as unknown as A;
+        const message = this.pollers.isEmpty ? this.subscription.poll(empty) : empty;
+
+        if (message == null) {
+          const future = Future.unsafeMake<never, A>(fiberId);
+
+          return IO.defer(() => {
+            this.pollers.enqueue(future);
+            this.subscribers.add(new HashedPair(this.subscription, this.pollers));
+            this.strategy.unsafeCompletePollers(this.hub, this.subscribers, this.subscription, this.pollers);
+            if (this.shutdownFlag.get) {
+              return IO.interrupt;
+            } else {
+              return future.await;
+            }
+          }).onInterrupt(() =>
+            IO.succeed(() => {
+              this.pollers.unsafeRemove(future);
+            }),
+          );
+        } else {
+          this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
+          return IO.succeedNow(message);
+        }
+      }),
+    );
+  }
 
-  takeAll: IO<never, never, Conc<A>> = IO.defer(() => {
-    if (this.shutdownFlag.get) {
-      return IO.interrupt;
-    }
+  get takeAll(): IO<never, never, Conc<A>> {
+    return IO.defer(() => {
+      if (this.shutdownFlag.get) {
+        return IO.interrupt;
+      }
 
-    const as = this.pollers.isEmpty ? this.subscription.unsafePollAll : Conc.empty<A>();
+      const as = this.pollers.isEmpty ? this.subscription.unsafePollAll : Conc.empty<A>();
 
-    this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
+      this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
 
-    return IO.succeedNow(as);
-  });
+      return IO.succeedNow(as);
+    });
+  }
 
-  takeUpTo = (n: number): IO<never, never, Conc<A>> => {
+  takeUpTo(this: this, n: number): IO<never, never, Conc<A>> {
     return IO.defer(() => {
       if (this.shutdownFlag.get) {
         return IO.interrupt;
@@ -350,7 +361,43 @@ class UnsafeSubscription<A> extends QueueInternal<never, never, unknown, never,
       this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
       return IO.succeedNow(as);
     });
-  };
+  }
+
+  private takeRemainder(min: number, max: number, acc: Conc<A>, __tsplusTrace?: string): UIO<Conc<A>> {
+    if (max < min) return IO.succeedNow(acc);
+    else {
+      return this.takeUpTo(max).flatMap((bs) => {
+        const remaining = min - bs.length;
+        if (remaining === 1) {
+          return this.take.map((b) => acc.concat(bs).append(b));
+        } else if (remaining > 1) {
+          return this.take.flatMap((b) => this.takeRemainder(remaining - 1, max - bs.length, acc.concat(bs).append(b)));
+        } else {
+          return IO.succeedNow(acc.concat(bs));
+        }
+      });
+    }
+  }
+
+  takeBetween(this: this, min: number, max: number, __tsplusTrace?: string): UIO<Conc<A>> {
+    return this.takeRemainder(min, max, Conc());
+  }
+
+  takeN(this: this, n: number, __tsplusTrace?: string): UIO<Conc<A>> {
+    return this.takeBetween(n, n);
+  }
+
+  get poll(): UIO<Maybe<A>> {
+    return this.takeUpTo(1).map((_) => _.head);
+  }
+
+  get isFull(): UIO<boolean> {
+    return this.size.map((size) => size === this.capacity);
+  }
+
+  get isEmpty(): UIO<boolean> {
+    return this.size.map((size) => size === 0);
+  }
 }
 
 /**
@@ -360,7 +407,7 @@ export function makeSubscription<A>(
   hub: HubInternal<A>,
   subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>,
   strategy: Strategy<A>,
-): UIO<Queue.Dequeue<A>> {
+): UIO<Dequeue<A>> {
   return Future.make<never, void>().map((future) => {
     return unsafeMakeSubscription(
       hub,
@@ -385,7 +432,7 @@ export function unsafeMakeSubscription<A>(
   shutdownHook: Future<never, void>,
   shutdownFlag: AtomicBoolean,
   strategy: Strategy<A>,
-): Queue.Dequeue<A> {
+): Dequeue<A> {
   return new UnsafeSubscription(hub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy);
 }
 
@@ -394,100 +441,3 @@ export function subscribersHashSet<A>(): HashSet<
 > {
   return HashSet.empty<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>();
 }
-
-class UnsafeHub<A> extends PHubInternal<never, never, never, never, A, A> {
-  constructor(
-    readonly hub: HubInternal<A>,
-    readonly subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>,
-    readonly scope: Scope.Closeable,
-    readonly shutdownHook: Future<never, void>,
-    readonly shutdownFlag: AtomicBoolean,
-    readonly strategy: Strategy<A>,
-  ) {
-    super();
-  }
-
-  awaitShutdown = this.shutdownHook.await;
-
-  capacity = this.hub.capacity;
-
-  isShutdown = IO.succeed(this.shutdownFlag.get);
-
-  shutdown = IO.fiberId.flatMap((fiberId) =>
-    IO.defer(() => {
-      this.shutdownFlag.set(true);
-      return this.scope
-        .close(Exit.interrupt(fiberId))
-        .apSecond(this.strategy.shutdown)
-        .whenIO(this.shutdownHook.succeed(undefined));
-    }),
-  ).uninterruptible;
-
-  size = IO.defer(() => {
-    if (this.shutdownFlag.get) {
-      return IO.interrupt;
-    }
-
-    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,
-  );
-
-  publish = (a: A): IO<never, never, boolean> =>
-    IO.defer(() => {
-      if (this.shutdownFlag.get) {
-        return IO.interrupt;
-      }
-
-      if (this.hub.publish(a)) {
-        this.strategy.unsafeCompleteSubscribers(this.hub, this.subscribers);
-        return IO.succeedNow(true);
-      }
-
-      return this.strategy.handleSurplus(this.hub, this.subscribers, Conc.single(a), this.shutdownFlag);
-    });
-
-  publishAll = (as: Iterable<A>): IO<never, never, boolean> =>
-    IO.defer(() => {
-      if (this.shutdownFlag.get) {
-        return IO.interrupt;
-      }
-
-      const surplus = this.hub.publishAll(as);
-
-      this.strategy.unsafeCompleteSubscribers(this.hub, this.subscribers);
-
-      if (surplus.isEmpty) {
-        return IO.succeedNow(true);
-      }
-
-      return this.strategy.handleSurplus(this.hub, this.subscribers, surplus, this.shutdownFlag);
-    });
-}
-
-/**
- * Unsafely creates a hub with the specified strategy.
- */
-export function unsafeMakeHub<A>(
-  hub: HubInternal<A>,
-  subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>,
-  scope: Scope.Closeable,
-  shutdownHook: Future<never, void>,
-  shutdownFlag: AtomicBoolean,
-  strategy: Strategy<A>,
-): Hub<A> {
-  return new UnsafeHub(hub, subscribers, scope, shutdownHook, shutdownFlag, strategy);
-}
-
-export function makeHubInternal<A>(hub: HubInternal<A>, strategy: Strategy<A>): UIO<Hub<A>> {
-  return Do((_) => {
-    const scope  = _(Scope.make);
-    const future = _(Future.make<never, void>());
-    return unsafeMakeHub(hub, subscribersHashSet(), scope, future, new AtomicBoolean(false), strategy);
-  });
-}

package/_src/Hub.ts

@@ -1,4 +1,4 @@
 // codegen:start { preset: barrel, include: ./Hub/*.ts, exclude: ./Hub/*internal.ts }
-export * from "./Hub/api.js";
+export * from "./Hub/constructors.js";
 export * from "./Hub/definition.js";
 // codegen:end

package/_src/IO/api/acquireRelease.ts

@@ -6,6 +6,6 @@ export function acquireRelease<R, E, A, R1>(
   acquire: Lazy<IO<R, E, A>>,
   release: (a: A) => IO<R1, never, any>,
   __tsplusTrace?: string,
-): IO<R | R1 | Scope, E, A> {
+): IO<Scope | R | R1, E, A> {
   return IO.acquireReleaseExit(acquire, (a, _) => release(a));
 }

package/_src/IO/api/acquireReleaseExit.ts

@@ -6,6 +6,6 @@ export function acquireReleaseExit<R, E, A, R1>(
   acquire: Lazy<IO<R, E, A>>,
   release: (a: A, exit: Exit<any, any>) => IO<R1, never, any>,
   __tsplusTrace?: string,
-): IO<R | R1 | Scope, E, A> {
+): IO<Scope | R | R1, E, A> {
   return IO.uninterruptible(IO.defer(acquire).tap((a) => IO.addFinalizerExit((exit) => release(a, exit))));
 }

package/_src/IO/api/bracket.ts

@@ -21,7 +21,7 @@
  * @tsplus fluent fncts.io.IO bracket
  * @tsplus static fncts.io.IOOps bracket
  */
-export function bracket_<R, E, A, R1, E1, A1, R2, E2, A2>(
+export function bracket<R, E, A, R1, E1, A1, R2, E2, A2>(
   acquire: Lazy<IO<R, E, A>>,
   use: (a: A) => IO<R1, E1, A1>,
   release: (a: A) => IO<R2, E2, A2>,

package/_src/IO/api/bracketExit.ts

@@ -8,7 +8,7 @@
  * @tsplus fluent fncts.io.IO bracketExit
  * @tsplus static fncts.io.IOOps bracketExit
  */
-export function bracketExit_<R, E, A, E1, R1, A1, R2, E2>(
+export function bracketExit<R, E, A, E1, R1, A1, R2, E2>(
   acquire: Lazy<IO<R, E, A>>,
   use: (a: A) => IO<R1, E1, A1>,
   release: (a: A, e: Exit<E1, A1>) => IO<R2, E2, any>,

package/_src/IO/api/clockWith.ts

@@ -4,7 +4,6 @@
 export function clockWith<R, E, A>(f: (clock: Clock) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
   return IOEnv.services.getWith((services) => f(services.get(Clock.Tag)));
 }
-
 /**
  * @tsplus static fncts.io.IOOps clock
  */

package/_src/IO/api/concurrency.ts

@@ -2,7 +2,6 @@
  * The number of fibers used for concurrent operators.
  */
 export const Concurrency: FiberRef<Maybe<number>> = FiberRef.unsafeMake(Nothing());
-
 /**
  * Retrieves the maximum number of fibers for concurrent operators or `Nothing` if
  * it is unbounded.
@@ -10,7 +9,6 @@ export const Concurrency: FiberRef<Maybe<number>> = FiberRef.unsafeMake(Nothing(
  * @tsplus static fncts.io.IOOps concurrency
  */
 export const concurrency: UIO<Maybe<number>> = Concurrency.get;
-
 /**
  * Retrieves the current maximum number of fibers for concurrent operators and
  * uses it to run the specified effect.
@@ -23,17 +21,17 @@ export function concurrencyWith<R, E, A>(
 ): IO<R, E, A> {
   return Concurrency.getWith(f);
 }
-
 /**
  * Runs the specified effect with the specified maximum number of fibers for
  * concurrent operators.
  *
- * @tsplus fluent fncts.io.IO withConcurrency
+ * @tsplus pipeable fncts.io.IO withConcurrency
  */
-export function withConcurrency_<R, E, A>(ma: IO<R, E, A>, n: number, __tsplusTrace?: string): IO<R, E, A> {
-  return IO.defer(Concurrency.locally(Just(n))(ma));
+export function withConcurrency(n: number, __tsplusTrace?: string) {
+  return <R, E, A>(ma: IO<R, E, A>): IO<R, E, A> => {
+    return IO.defer(Concurrency.locally(Just(n))(ma));
+  };
 }
-
 /**
  * Runs the specified effect with an unbounded maximum number of fibers for
  * concurrent operators.

package/_src/IO/api/consoleWith.ts

@@ -1,12 +1,10 @@
 import { Console } from "@fncts/io/Console";
-
 /**
  * @tsplus static fncts.io.IOOps consoleWith
  */
 export function consoleWith<R, E, A>(f: (console: Console) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
   return IOEnv.services.getWith((services) => f(services.get(Console.Tag)));
 }
-
 /**
  * @tsplus static fncts.io.IOOps console
  */

package/_src/IO/api/core-scope.ts

@@ -42,7 +42,7 @@ export class ForkScopeRestore {
  *
  * @tsplus static fncts.io.IOOps forkScopeMask
  */
-export function forkScopeMask_<R, E, A>(
+export function forkScopeMask<R, E, A>(
   newScope: FiberScope,
   f: (restore: ForkScopeRestore) => IO<R, E, A>,
   __tsplusTrace?: string,
@@ -56,40 +56,41 @@ export function forkScopeMask_<R, E, A>(
  * Returns an effect that races this effect with the specified effect, calling
  * the specified finisher as soon as one result or the other has been computed.
  *
- * @tsplus fluent fncts.io.IO raceWith
+ * @tsplus pipeable fncts.io.IO raceWith
  */
-export function raceWith_<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(
-  left: IO<R, E, A>,
+export function raceWith<E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(
   right: Lazy<IO<R1, E1, A1>>,
   leftWins: (exit: Exit<E, A>, fiber: Fiber<E1, A1>) => IO<R2, E2, A2>,
   rightWins: (exit: Exit<E1, A1>, fiber: Fiber<E, A>) => IO<R3, E3, A3>,
   __tsplusTrace?: string,
-): IO<R | R1 | R2 | R3, E2 | E3, A2 | A3> {
-  return IO.defer(
-    () =>
-      new Race(
-        left,
-        right(),
-        (winner, loser) =>
-          winner.await.flatMap((exit) => {
-            switch (exit._tag) {
-              case ExitTag.Success:
-                return winner.inheritRefs.flatMap(() => leftWins(exit, loser));
-              case ExitTag.Failure:
-                return leftWins(exit, loser);
-            }
-          }),
-        (winner, loser) =>
-          winner.await.flatMap((exit) => {
-            switch (exit._tag) {
-              case ExitTag.Success:
-                return winner.inheritRefs.flatMap(() => rightWins(exit, loser));
-              case ExitTag.Failure:
-                return rightWins(exit, loser);
-            }
-          }),
-      ),
-  );
+) {
+  return <R>(left: IO<R, E, A>): IO<R | R1 | R2 | R3, E2 | E3, A2 | A3> => {
+    return IO.defer(
+      () =>
+        new Race(
+          left,
+          right(),
+          (winner, loser) =>
+            winner.await.flatMap((exit) => {
+              switch (exit._tag) {
+                case ExitTag.Success:
+                  return winner.inheritRefs.flatMap(() => leftWins(exit, loser));
+                case ExitTag.Failure:
+                  return leftWins(exit, loser);
+              }
+            }),
+          (winner, loser) =>
+            winner.await.flatMap((exit) => {
+              switch (exit._tag) {
+                case ExitTag.Success:
+                  return winner.inheritRefs.flatMap(() => rightWins(exit, loser));
+                case ExitTag.Failure:
+                  return rightWins(exit, loser);
+              }
+            }),
+        ),
+    );
+  };
 }
 
 export type Grafter = <R, E, A>(effect: IO<R, E, A>) => IO<R, E, A>;
@@ -123,10 +124,12 @@ export function forkDaemon<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): UR
  * Returns a new effect that will utilize the specified scope to supervise
  * any fibers forked within the original effect.
  *
- * @tsplus fluent fncts.io.IO overrideForkScope
+ * @tsplus pipeable fncts.io.IO overrideForkScope
  */
-export function overrideForkScope_<R, E, A>(ma: IO<R, E, A>, scope: FiberScope, __tsplusTrace?: string): IO<R, E, A> {
-  return FiberRef.forkScopeOverride.locally(Just(scope))(ma);
+export function overrideForkScope(scope: FiberScope, __tsplusTrace?: string) {
+  return <R, E, A>(ma: IO<R, E, A>): IO<R, E, A> => {
+    return FiberRef.forkScopeOverride.locally(Just(scope))(ma);
+  };
 }
 
 /**

package/_src/IO/api/ensuringChildren.ts

@@ -1,12 +1,13 @@
 /**
- * @tsplus fluent fncts.io.IO ensuringChildren
+ * @tsplus pipeable fncts.io.IO ensuringChildren
  */
-export function ensuringChildren<R, E, A, R1>(
-  self: IO<R, E, A>,
+export function ensuringChildren<R1>(
   children: (_: Conc<Fiber.Runtime<any, any>>) => IO<R1, never, void>,
   __tsplusTrace?: string,
-): IO<R | R1, E, A> {
-  return Supervisor.track(true).flatMap((supervisor) =>
-    self.supervised(supervisor).ensuring(supervisor.value.flatMap(children)),
-  );
+) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E, A> => {
+    return Supervisor.track(true).flatMap((supervisor) =>
+      self.supervised(supervisor).ensuring(supervisor.value.flatMap(children)),
+    );
+  };
 }