@fncts/io 0.0.19 → 0.0.21

package/_src/Future/api.ts

@@ -6,30 +6,36 @@ import { Done, FutureStateTag, Pending } from "@fncts/io/Future/definition";
  * Exits the future with the specified exit, which will be propagated to all
  * fibers waiting on the value of the future.
  *
- * @tsplus fluent fncts.io.Future done
+ * @tsplus pipeable fncts.io.Future done
  */
-export function done_<E, A>(future: Future<E, A>, exit: Exit<E, A>, __tsplusTrace?: string): UIO<boolean> {
-  return future.fulfillWith(IO.fromExitNow(exit));
+export function done<E, A>(exit: Exit<E, A>, __tsplusTrace?: string) {
+  return (future: Future<E, A>): UIO<boolean> => {
+    return future.fulfillWith(IO.fromExitNow(exit));
+  };
 }
 
 /**
  * Fails the future with the specified error, which will be propagated to all
  * fibers waiting on the value of the future.
  *
- * @tsplus fluent fncts.io.Future fail
+ * @tsplus pipeable fncts.io.Future fail
  */
-export function fail_<E, A>(future: Future<E, A>, e: E, __tsplusTrace?: string): UIO<boolean> {
-  return future.fulfillWith(IO.failNow(e));
+export function fail<E>(e: E, __tsplusTrace?: string) {
+  return <A>(future: Future<E, A>): UIO<boolean> => {
+    return future.fulfillWith(IO.failNow(e));
+  };
 }
 
 /**
  * Halts the future with the specified cause, which will be propagated to all
  * fibers waiting on the value of the future.
  *
- * @tsplus fluent fncts.io.Future failCause
+ * @tsplus pipeable fncts.io.Future failCause
  */
-export function failCause_<E, A>(future: Future<E, A>, cause: Cause<E>, __tsplusTrace?: string): UIO<boolean> {
-  return future.fulfillWith(IO.failCauseNow(cause));
+export function failCause<E>(cause: Cause<E>, __tsplusTrace?: string) {
+  return <A>(future: Future<E, A>): UIO<boolean> => {
+    return future.fulfillWith(IO.failCauseNow(cause));
+  };
 }
 
 /**
@@ -39,14 +45,12 @@ export function failCause_<E, A>(future: Future<E, A>, cause: Cause<E>, __tsplus
  * Note that `Future.completeWith` will be much faster, so consider using
  * that if you do not need to memoize the result of the specified effect.
  *
- * @tsplus fluent fncts.io.Future fulfill
+ * @tsplus pipeable fncts.io.Future fulfill
  */
-export function fulfill_<R, E, A>(
-  future: Future<E, A>,
-  io: IO<R, E, A>,
-  __tsplusTrace?: string,
-): IO<R, never, boolean> {
-  return IO.uninterruptibleMask(({ restore }) => restore(io).result.flatMap((exit) => future.done(exit)));
+export function fulfill<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string) {
+  return (future: Future<E, A>): IO<R, never, boolean> => {
+    return IO.uninterruptibleMask(({ restore }) => restore(io).result.flatMap((exit) => future.done(exit)));
+  };
 }
 
 /**
@@ -62,34 +66,38 @@ export function fulfill_<R, E, A>(
  * completes the future with the result of an IO see
  * `Future.complete`.
  *
- * @tsplus fluent fncts.io.Future fulfillWith
+ * @tsplus pipeable fncts.io.Future fulfillWith
  */
-export function fulfillWith_<E, A>(future: Future<E, A>, io: FIO<E, A>, __tsplusTrace?: string): UIO<boolean> {
-  return IO.succeed(() => {
-    switch (future.state._tag) {
-      case FutureStateTag.Done: {
-        return false;
-      }
-      case FutureStateTag.Pending: {
-        const state  = future.state;
-        future.state = new Done(io);
-        state.joiners.reverse.forEach((f) => {
-          f(io);
-        });
-        return true;
+export function fulfillWith<E, A>(io: FIO<E, A>, __tsplusTrace?: string) {
+  return (future: Future<E, A>): UIO<boolean> => {
+    return IO.succeed(() => {
+      switch (future.state._tag) {
+        case FutureStateTag.Done: {
+          return false;
+        }
+        case FutureStateTag.Pending: {
+          const state  = future.state;
+          future.state = new Done(io);
+          state.joiners.reverse.forEach((f) => {
+            f(io);
+          });
+          return true;
+        }
       }
-    }
-  });
+    });
+  };
 }
 
 /**
  * Kills the future with the specified error, which will be propagated to all
  * fibers waiting on the value of the future.
  *
- * @tsplus fluent fncts.io.Future halt
+ * @tsplus pipeable fncts.io.Future halt
  */
-export function halt_<E, A>(future: Future<E, A>, defect: unknown, __tsplusTrace?: string): UIO<boolean> {
-  return future.fulfillWith(IO.haltNow(defect));
+export function halt(defect: unknown, __tsplusTrace?: string) {
+  return <E, A>(future: Future<E, A>): UIO<boolean> => {
+    return future.fulfillWith(IO.haltNow(defect));
+  };
 }
 
 /**
@@ -106,10 +114,12 @@ export function interrupt<E, A>(future: Future<E, A>, __tsplusTrace?: string): U
  * Completes the future with interruption. This will interrupt all fibers
  * waiting on the value of the future as by the specified fiber.
  *
- * @tsplus fluent fncts.io.Future interruptAs
+ * @tsplus pipeable fncts.io.Future interruptAs
  */
-export function interruptAs_<E, A>(future: Future<E, A>, id: FiberId, __tsplusTrace?: string): UIO<boolean> {
-  return future.fulfillWith(IO.interruptAs(id));
+export function interruptAs(id: FiberId, __tsplusTrace?: string) {
+  return <E, A>(future: Future<E, A>): UIO<boolean> => {
+    return future.fulfillWith(IO.interruptAs(id));
+  };
 }
 
 /**
@@ -144,33 +154,37 @@ export function poll<E, A>(future: Future<E, A>, __tsplusTrace?: string): UIO<Ma
 /**
  * Completes the future with the specified value.
  *
- * @tsplus fluent fncts.io.Future succeed
+ * @tsplus pipeable fncts.io.Future succeed
  */
-export function succeed_<A, E>(future: Future<E, A>, a: A, __tsplusTrace?: string) {
-  return future.fulfillWith(IO.succeedNow(a));
+export function succeed_<A>(a: A, __tsplusTrace?: string) {
+  return <E>(future: Future<E, A>): UIO<boolean> => future.fulfillWith(IO.succeedNow(a));
 }
 
 /**
  * Retrieves the value of the future, suspending the fiber running the action
  * until the result is available.
  *
- * @tsplus fluent fncts.io.Future unsafeDone
+ * @tsplus pipeable fncts.io.Future unsafeDone
  */
-export function unsafeDone_<E, A>(future: Future<E, A>, io: FIO<E, A>, __tsplusTrace?: string) {
-  if (future.state._tag === FutureStateTag.Pending) {
-    const state  = future.state;
-    future.state = new Done(io);
-    state.joiners.reverse.forEach((f) => {
-      f(io);
-    });
-  }
+export function unsafeDone<E, A>(io: FIO<E, A>, __tsplusTrace?: string) {
+  return (future: Future<E, A>): void => {
+    if (future.state._tag === FutureStateTag.Pending) {
+      const state  = future.state;
+      future.state = new Done(io);
+      state.joiners.reverse.forEach((f) => {
+        f(io);
+      });
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Future unsafeSucceed
+ * @tsplus pipeable fncts.io.Future unsafeSucceed
  */
-export function unsafeSucceed_<A>(future: Future<never, A>, a: A, __tsplusTrace?: string): void {
-  future.unsafeDone(IO.succeedNow(a));
+export function unsafeSucceed<A>(a: A, __tsplusTrace?: string) {
+  return (future: Future<never, A>): void => {
+    future.unsafeDone(IO.succeedNow(a));
+  };
 }
 
 /**

package/_src/Hub/constructors.ts

@@ -0,0 +1,80 @@
+import type { Strategy } from "./internal";
+import type { HashSet } from "@fncts/base/collection/mutable/HashSet";
+import type { HashedPair } from "@fncts/io/internal/HashedPair";
+import type { MutableQueue } from "@fncts/io/internal/MutableQueue";
+import type { Dequeue } from "@fncts/io/Queue";
+
+import { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
+import { Hub as HubInternal } from "@fncts/io/internal/Hub";
+
+import { Hub } from "./definition.js";
+import { BackPressure, Dropping, Sliding } from "./internal.js";
+import { subscribersHashSet } from "./internal.js";
+
+/**
+ * Creates a bounded hub with the back pressure strategy. The hub will retain
+ * messages until they have been taken by all subscribers, applying back
+ * pressure to publishers if the hub is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ *
+ * @tsplus static fncts.io.HubOps makeBounded
+ */
+export function makeBounded<A>(requestedCapacity: number, __tsplusTrace?: string): UIO<Hub<A>> {
+  return IO.succeed(HubInternal.makeBounded<A>(requestedCapacity)).flatMap((hub) => makeHub(hub, new BackPressure()));
+}
+
+/**
+ * Creates a bounded hub with the dropping strategy. The hub will drop new
+ * messages if the hub is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ *
+ * @tsplus static fncts.io.HubOps makeDropping
+ */
+export function makeDropping<A>(requestedCapacity: number, __tsplusTrace?: string): UIO<Hub<A>> {
+  return IO.succeed(HubInternal.makeBounded<A>(requestedCapacity)).flatMap((hub) => makeHub(hub, new Dropping()));
+}
+
+/**
+ * Creates a bounded hub with the sliding strategy. The hub will add new
+ * messages and drop old messages if the hub is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ *
+ * @tsplus static fncts.io.HubOps makeSliding
+ */
+export function makeSliding<A>(requestedCapacity: number, __tsplusTrace?: string): UIO<Hub<A>> {
+  return IO.succeed(HubInternal.makeBounded<A>(requestedCapacity)).flatMap((hub) => makeHub(hub, new Sliding()));
+}
+
+/**
+ * Creates an unbounded hub.
+ *
+ * @tsplus static fncts.io.HubOps makeUnbounded
+ */
+export function makeUnbounded<A>(__tsplusTrace?: string): UIO<Hub<A>> {
+  return IO.succeed(HubInternal.makeUnbounded<A>()).flatMap((hub) => makeHub(hub, new Dropping()));
+}
+
+/**
+ * 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 Hub(hub, subscribers, scope, shutdownHook, shutdownFlag, strategy);
+}
+
+export function makeHub<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/definition.ts

@@ -1,102 +1,108 @@
+import type { HashedPair } from "../internal/HashedPair.js";
+import type { MutableQueue } from "../internal/MutableQueue.js";
+import type { UIO } from "../IO.js";
+import type { Dequeue, Enqueue } from "../Queue/definition.js";
+import type { Strategy } from "./internal.js";
+import type { HashSet } from "@fncts/base/collection/mutable/HashSet";
+import type { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
+import type { Hub as HubInternal } from "@fncts/io/internal/Hub";
+
+import { QueueTypeId } from "../Queue/definition.js";
+import { makeSubscription } from "./internal.js";
+
 export const HubTypeId = Symbol.for("fncts.io.Hub");
 export type HubTypeId = typeof HubTypeId;
 
 /**
- * A `Hub<RA, RB, EA, EB, A, B>` is an asynchronous message hub. Publishers
- * can publish messages of type `A` to the hub and subscribers can subscribe to
- * take messages of type `B` from the hub. Publishing messages can require an
- * environment of type `RA` and fail with an error of type `EA`. Taking
- * messages can require an environment of type `RB` and fail with an error of
- * type `EB`.
- *
  * @tsplus type fncts.io.Hub
+ * @tsplus companion fncts.io.HubOps
  */
-export interface PHub<RA, RB, EA, EB, A, B> {
-  readonly _typeId: HubTypeId;
-  readonly _RA: () => RA;
-  readonly _RB: () => RB;
-  readonly _EA: () => EA;
-  readonly _EB: () => EB;
-  readonly _A: (_: A) => void;
-  readonly _B: () => B;
-}
+export class Hub<A> implements Enqueue<A> {
+  readonly [QueueTypeId]: QueueTypeId = QueueTypeId;
+  readonly [HubTypeId]: HubTypeId     = HubTypeId;
+  declare _In: (_: A) => void;
+  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>,
+  ) {}
 
-/**
- * @tsplus type fncts.io.Hub
- */
-export interface Hub<A> extends PHub<never, never, never, never, A, A> {}
+  awaitShutdown: UIO<void> = this.shutdownHook.await;
 
-/**
- * @tsplus type fncts.io.HubOps
- */
-export interface HubOps {}
+  get capacity(): number {
+    return this.hub.capacity;
+  }
 
-export const Hub: HubOps = {};
+  isShutdown: UIO<boolean> = IO(this.shutdownFlag.get);
 
-export declare namespace Hub {
-  export type Dequeue<R, E, A> = PQueue<never, R, unknown, E, never, A>;
-  export type Enqueue<R, E, A> = PQueue<R, never, E, unknown, A, never>;
-}
+  publish(this: this, a: A, __tsplusTrace?: string): UIO<boolean> {
+    return IO.defer(() => {
+      if (this.shutdownFlag.get) {
+        return IO.interrupt;
+      }
 
-export abstract class PHubInternal<RA, RB, EA, EB, A, B> implements PHub<RA, RB, EA, EB, A, B> {
-  _typeId: HubTypeId = HubTypeId;
-  readonly _RA!: () => RA;
-  readonly _RB!: () => RB;
-  readonly _EA!: () => EA;
-  readonly _EB!: () => EB;
-  readonly _A!: (_: A) => void;
-  readonly _B!: () => B;
-
-  /**
-   * Waits for the hub to be shut down.
-   */
-  abstract awaitShutdown: UIO<void>;
-
-  /**
-   * The maximum capacity of the hub.
-   */
-  abstract capacity: number;
-
-  /**
-   * Checks whether the hub is shut down.
-   */
-  abstract isShutdown: UIO<boolean>;
-
-  /**
-   * Publishes a message to the hub, returning whether the message was
-   * published to the hub.
-   */
-  abstract publish(a: A): IO<RA, EA, boolean>;
-
-  /**
-   * Publishes all of the specified messages to the hub, returning whether
-   * they were published to the hub.
-   */
-  abstract publishAll(as: Iterable<A>): IO<RA, EA, boolean>;
-
-  /**
-   * Shuts down the hub.
-   */
-  abstract shutdown: UIO<void>;
-
-  /**
-   * The current number of messages in the hub.
-   */
-  abstract size: UIO<number>;
-
-  /**
-   * Subscribes to receive messages from the hub. The resulting subscription
-   * can be evaluated multiple times within the scope of the managed to take a
-   * message from the hub each time.
-   */
-  abstract subscribe: IO<Scope, never, Hub.Dequeue<RB, EB, B>>;
-}
+      if (this.hub.publish(a)) {
+        this.strategy.unsafeCompleteSubscribers(this.hub, this.subscribers);
+        return IO.succeedNow(true);
+      }
 
-/**
- * @tsplus macro remove
- */
-export function concrete<RA, RB, EA, EB, A, B>(
-  _: PHub<RA, RB, EA, EB, A, B>,
-): asserts _ is PHubInternal<RA, RB, EA, EB, A, B> {
-  //
+      return this.strategy.handleSurplus(this.hub, this.subscribers, Conc.single(a), this.shutdownFlag);
+    });
+  }
+
+  publishAll(this: this, as: Iterable<A>, __tsplusTrace?: string): UIO<boolean> {
+    return 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);
+    });
+  }
+
+  shutdown: UIO<void> = IO.deferWith((_, fiberId) => {
+    this.shutdownFlag.set(true);
+    return this.scope
+      .close(Exit.interrupt(fiberId))
+      .apSecond(this.strategy.shutdown)
+      .whenIO(this.shutdownHook.succeed(undefined));
+  }).uninterruptible;
+
+  size: UIO<number> = IO.defer(() => {
+    if (this.shutdownFlag.get) {
+      return IO.interrupt;
+    }
+
+    return IO.succeed(this.hub.size());
+  });
+
+  subscribe: IO<Scope, never, Dequeue<A>> = IO.acquireRelease(
+    makeSubscription(this.hub, this.subscribers, this.strategy).tap((dequeue) =>
+      this.scope.addFinalizer(dequeue.shutdown),
+    ),
+    (dequeue) => dequeue.shutdown,
+  );
+
+  isEmpty: UIO<boolean> = this.size.map((size) => size === 0);
+
+  isFull: UIO<boolean> = this.size.map((size) => size === this.capacity);
+
+  offer(this: this, a: A, __tsplusTrace?: string | undefined): UIO<boolean> {
+    return this.publish(a);
+  }
+
+  offerAll(this: this, as: Iterable<A>, __tsplusTrace?: string | undefined): UIO<boolean> {
+    return this.publishAll(as);
+  }
 }