@fncts/io 0.0.48 → 0.0.49

package/_src/Fiber/api/interruptAs.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus fluent fncts.io.Fiber interruptAsFork
  */
-export function interruptAsFork<E, A>(self: Fiber<E, A>, fiberId: FiberId): UIO<void> {
+export function interruptAsFork<E, A>(self: Fiber<E, A>, fiberId: FiberId, __tsplusTrace?: string): UIO<void> {
   self.concrete();
   return self.interruptAsFork(fiberId);
 }
@@ -9,6 +9,7 @@ export function interruptAsFork<E, A>(self: Fiber<E, A>, fiberId: FiberId): UIO<
 /**
  * @tsplus fluent fncts.io.Fiber interruptAs
  */
-export function interruptAs<E, A>(self: Fiber<E, A>, fiberId: FiberId): UIO<Exit<E, A>> {
-  return self.interruptAsFork(fiberId) > self.await;
+export function interruptAs<E, A>(self: Fiber<E, A>, fiberId: FiberId, __tsplusTrace?: string): UIO<Exit<E, A>> {
+  self.concrete();
+  return self.interruptAs(fiberId);
 }

package/_src/Fiber/constructors.ts

@@ -10,7 +10,7 @@ export function done<E, A>(exit: Exit<E, A>, __tsplusTrace?: string): Fiber<E, A
     IO.succeedNow(Conc()),
     IO.unit,
     IO.succeedNow(Just(exit)),
-    () => IO.succeedNow(exit),
+    () => IO.unit,
   );
 }
 

package/_src/Fiber/definition.ts

@@ -56,6 +56,8 @@ export interface FiberCommon<E, A> extends Fiber<E, A> {
    */
   readonly interruptAsFork: (fiberId: FiberId) => UIO<void>;
 
+  readonly interruptAs: (fiberId: FiberId) => UIO<Exit<E, A>>;
+
   /**
    * Tentatively observes the fiber, but returns immediately if it is not already done.
    */
@@ -114,6 +116,8 @@ export class SyntheticFiber<E, A> implements FiberCommon<E, A> {
   ) {
     this.await = wait;
   }
+
+  interruptAs = (fiberId: FiberId): UIO<Exit<E, A>> => this.interruptAsFork(fiberId) > this.await;
 }
 
 export type ConcreteFiber<E, A> = Fiber.Runtime<E, A> | Fiber.Synthetic<E, A>;

package/_src/FiberScope/definition.ts

@@ -18,6 +18,11 @@ export abstract class FiberScope {
     runtimeFlags: RuntimeFlags,
     child: FiberRuntime<any, any>,
   ): void;
+  abstract unsafeAddAll(
+    currentFiber: FiberRuntime<any, any>,
+    runtimeFlags: RuntimeFlags,
+    children: Iterable<FiberRuntime<any, any>>,
+  ): void;
 }
 
 export class Global extends FiberScope {
@@ -29,6 +34,17 @@ export class Global extends FiberScope {
       Fiber._roots.add(child);
     }
   }
+  unsafeAddAll(
+    _currentFiber: FiberRuntime<any, any>,
+    runtimeFlags: RuntimeFlags,
+    children: Iterable<FiberRuntime<any, any>>,
+  ): void {
+    if (runtimeFlags.fiberRoots) {
+      for (const child of children) {
+        Fiber._roots.add(child);
+      }
+    }
+  }
 }
 
 export class Local extends FiberScope {
@@ -44,10 +60,32 @@ export class Local extends FiberScope {
       if (currentFiber === parent) {
         parent.addChild(child);
       } else {
-        parent.tell(FiberMessage.Stateful((parentFiber) => parentFiber.addChild(child)));
+        parent.tellAddChild(child);
       }
     } else {
-      child.tell(FiberMessage.InterruptSignal(Cause.interrupt(currentFiber.id)));
+      child.tellInterrupt(Cause.interrupt(currentFiber.id));
+    }
+  }
+  unsafeAddAll(
+    currentFiber: FiberRuntime<any, any>,
+    _runtimeFlags: RuntimeFlags,
+    children: Iterable<FiberRuntime<any, any>>,
+  ): void {
+    if (children.isNonEmpty) {
+      const parent = this.parentRef.deref();
+
+      if (parent != null) {
+        if (currentFiber === parent) {
+          parent.addChildren(children);
+        } else {
+          parent.tellAddChildren(children);
+        }
+      } else {
+        const cause = Cause.interrupt(currentFiber.id);
+        for (const child of children) {
+          child.tellInterrupt(cause);
+        }
+      }
     }
   }
 }

package/_src/FiberSet.ts

@@ -5,12 +5,16 @@ export type FiberSetTypeId = typeof FiberSetTypeId;
  * @tsplus type fncts.io.FiberSet
  * @tsplus companion fncts.io.FiberSetOps
  */
-export class FiberSet<E, A> {
+export class FiberSet<E, A> implements Iterable<Fiber<E, A>> {
   readonly [FiberSetTypeId]: FiberSetTypeId = FiberSetTypeId;
   constructor(
     readonly backing: Set<Fiber.Runtime<E, A>>,
     readonly future: Future<unknown, never>,
   ) {}
+
+  [Symbol.iterator](): Iterator<Fiber<E, A>> {
+    return this.backing[Symbol.iterator]();
+  }
 }
 
 /**
@@ -111,5 +115,5 @@ export function join<E, A>(self: FiberSet<E, A>): FIO<E, never> {
  * @tsplus getter fncts.io.FiberSet clear
  */
 export function clear<E, A>(self: FiberSet<E, A>): UIO<void> {
-  return IO.foreach(self.backing, (fiber) => fiber.interrupt) > IO(self.backing.clear());
+  return IO.foreach(self.backing, (fiber) => fiber.interruptFork) > IO(self.backing.clear());
 }

package/_src/Future/State.ts

@@ -0,0 +1,128 @@
+export type FutureState<E, A> = Done<E, A> | Pending<E, A>;
+
+export const enum FutureStateTag {
+  Link,
+  Empty,
+  Done,
+}
+
+export abstract class Pending<E, A> {
+  abstract size: number;
+  abstract complete(io: FIO<E, A>): void;
+  abstract add(waiter: (io: FIO<E, A>) => any): Pending<E, A>;
+  abstract remove(waiter: (io: FIO<E, A>) => any): Pending<E, A>;
+}
+
+export type Concrete<E, A> = Empty | Link<E, A> | Done<E, A>;
+export type ConcretePending<E, A> = Empty | Link<E, A>;
+
+/**
+ * @tsplus fluent fncts.io.Future.State concrete
+ * @tsplus macro remove
+ */
+export function concrete<E, A>(self: State<E, A>): asserts self is Concrete<E, A> {}
+
+/**
+ * @tsplus fluent fncts.io.Future.State concretePending
+ * @tsplus macro remove
+ */
+export function concretePending<E, A>(self: Pending<E, A>): asserts self is ConcretePending<E, A> {}
+
+export class Empty extends Pending<never, never> {
+  readonly _tag = FutureStateTag.Empty;
+  size: number  = 0;
+  complete(_: FIO<never, never>): void {
+    return;
+  }
+  add(waiter: (io: FIO<never, never>) => any): Pending<never, never> {
+    return new Link(waiter, this, 1);
+  }
+  remove(_: (io: FIO<never, never>) => any): Pending<never, never> {
+    return this;
+  }
+}
+
+/**
+ * @tsplus static fncts.io.Future.State Empty
+ */
+export const _Empty = new Empty();
+
+export class Link<E, A> extends Pending<E, A> {
+  readonly _tag = FutureStateTag.Link;
+
+  constructor(
+    readonly waiter: (io: FIO<E, A>) => any,
+    readonly ws: Pending<E, A>,
+    readonly size: number,
+  ) {
+    super();
+  }
+
+  add(waiter: (io: FIO<E, A>) => any): Pending<E, A> {
+    return new Link(waiter, this, this.size + 1);
+  }
+
+  complete(io: FIO<E, A>): void {
+    if (this.size === 1) {
+      return this.waiter(io);
+    } else {
+      let current = this as ConcretePending<E, A>;
+
+      while (current._tag !== FutureStateTag.Empty) {
+        current.waiter(io);
+        current = current.ws as ConcretePending<E, A>;
+      }
+    }
+  }
+
+  remove(waiter: (io: FIO<E, A>) => any): Pending<E, A> {
+    if (this.size === 1) {
+      if (waiter === this.waiter) {
+        return this.ws;
+      } else {
+        return this;
+      }
+    } else {
+      const arr              = materialize(this, this.size);
+      let i                  = this.size - 1;
+      let acc: Pending<E, A> = State.Empty;
+
+      while (i >= 0) {
+        if (arr[i] !== this.waiter) {
+          acc = acc.add(arr[i]) as Pending<E, A>;
+        }
+        i -= 1;
+      }
+
+      return acc;
+    }
+  }
+}
+
+function materialize<E, A>(self: Pending<E, A>, size: number): Array<(io: FIO<E, A>) => any> {
+  const array = new Array<(io: FIO<E, A>) => any>(size);
+  let current = self;
+  let i       = size - 1;
+
+  while (i >= 0) {
+    concretePending(current);
+    if (current._tag === FutureStateTag.Link) {
+      array[i] = current.waiter;
+      current  = current.ws;
+    }
+    i -= 1;
+  }
+
+  return array;
+}
+
+export class Done<E, A> {
+  readonly _tag = FutureStateTag.Done;
+  constructor(readonly value: FIO<E, A>) {}
+}
+
+/**
+ * @tsplus type fncts.io.Future.State
+ * @tsplus companion fncts.io.Future.State
+ */
+export type State<E, A> = Done<E, A> | Pending<E, A>;

package/_src/Future/api.ts

@@ -1,6 +1,7 @@
+import type { Pending } from "./State.js";
 import type { Canceler } from "@fncts/io/IO";
 
-import { Done, FutureStateTag, Pending } from "@fncts/io/Future/definition";
+import { Done, FutureStateTag } from "./State.js";
 
 /**
  * Exits the future with the specified exit, which will be propagated to all
@@ -42,7 +43,7 @@ export function failCause<E>(cause: Cause<E>, __tsplusTrace?: string) {
  * 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
+ * Note that `Future.fulfillWith` will be much faster, so consider using
  * that if you do not need to memoize the result of the specified effect.
  *
  * @tsplus pipeable fncts.io.Future fulfill
@@ -64,27 +65,13 @@ export function fulfill<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string) {
  * 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`.
+ * `Future.fulfill`.
  *
  * @tsplus pipeable fncts.io.Future fulfillWith
  */
 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;
-        }
-      }
-    });
+    return IO(future.unsafeFulfill(io));
   };
 }
 
@@ -122,6 +109,25 @@ export function interruptAs(id: FiberId, __tsplusTrace?: string) {
   };
 }
 
+function interruptJoiner<E, A>(
+  future: Future<E, A>,
+  joiner: (a: FIO<E, A>) => void,
+  __tsplusTrace?: string,
+): Canceler<never> {
+  return IO.succeed(() => {
+    future.state.concrete();
+    switch (future.state._tag) {
+      case FutureStateTag.Done: {
+        break;
+      }
+      default: {
+        future.state = future.state.remove(joiner);
+        break;
+      }
+    }
+  });
+}
+
 /**
  * Checks for completion of this Future. Produces true if this future has
  * already been completed with a value or an error and false otherwise.
@@ -129,6 +135,7 @@ export function interruptAs(id: FiberId, __tsplusTrace?: string) {
  * @tsplus getter fncts.io.Future isDone
  */
 export function isDone<E, A>(future: Future<E, A>, __tsplusTrace?: string): UIO<boolean> {
+  future.state.concrete();
   return IO.succeed(future.state._tag === FutureStateTag.Done);
 }
 
@@ -139,12 +146,13 @@ export function isDone<E, A>(future: Future<E, A>, __tsplusTrace?: string): UIO<
  * @tsplus getter fncts.io.Future poll
  */
 export function poll<E, A>(future: Future<E, A>, __tsplusTrace?: string): UIO<Maybe<FIO<E, A>>> {
-  return IO.succeed(() => {
+  return IO(() => {
+    future.state.concrete();
     switch (future.state._tag) {
       case FutureStateTag.Done: {
         return Just(future.state.value);
       }
-      case FutureStateTag.Pending: {
+      default: {
         return Nothing();
       }
     }
@@ -177,12 +185,28 @@ export function succeedVoid_(a: void, __tsplusTrace?: string) {
  */
 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);
-      });
+    future.unsafeFulfill(io);
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.io.Future unsafeFulfill
+ */
+export function unsafeFulfill<E, A>(io: FIO<E, A>) {
+  return (future: Future<E, A>): boolean => {
+    future.state.concrete();
+
+    switch (future.state._tag) {
+      case FutureStateTag.Link:
+      case FutureStateTag.Empty: {
+        const pending: Pending<E, A> = future.state;
+        future.state                 = new Done(io);
+        pending.complete(io);
+        return true;
+      }
+      default: {
+        return false;
+      }
     }
   };
 }
@@ -191,8 +215,8 @@ export function unsafeDone<E, A>(io: FIO<E, A>, __tsplusTrace?: string) {
  * @tsplus pipeable fncts.io.Future unsafeSucceed
  */
 export function unsafeSucceed<A>(a: A, __tsplusTrace?: string) {
-  return (future: Future<never, A>): void => {
-    future.unsafeDone(IO.succeedNow(a));
+  return (future: Future<never, A>): boolean => {
+    return future.unsafeFulfill(IO.succeedNow(a));
   };
 }
 
@@ -204,40 +228,27 @@ export function unsafeSucceed<A>(a: A, __tsplusTrace?: string) {
  */
 export function wait<E, A>(future: Future<E, A>, __tsplusTrace?: string): IO<never, E, A> {
   return IO.defer(() => {
+    future.state.concrete();
     switch (future.state._tag) {
       case FutureStateTag.Done: {
         return future.state.value;
       }
-      case FutureStateTag.Pending: {
+      default: {
         return IO.asyncInterrupt<never, E, A>((k) => {
+          future.state.concrete();
           switch (future.state._tag) {
             case FutureStateTag.Done: {
-              return Either.right(future.state.value);
+              k(future.state.value);
+              break;
             }
-            case FutureStateTag.Pending: {
-              future.state = new Pending(future.state.joiners.prepend(k));
-              return Either.left(interruptJoiner(future, k));
+            default: {
+              future.state = future.state.add(k);
+              break;
             }
           }
-        }, future.blockingOn);
-      }
-    }
-  });
-}
 
-function interruptJoiner<E, A>(
-  future: Future<E, A>,
-  joiner: (a: FIO<E, A>) => void,
-  __tsplusTrace?: string,
-): Canceler<never> {
-  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;
+          return Either.left(interruptJoiner(future, k));
+        }, future.blockingOn);
       }
     }
   });

package/_src/Future/constructors.ts

@@ -1,4 +1,6 @@
-import { Future, Pending } from "@fncts/io/Future/definition";
+import { Future } from "@fncts/io/Future/definition";
+
+import { State } from "./State.js";
 
 /**
  * Makes a new future to be completed by the fiber creating the future.
@@ -24,5 +26,5 @@ export function makeAs<E, A>(fiberId: FiberId, __tsplusTrace?: string) {
  * @tsplus static fncts.io.FutureOps unsafeMake
  */
 export function unsafeMake<E, A>(fiberId: FiberId) {
-  return new Future<E, A>(new Pending(List.empty()), fiberId);
+  return new Future<E, A>(State.Empty, fiberId);
 }

package/_src/Future/definition.ts

@@ -1,3 +1,5 @@
+import type { State } from "./State.js";
+
 export const FutureTypeId = Symbol.for("fncts.io.Future");
 export type FutureTypeId = typeof FutureTypeId;
 
@@ -24,20 +26,3 @@ export declare namespace Future {
   type ErrorOf<X> = [X] extends [{ [FutureVariance]: { _E: (_: infer E) => infer E } }] ? E : never;
   type ValueOf<X> = [X] extends [{ [FutureVariance]: { _A: (_: infer A) => infer A } }] ? A : never;
 }
-
-export const enum FutureStateTag {
-  Done,
-  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

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

package/_src/Hub/api.ts

@@ -48,6 +48,21 @@ export function contramapIO<A, RC, EC, C>(f: (c: C) => IO<RC, EC, A>, __tsplusTr
   };
 }
 
+/**
+ * Transforms messages published to and taken from the hub using the
+ * specified functions.
+ *
+ * @tsplus pipeable fncts.io.Hub dimap
+ */
+export function dimap<A, B, C, D>(f: (c: C) => A, g: (b: B) => D, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB>(self: PHub<RA, RB, EA, EB, A, B>): PHub<RA, RB, EA, EB, C, D> => {
+    return self.dimapIO(
+      (c) => IO.succeedNow(f(c)),
+      (b) => IO.succeedNow(g(b)),
+    );
+  };
+}
+
 class DimapIO<RA, RB, RC, RD, EA, EB, EC, ED, A, B, C, D> extends PHubInternal<
   RC | RA,
   RD | RB,
@@ -78,21 +93,6 @@ class DimapIO<RA, RB, RC, RD, EA, EB, EC, ED, A, B, C, D> extends PHubInternal<
   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 pipeable fncts.io.Hub dimap
- */
-export function dimap<A, B, C, D>(f: (c: C) => A, g: (b: B) => D, __tsplusTrace?: string) {
-  return <RA, RB, EA, EB>(self: PHub<RA, RB, EA, EB, A, B>): 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.
@@ -110,6 +110,17 @@ export function dimapIO<A, B, RC, EC, C, RD, ED, D>(
   };
 }
 
+/**
+ * Filters messages published to the hub using the specified function.
+ *
+ * @tsplus pipeable fncts.io.Hub filterInput
+ */
+export function filterInput<A>(f: (a: A) => boolean, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, B>(self: PHub<RA, RB, EA, EB, A, B>) => {
+    return self.filterInputIO((a) => IO.succeedNow(f(a)));
+  };
+}
+
 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>,
@@ -145,13 +156,13 @@ export function filterInputIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsp
 }
 
 /**
- * Filters messages published to the hub using the specified function.
+ * Filters messages taken from the hub using the specified function.
  *
- * @tsplus pipeable fncts.io.Hub filterInput
+ * @tsplus pipeable fncts.io.Hub filterOutput
  */
-export function filterInput<A>(f: (a: A) => boolean, __tsplusTrace?: string) {
-  return <RA, RB, EA, EB, B>(self: PHub<RA, RB, EA, EB, A, B>) => {
-    return self.filterInputIO((a) => IO.succeedNow(f(a)));
+export function filterOutput<B>(f: (b: B) => boolean, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, A>(self: PHub<RA, RB, EA, EB, A, B>): PHub<RA, RB, EA, EB, A, B> => {
+    return self.filterOutputIO((b) => IO.succeedNow(f(b)));
   };
 }
 
@@ -188,17 +199,6 @@ export function filterOutputIO<B, R1, E1>(f: (a: B) => IO<R1, E1, boolean>, __ts
   };
 }
 
-/**
- * Filters messages taken from the hub using the specified function.
- *
- * @tsplus pipeable fncts.io.Hub filterOutput
- */
-export function filterOutput<B>(f: (b: B) => boolean, __tsplusTrace?: string) {
-  return <RA, RB, EA, EB, A>(self: PHub<RA, RB, EA, EB, A, B>): PHub<RA, RB, EA, EB, A, B> => {
-    return self.filterOutputIO((b) => IO.succeedNow(f(b)));
-  };
-}
-
 /**
  * Checks whether the hub is shut down.
  *
@@ -287,28 +287,6 @@ export function mapIO<B, RC, EC, C>(f: (b: B) => IO<RC, EC, C>, __tsplusTrace?:
   };
 }
 
-class ToQueue<RA, RB, EA, EB, A, B> implements PEnqueue<RA, RB, EA, EB, A, B> {
-  readonly [QueueTypeId]: QueueTypeId     = QueueTypeId;
-  readonly [EnqueueTypeId]: EnqueueTypeId = EnqueueTypeId;
-  declare [QueueVariance]: {
-    readonly _RA: (_: never) => RA;
-    readonly _RB: (_: never) => RB;
-    readonly _EA: (_: never) => EA;
-    readonly _EB: (_: never) => EB;
-    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());
-}
-
 /**
  * Publishes a message to the hub, returning whether the message was
  * published to the hub.
@@ -345,6 +323,16 @@ export function shutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>,
   return self.shutdown;
 }
 
+/**
+ * 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>, __tsplusTrace?: string): UIO<number> {
+  concrete(self);
+  return self.size;
+}
+
 /**
  * Subscribes to receive messages from the hub. The resulting subscription
  * can be evaluated multiple times within the scope of the managed to take a
@@ -360,14 +348,26 @@ export function subscribe<RA, RB, EA, EB, A, B>(
   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>, __tsplusTrace?: string): UIO<number> {
-  concrete(self);
-  return self.size;
+class ToQueue<RA, RB, EA, EB, A, B> implements PEnqueue<RA, RB, EA, EB, A, B> {
+  readonly [QueueTypeId]: QueueTypeId     = QueueTypeId;
+  readonly [EnqueueTypeId]: EnqueueTypeId = EnqueueTypeId;
+  declare [QueueVariance]: {
+    readonly _RA: (_: never) => RA;
+    readonly _RB: (_: never) => RB;
+    readonly _EA: (_: never) => EA;
+    readonly _EB: (_: never) => EB;
+    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());
 }
 
 /**