@fncts/io 0.0.1

package/_src/Future/api.ts

@@ -0,0 +1,204 @@
+import type { Canceler } from "@fncts/io/IO";
+
+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
+ */
+export function done_<E, A>(future: Future<E, A>, exit: Exit<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
+ */
+export function fail_<E, A>(future: Future<E, A>, e: E): 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
+ */
+export function failCause_<E, A>(future: Future<E, A>, cause: Cause<E>): UIO<boolean> {
+  return future.fulfillWith(IO.failCauseNow(cause));
+}
+
+/**
+ * Completes the future with the result of the specified effect. If the
+ * future has already been completed, the method will produce false.
+ *
+ * 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
+ */
+export function fulfill_<R, E, A>(future: Future<E, A>, io: IO<R, E, A>): IO<R, never, boolean> {
+  return IO.uninterruptibleMask(({ restore }) => restore(io).result.flatMap((exit) => future.done(exit)));
+}
+
+/**
+ * Completes the future with the specified effect. If the future has
+ * already been completed, the method will produce false.
+ *
+ * Note that since the future is completed with an IO, the effect will
+ * be evaluated each time the value of the future is retrieved through
+ * combinators such as `wait`, potentially producing different results if
+ * the effect produces different results on subsequent evaluations. In this
+ * case te meaning of the "exactly once" guarantee of `Future` is that the
+ * future can be completed with exactly one effect. For a version that
+ * completes the future with the result of an IO see
+ * `Future.complete`.
+ *
+ * @tsplus fluent fncts.io.Future fulfillWith
+ */
+export function fulfillWith_<E, A>(future: Future<E, A>, io: FIO<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
+ */
+export function halt_<E, A>(future: Future<E, A>, defect: unknown): UIO<boolean> {
+  return future.fulfillWith(IO.haltNow(defect));
+}
+
+/**
+ * Completes the future with interruption. This will interrupt all fibers
+ * waiting on the value of the future as by the fiber calling this method.
+ *
+ * @tsplus getter fncts.io.Future interrupt
+ */
+export function interrupt<E, A>(future: Future<E, A>): UIO<boolean> {
+  return IO.fiberId.flatMap((id) => future.fulfillWith(IO.interruptAs(id)));
+}
+
+/**
+ * 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
+ */
+export function interruptAs_<E, A>(future: Future<E, A>, id: FiberId): UIO<boolean> {
+  return future.fulfillWith(IO.interruptAs(id));
+}
+
+/**
+ * Checks for completion of this Future. Produces true if this future has
+ * already been completed with a value or an error and false otherwise.
+ *
+ * @tsplus getter fncts.io.Future isDone
+ */
+export function isDone<E, A>(future: Future<E, A>): UIO<boolean> {
+  return IO.succeed(future.state._tag === FutureStateTag.Done);
+}
+
+/**
+ * Checks for completion of this Future. Returns the result effect if this
+ * future has already been completed or a `None` otherwise.
+ *
+ * @tsplus getter fncts.io.Future poll
+ */
+export function poll<E, A>(future: Future<E, A>): UIO<Maybe<FIO<E, A>>> {
+  return IO.succeed(() => {
+    switch (future.state._tag) {
+      case FutureStateTag.Done: {
+        return Just(future.state.value);
+      }
+      case FutureStateTag.Pending: {
+        return Nothing();
+      }
+    }
+  });
+}
+
+/**
+ * Completes the future with the specified value.
+ *
+ * @tsplus fluent fncts.io.Future succeed
+ */
+export function succeed_<A, E>(future: Future<E, A>, a: A) {
+  return 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
+ */
+export function unsafeDone_<E, A>(future: Future<E, A>, io: FIO<E, A>) {
+  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
+ */
+export function unsafeSucceed_<A>(future: Future<never, A>, a: A): void {
+  future.unsafeDone(IO.succeedNow(a));
+}
+
+/**
+ * Retrieves the value of the future, suspending the fiber running the action
+ * until the result is available.
+ *
+ * @tsplus getter fncts.io.Future await
+ */
+export function wait<E, A>(future: Future<E, A>): IO<unknown, E, A> {
+  return IO.asyncInterrupt<unknown, E, A>((k) => {
+    switch (future.state._tag) {
+      case FutureStateTag.Done: {
+        return Either.right(future.state.value);
+      }
+      case FutureStateTag.Pending: {
+        future.state = new Pending(future.state.joiners.prepend(k));
+        return Either.left(interruptJoiner(future, k));
+      }
+    }
+  }, future.blockingOn);
+}
+
+function interruptJoiner<E, A>(future: Future<E, A>, joiner: (a: FIO<E, A>) => void): Canceler<unknown> {
+  return IO.succeed(() => {
+    switch (future.state._tag) {
+      case FutureStateTag.Pending: {
+        future.state = new Pending(future.state.joiners.filter((j) => j !== joiner));
+        break;
+      }
+      case FutureStateTag.Done: {
+        break;
+      }
+    }
+  });
+}

package/_src/Future/constructors.ts

@@ -0,0 +1,28 @@
+import { Pending } from "@fncts/io/Future/definition";
+
+/**
+ * Makes a new future to be completed by the fiber creating the future.
+ *
+ * @tsplus static fncts.io.FutureOps make
+ */
+export function make<E, A>(): IO<unknown, never, Future<E, A>> {
+  return IO.fiberId.flatMap((id) => Future.makeAs<E, A>(id));
+}
+
+/**
+ * Makes a new future to be completed by the fiber with the specified id.
+ *
+ * @tsplus static fncts.io.FutureOps makeAs
+ */
+export function makeAs<E, A>(fiberId: FiberId) {
+  return IO.succeed(unsafeMake<E, A>(fiberId));
+}
+
+/**
+ * Makes a new future to be completed by the fiber with the specified id.
+ *
+ * @tsplus static fncts.io.FutureOps unsafeMake
+ */
+export function unsafeMake<E, A>(fiberId: FiberId) {
+  return new Future<E, A>(new Pending(List.empty()), fiberId);
+}

package/_src/Future/definition.ts

@@ -0,0 +1,24 @@
+/**
+ * @tsplus type fncts.io.Future
+ * @tsplus companion fncts.io.FutureOps
+ */
+export class Future<E, A> {
+  constructor(public state: State<E, A>, readonly blockingOn: FiberId) {}
+}
+
+export const enum FutureStateTag {
+  Done = "Done",
+  Pending = "Pending",
+}
+
+export class Pending<E, A> {
+  readonly _tag = FutureStateTag.Pending;
+  constructor(readonly joiners: List<(_: FIO<E, A>) => void>) {}
+}
+
+export class Done<E, A> {
+  readonly _tag = FutureStateTag.Done;
+  constructor(readonly value: FIO<E, A>) {}
+}
+
+export type State<E, A> = Done<E, A> | Pending<E, A>;

package/_src/Future.ts

@@ -0,0 +1,5 @@
+// codegen:start { preset: barrel, include: Future/*.ts }
+export * from "./Future/api.js";
+export * from "./Future/constructors.js";
+export * from "./Future/definition.js";
+// codegen:end

package/_src/Hub/api.ts

@@ -0,0 +1,434 @@
+import { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
+import { concrete, PHubInternal } from "@fncts/io/Hub/definition";
+import {
+  BackPressure,
+  Dropping,
+  makeHubInternal,
+  Sliding,
+  subscribersHashSet,
+  unsafeMakeHub,
+} from "@fncts/io/Hub/internal";
+import { Hub as HubInternal } from "@fncts/io/internal/Hub";
+import { QueueInternal } from "@fncts/io/Queue";
+
+/**
+ * Waits for the hub to be shut down.
+ *
+ * @tsplus getter fncts.io.Hub awaitShutdown
+ */
+export function awaitShutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): UIO<void> {
+  concrete(self);
+  return self.awaitShutdown;
+}
+
+/**
+ * The maximum capacity of the hub.
+ *
+ * @tsplus getter fncts.io.Hub capacity
+ */
+export function capacity<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): number {
+  concrete(self);
+  return self.capacity;
+}
+
+/**
+ * Transforms messages published to the hub using the specified effectual
+ * function.
+ *
+ * @tsplus fluent fncts.io.Hub contramapIO
+ */
+export function contramapIO_<RA, RB, RC, EA, EB, EC, A, B, C>(
+  self: PHub<RA, RB, EA, EB, A, B>,
+  f: (c: C) => IO<RC, EC, A>,
+): PHub<RC & RA, RB, EA | EC, EB, C, B> {
+  return self.dimapIO(f, IO.succeedNow);
+}
+
+class DimapIO<RA, RB, RC, RD, EA, EB, EC, ED, A, B, C, D> extends PHubInternal<
+  RC & RA,
+  RD & RB,
+  EA | EC,
+  EB | ED,
+  C,
+  D
+> {
+  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();
+  }
+  awaitShutdown = this.source.awaitShutdown;
+  capacity      = this.source.capacity;
+  isShutdown    = this.source.isShutdown;
+  shutdown      = this.source.shutdown;
+  size          = this.source.size;
+  subscribe     = 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));
+}
+
+/**
+ * Transforms messages published to and taken from the hub using the
+ * specified functions.
+ *
+ * @tsplus fluent fncts.io.Hub dimap
+ */
+export function dimap_<RA, RB, EA, EB, A, B, C, D>(
+  self: PHub<RA, RB, EA, EB, A, B>,
+  f: (c: C) => A,
+  g: (b: B) => D,
+): PHub<RA, RB, EA, EB, C, D> {
+  return self.dimapIO(
+    (c) => IO.succeedNow(f(c)),
+    (b) => IO.succeedNow(g(b)),
+  );
+}
+
+/**
+ * Transforms messages published to and taken from the hub using the
+ * specified effectual functions.
+ *
+ * @tsplus fluent fncts.io.Hub dimapIO
+ */
+export function dimapIO_<RA, RB, RC, RD, EA, EB, EC, ED, A, B, C, D>(
+  source: PHub<RA, RB, EA, EB, A, B>,
+  f: (c: C) => IO<RC, EC, A>,
+  g: (b: B) => IO<RD, ED, D>,
+): PHub<RC & RA, RD & RB, EA | EC, EB | ED, C, D> {
+  concrete(source);
+  return new DimapIO(source, f, g);
+}
+
+class FilterInputIO<RA, RA1, RB, EA, EA1, EB, A, B> extends PHubInternal<RA & RA1, RB, EA | EA1, EB, A, B> {
+  constructor(readonly source: PHubInternal<RA, RB, EA, EB, A, B>, readonly f: (a: A) => IO<RA1, EA1, boolean>) {
+    super();
+  }
+  awaitShutdown = this.source.awaitShutdown;
+  capacity      = this.source.capacity;
+  isShutdown    = this.source.isShutdown;
+  shutdown      = this.source.shutdown;
+  size          = this.source.size;
+  subscribe     = 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)));
+}
+
+/**
+ * Filters messages published to the hub using the specified effectual
+ * function.
+ *
+ * @tsplus fluent fncts.io.Hub filterInputIO
+ */
+export function filterInputIO_<RA, RA1, RB, EA, EA1, EB, A, B>(
+  source: PHub<RA, RB, EA, EB, A, B>,
+  f: (a: A) => IO<RA1, EA1, boolean>,
+): PHub<RA & RA1, RB, EA | EA1, EB, A, B> {
+  concrete(source);
+  return new FilterInputIO(source, f);
+}
+
+/**
+ * Filters messages published to the hub using the specified function.
+ *
+ * @tsplus fluent fncts.io.Hub filterInput
+ */
+export function filterInput_<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, f: (a: A) => boolean) {
+  return self.filterInputIO((a) => IO.succeedNow(f(a)));
+}
+
+class FilterOutputIO<RA, RB, RB1, EA, EB, EB1, A, B> extends PHubInternal<RA, RB & RB1, EA, EB | EB1, A, B> {
+  constructor(readonly source: PHubInternal<RA, RB, EA, EB, A, B>, readonly f: (a: B) => IO<RB1, EB1, boolean>) {
+    super();
+  }
+  awaitShutdown = this.source.awaitShutdown;
+  capacity      = this.source.capacity;
+  isShutdown    = this.source.isShutdown;
+  shutdown      = this.source.shutdown;
+  size          = this.source.size;
+  subscribe     = 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 fluent fncts.io.Hub filterOutputIO
+ */
+export function filterOutputIO_<RA, RB, RB1, EA, EB, EB1, A, B>(
+  source: PHub<RA, RB, EA, EB, A, B>,
+  f: (a: B) => IO<RB1, EB1, boolean>,
+): PHub<RA, RB & RB1, EA, EB | EB1, A, B> {
+  concrete(source);
+  return new FilterOutputIO(source, f);
+}
+
+/**
+ * Filters messages taken from the hub using the specified function.
+ *
+ * @tsplus fluent fncts.io.Hub filterOutput
+ */
+export function filterOutput_<RA, RB, EA, EB, A, B>(
+  self: PHub<RA, RB, EA, EB, A, B>,
+  f: (b: B) => boolean,
+): PHub<RA, RB, EA, EB, A, B> {
+  return self.filterOutputIO((b) => IO.succeedNow(f(b)));
+}
+
+/**
+ * Checks whether the hub is shut down.
+ *
+ * @tsplus getter fncts.io.Hub isShutdown
+ */
+export function isShutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): UIO<boolean> {
+  concrete(self);
+  return self.isShutdown;
+}
+
+/**
+ * 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): UIO<Hub<A>> {
+  return IO.succeed(HubInternal.makeBounded<A>(requestedCapacity)).flatMap((hub) =>
+    makeHubInternal(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): UIO<Hub<A>> {
+  return IO.succeed(HubInternal.makeBounded<A>(requestedCapacity)).flatMap((hub) =>
+    makeHubInternal(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): UIO<Hub<A>> {
+  return IO.succeed(HubInternal.makeBounded<A>(requestedCapacity)).flatMap((hub) =>
+    makeHubInternal(hub, new Sliding()),
+  );
+}
+
+/**
+ * Creates an unbounded hub.
+ *
+ * @tsplus static fncts.io.HubOps makeUnbounded
+ */
+export function makeUnbounded<A>(): UIO<Hub<A>> {
+  return IO.succeed(HubInternal.makeUnbounded<A>()).flatMap((hub) => makeHubInternal(hub, new Dropping()));
+}
+
+/**
+ * Transforms messages taken from the hub using the specified function.
+ *
+ * @tsplus fluent fncts.io.Hub map
+ */
+export function map_<RA, RB, EA, EB, A, B, C>(
+  self: PHub<RA, RB, EA, EB, A, B>,
+  f: (b: B) => C,
+): PHub<RA, RB, EA, EB, A, C> {
+  return self.mapIO((b) => IO.succeedNow(f(b)));
+}
+
+/**
+ * Transforms messages taken from the hub using the specified effectual
+ * function.
+ *
+ * @tsplus fluent fncts.io.Hub mapIO
+ */
+export function mapIO_<RA, RB, RC, EA, EB, EC, A, B, C>(
+  self: PHub<RA, RB, EA, EB, A, B>,
+  f: (b: B) => IO<RC, EC, C>,
+): PHub<RA, RC & RB, EA, EB | EC, A, C> {
+  return self.dimapIO(IO.succeedNow, f);
+}
+
+class ToQueue<RA, RB, EA, EB, A, B> extends QueueInternal<RA, never, EA, unknown, A, never> {
+  constructor(readonly source: PHubInternal<RA, RB, EA, EB, A, B>) {
+    super();
+  }
+  awaitShutdown = this.source.awaitShutdown;
+  capacity      = this.source.capacity;
+  isShutdown    = this.source.isShutdown;
+  shutdown      = this.source.shutdown;
+  size          = this.source.size;
+  take          = IO.never;
+  takeAll       = IO.succeedNow(Conc.empty<never>());
+  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<unknown, never, Conc<never>> => IO.succeedNow(Conc.empty());
+}
+
+/**
+ * Publishes a message to the hub, returning whether the message was
+ * published to the hub.
+ *
+ * @tsplus fluent fncts.io.Hub publish
+ */
+export function publish_<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, a: A): IO<RA, EA, boolean> {
+  concrete(self);
+  return self.publish(a);
+}
+
+/**
+ * Publishes all of the specified messages to the hub, returning whether
+ * they were published to the hub.
+ *
+ * @tsplus fluent fncts.io.Hub publishAll
+ */
+export function publishAll_<RA, RB, EA, EB, A, B>(
+  self: PHub<RA, RB, EA, EB, A, B>,
+  as: Iterable<A>,
+): IO<RA, EA, boolean> {
+  concrete(self);
+  return self.publishAll(as);
+}
+
+/**
+ * Shuts down the hub.
+ *
+ * @tsplus getter fncts.io.Hub shutdown
+ */
+export function shutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): UIO<void> {
+  concrete(self);
+  return self.shutdown;
+}
+
+/**
+ * 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.
+ *
+ * @tsplus getter fncts.io.Hub subscribe
+ */
+export function subscribe<RA, RB, EA, EB, A, B>(
+  self: PHub<RA, RB, EA, EB, A, B>,
+): IO<Has<Scope>, never, Hub.Dequeue<RB, EB, B>> {
+  concrete(self);
+  return self.subscribe;
+}
+
+/**
+ * The current number of messages in the hub.
+ *
+ * @tsplus getter fncts.io.Hub size
+ */
+export function size<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): UIO<number> {
+  concrete(self);
+  return self.size;
+}
+
+/**
+ * Views the hub as a queue that can only be written to.
+ *
+ * @tsplus getter fncts.io.Hub toQueue
+ */
+export function toQueue<RA, RB, EA, EB, A, B>(source: PHub<RA, RB, EA, EB, A, B>): Hub.Enqueue<RA, EA, A> {
+  concrete(source);
+  return new ToQueue(source);
+}
+
+/**
+ * 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 unsafeMakeBounded
+ */
+export function unsafeMakeBounded<A>(requestedCapacity: number): Hub<A> {
+  const scope = Scope.unsafeMake();
+
+  return unsafeMakeHub(
+    HubInternal.makeBounded<A>(requestedCapacity),
+    subscribersHashSet<A>(),
+    scope,
+    Future.unsafeMake<never, void>(FiberId.none),
+    new AtomicBoolean(false),
+    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 unsafeMakeDropping
+ */
+export function unsafeMakeDropping<A>(requestedCapacity: number): Hub<A> {
+  const scope = Scope.unsafeMake();
+
+  return unsafeMakeHub(
+    HubInternal.makeBounded<A>(requestedCapacity),
+    subscribersHashSet<A>(),
+    scope,
+    Future.unsafeMake<never, void>(FiberId.none),
+    new AtomicBoolean(false),
+    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 unsafeMakeSliding
+ */
+export function unsafeMakeSliding<A>(requestedCapacity: number): Hub<A> {
+  const scope = Scope.unsafeMake();
+
+  return unsafeMakeHub(
+    HubInternal.makeBounded<A>(requestedCapacity),
+    subscribersHashSet<A>(),
+    scope,
+    Future.unsafeMake<never, void>(FiberId.none),
+    new AtomicBoolean(false),
+    new Sliding(),
+  );
+}
+
+/**
+ * Creates an unbounded hub.
+ *
+ * @tsplus static fncts.io.HubOps unsafeMakeUnbounded
+ */
+export function unsafeMakeUnbounded<A>(): Hub<A> {
+  const scope = Scope.unsafeMake();
+
+  return unsafeMakeHub(
+    HubInternal.makeUnbounded<A>(),
+    subscribersHashSet<A>(),
+    scope,
+    Future.unsafeMake<never, void>(FiberId.none),
+    new AtomicBoolean(false),
+    new Dropping(),
+  );
+}