@fncts/io 0.0.40 → 0.0.42

package/_src/Queue/api/filterOutputIO.ts

@@ -16,6 +16,14 @@ class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInternal<RA, R
 
   isShutdown: UIO<boolean> = this.queue.isShutdown;
 
+  get unsafeSize(): Maybe<number> {
+    return this.queue.unsafeSize;
+  }
+
+  unsafeOffer(a: A): boolean {
+    throw new Error("Cannot unsafely offer to an effectful Queue");
+  }
+
   offer(a: A): IO<RA, EA, boolean> {
     return this.queue.offer(a);
   }
@@ -104,6 +112,14 @@ class FilterOutputDequeueIO<RA, RB, EA, EB, A, B, RB1, EB1>
 
   size: UIO<number> = this.queue.size;
 
+  get unsafeSize(): Maybe<number> {
+    return this.queue.unsafeSize;
+  }
+
+  unsafeOffer(a: A): boolean {
+    throw new Error("Cannot unsafely offer to an effectful Queue");
+  }
+
   take: IO<RB | RB1, EB1 | EB, B> = this.queue.take.flatMap((b) =>
     this.f(b).flatMap((p) => (p ? IO.succeedNow(b) : this.take)),
   );

package/_src/Queue/api/operations.ts

@@ -43,6 +43,18 @@ export function isShutdown<RA, RB, EA, EB, A, B>(
   return queue.isShutdown;
 }
 
+/**
+ * Places one value in the queue.
+ *
+ * @tsplus pipeable fncts.io.Queue unsafeOffer
+ */
+export function unsafeOffer<A>(a: A, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, B>(queue: PEnqueue<RA, RB, EA, EB, A, B>): boolean => {
+    concrete(queue);
+    return queue.unsafeOffer(a);
+  };
+}
+
 /**
  * Places one value in the queue.
  *
@@ -103,6 +115,14 @@ export function size<RA, RB, EA, EB, A, B>(queue: PQueueCommon<RA, RB, EA, EB, A
   return queue.size;
 }
 
+/**
+ * @tsplus getter fncts.io.Queue unsafeSize
+ */
+export function unsafeSize<RA, RB, EA, EB, A, B>(queue: PQueueCommon<RA, RB, EA, EB, A, B>, __tsplusTrace?: string) {
+  concrete(queue);
+  return queue.unsafeSize;
+}
+
 /**
  * Removes the oldest value in the queue. If the queue is empty, this will
  * return a computation that resumes when an item has been added to the queue.

package/_src/Queue/api/zipWithIO.ts

@@ -23,6 +23,14 @@ class ZipWithIO<RA, RB, EA, EB, A, B, RA1, RB1, EA1, EB1, A1 extends A, B1, R3,
 
   isShutdown: UIO<boolean> = this.fa.isShutdown;
 
+  get unsafeSize(): Maybe<number> {
+    return this.fa.unsafeSize.zipWith(this.fb.unsafeSize, (a, b) => Math.max(a, b));
+  }
+
+  unsafeOffer(a: A): boolean {
+    throw new Error("Cannot unsafely offer to an effectful Queue");
+  }
+
   offer(a: A1): IO<RA | RA1, EA1 | EA, boolean> {
     return this.fa.offer(a).zipWithConcurrent(this.fb.offer(a), (x, y) => x && y);
   }

package/_src/Queue/definition.ts

@@ -113,6 +113,7 @@ export abstract class QueueInternal<RA, RB, EA, EB, A, B>
    * `true` if `shutdown` has been called.
    */
   abstract readonly isShutdown: UIO<boolean>;
+  abstract unsafeOffer(a: A): boolean;
   /**
    * Places one value in the queue.
    */
@@ -140,6 +141,7 @@ export abstract class QueueInternal<RA, RB, EA, EB, A, B>
    * Future calls to `offer*` and `take*` will be interrupted immediately.
    */
   abstract readonly shutdown: UIO<void>;
+  abstract readonly unsafeSize: Maybe<number>;
   /**
    * Retrieves the size of the queue, which is equal to the number of elements
    * in the queue. This may be negative if fibers are suspended waiting for
@@ -211,6 +213,7 @@ export interface PQueueCommonInternal<RA, RB, EA, EB, A, B> {
    * Future calls to `offer*` and `take*` will be interrupted immediately.
    */
   readonly shutdown: UIO<void>;
+  readonly unsafeSize: Maybe<number>;
   /**
    * Retrieves the size of the queue, which is equal to the number of elements
    * in the queue. This may be negative if fibers are suspended waiting for
@@ -221,6 +224,7 @@ export interface PQueueCommonInternal<RA, RB, EA, EB, A, B> {
 
 export interface PEnqueueInternal<RA, RB, EA, EB, A, B> extends PQueueCommonInternal<RA, RB, EA, EB, A, B> {
   readonly [EnqueueTypeId]: EnqueueTypeId;
+  unsafeOffer(a: A): boolean;
   /**
    * Places one value in the queue.
    */

package/_src/Queue/internal.ts

@@ -22,6 +22,38 @@ class UnsafeQueue<A> extends QueueInternal<never, never, never, never, A, A> {
 
   isShutdown: UIO<boolean> = IO.succeed(this.shutdownFlag.get);
 
+  get unsafeSize(): Maybe<number> {
+    if (this.shutdownFlag.get) {
+      return Nothing();
+    }
+    return Just(this.queue.size - this.takers.size + this.strategy.surplusSize);
+  }
+
+  unsafeOffer(a: A): boolean {
+    if (this.shutdownFlag.get) {
+      return false;
+    }
+    let noRemaining: boolean;
+    if (this.queue.size === 0) {
+      const taker = this.takers.dequeue(undefined);
+
+      if (taker != null) {
+        unsafeCompletePromise(taker, a);
+        noRemaining = true;
+      } else {
+        noRemaining = false;
+      }
+    } else {
+      noRemaining = false;
+    }
+    if (noRemaining) {
+      return true;
+    }
+    const succeeded = this.queue.enqueue(a);
+    unsafeCompleteTakers(this.strategy, this.queue, this.takers);
+    return succeeded;
+  }
+
   offer(a: A, __tsplusTrace?: string): IO<never, never, boolean> {
     return IO.defer(() => {
       if (this.shutdownFlag.get) {

package/_src/STM/definition.ts

@@ -25,7 +25,7 @@ export type STMTypeId = typeof STMTypeId;
  */
 export abstract class STM<R, E, A> {
   readonly [IOTypeId]: IOTypeId = IOTypeId;
-  readonly _tag                 = IOTag.Commit;
+  readonly _ioOpCode            = IOTag.Commit;
   readonly trace?: string;
   readonly [STMTypeId]: STMTypeId = STMTypeId;
   declare [IOVariance]: {

package/_src/Stream/api.ts

@@ -1592,6 +1592,26 @@ export function fromChunk<O>(c: Lazy<Conc<O>>, __tsplusTrace?: string): Stream<n
   return new Stream(Channel.unwrap(IO.succeedNow(Channel.write(c))));
 }
 
+/**
+ * @tsplus static fncts.io.StreamOps fromReadableStream
+ */
+export function fromReadableStream<A, E>(
+  evaluate: Lazy<ReadableStream<A>>,
+  onError: (error: unknown) => E,
+): Stream<never, E, A> {
+  return Stream.unwrapScoped(
+    IO(evaluate().getReader())
+      .acquireRelease((reader) => IO.fromPromiseHalt(reader.cancel()))
+      .map((reader) =>
+        Stream.repeatIOMaybe(
+          IO.fromPromiseCatch(reader.read(), (reason) => Just(onError(reason))).flatMap(({ done, value }) =>
+            done ? IO.failNow(Nothing()) : IO.succeedNow(value),
+          ),
+        ),
+      ),
+  );
+}
+
 /**
  * Creates a single-valued stream from a managed resource
  *
@@ -3286,6 +3306,41 @@ export function toQueueUnbounded<R, E, A>(
   });
 }
 
+/**
+ * @tsplus getter fncts.io.Stream toReadableStream
+ */
+export function toReadableStream<E, A>(self: Stream<never, E, A>, __tsplusTrace?: string): ReadableStream<A> {
+  let pull: UIO<void>;
+  let scope: Scope.Closeable;
+  return new ReadableStream<A>({
+    start(controller) {
+      scope = Scope.make.unsafeRun.getOrThrow;
+      pull  = self.toPull
+        .provideScope(scope)
+        .unsafeRun.getOrThrow.tap((chunk) =>
+          IO(
+            chunk.forEach((a) => {
+              controller.enqueue(a);
+            }),
+          ),
+        )
+        .tapErrorCause(() => scope.close(Exit.unit))
+        .catchAll((error) =>
+          error.match(
+            () => IO(controller.close()),
+            (error) => IO(controller.error(error)),
+          ),
+        ).asUnit;
+    },
+    pull() {
+      return pull.unsafeRunPromise();
+    },
+    cancel() {
+      return scope.close(Exit.unit).unsafeRunPromise();
+    },
+  });
+}
+
 function unfoldChunkIOLoop<S, R, E, A>(
   s: S,
   f: (s: S) => IO<R, E, Maybe<readonly [Conc<A>, S]>>,

package/_src/global.ts

@@ -51,6 +51,10 @@ import { FiberRefs } from "@fncts/io/FiberRefs";
  * @tsplus global
  */
 import { FiberScope } from "@fncts/io/FiberScope";
+/**
+ * @tsplus global
+ */
+import { FiberSet } from "@fncts/io/FiberSet";
 /**
  * @tsplus global
  */

package/_src/internal/BackgroundScheduler.ts

@@ -203,7 +203,6 @@ export class BackgroundScheduler implements Scheduler {
     if (this.callbacks.length === 0) {
       const channel = new MessageChannel();
       channel.port2.postMessage(undefined);
-      // @ts-expect-error
       channel.port1.onmessage = (): void => {
         channel.port1.close();
         channel.port2.close();

package/global.d.ts

@@ -50,6 +50,10 @@ import { FiberRefs } from "@fncts/io/FiberRefs";
  * @tsplus global
  */
 import { FiberScope } from "@fncts/io/FiberScope";
+/**
+ * @tsplus global
+ */
+import { FiberSet } from "@fncts/io/FiberSet";
 /**
  * @tsplus global
  */

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@fncts/io",
-  "version": "0.0.40",
+  "version": "0.0.42",
   "dependencies": {
-    "@fncts/base": "0.0.33",
-    "@fncts/transformers": "0.0.7",
-    "@fncts/typelevel": "0.0.16"
+    "@fncts/base": "0.0.34",
+    "@fncts/transformers": "0.0.8",
+    "@fncts/typelevel": "0.0.17"
   },
   "exports": {
     "./*": {