@fncts/io 0.0.41 → 0.0.43

package/_src/Stream/api.ts

@@ -3,7 +3,7 @@ import type { Canceler } from "../IO.js";
 import type { PDequeue, PEnqueue, PQueue } from "../Queue.js";
 import type { SinkEndReason } from "./internal/SinkEndReason.js";
 
-import { constVoid, identity, tuple } from "@fncts/base/data/function";
+import { identity, tuple } from "@fncts/base/data/function";
 
 import { MergeDecision } from "../Channel/internal/MergeDecision.js";
 import { Hub } from "../Hub.js";
@@ -56,9 +56,7 @@ export function aggregateAsyncWithin<R1, E1, A1, B, R2, C>(
   __tsplusTrace?: string,
 ) {
   return <R, E, A extends A1>(stream: Stream<R, E, A>): Stream<R | R1 | R2, E | E1, B> => {
-    return stream
-      .aggregateAsyncWithinEither(sink, schedule)
-      .filterMap((cb) => cb.match({ Left: () => Nothing(), Right: Maybe.just }));
+    return stream.aggregateAsyncWithinEither(sink, schedule).filterMap((cb) => cb.match(() => Nothing(), Maybe.just));
   };
 }
 
@@ -167,14 +165,14 @@ export function aggregateAsyncWithinEither<R1, E1, A1, B, R2, C>(
             (scheduleExit, sinkFiber) =>
               IO.fromExit(scheduleExit).matchCauseIO(
                 (cause) =>
-                  cause.failureOrCause.match({
-                    Left: () =>
+                  cause.failureOrCause.match(
+                    () =>
                       handoff.offer(HandoffSignal.End(new ScheduleEnd())).forkDaemon >
                       sinkFiber.join.map(([leftovers, b]) => handleSide(leftovers, b, Nothing())),
-                    Right: (cause) =>
+                    (cause) =>
                       handoff.offer(HandoffSignal.Halt(cause)).forkDaemon >
                       sinkFiber.join.map(([leftovers, b]) => handleSide(leftovers, b, Nothing())),
-                  }),
+                  ),
                 (c) =>
                   handoff.offer(HandoffSignal.End(new ScheduleEnd())).forkDaemon >
                   sinkFiber.join.map(([leftovers, b]) => handleSide(leftovers, b, Just(c))),
@@ -257,8 +255,8 @@ export function asyncInterrupt<R, E, A>(
           }),
         ),
       );
-      return eitherStream.match({
-        Left: (canceler) => {
+      return eitherStream.match(
+        (canceler) => {
           const loop: Channel<never, unknown, unknown, unknown, E, Conc<A>, void> = Channel.unwrap(
             output.take
               .flatMap((take) => take.done)
@@ -269,8 +267,8 @@ export function asyncInterrupt<R, E, A>(
           );
           return new Stream(loop).ensuring(canceler);
         },
-        Right: (stream) => Stream.unwrap(output.shutdown.as(stream)),
-      });
+        (stream) => Stream.unwrap(output.shutdown.as(stream)),
+      );
     }),
   );
 }
@@ -338,10 +336,10 @@ export function asyncIO<R, E, A, R1 = R, E1 = E>(
             .matchCauseIO(
               (cause) =>
                 output.shutdown.as(
-                  cause.failureOrCause.match({
-                    Left: (maybeError) => maybeError.match(() => Channel.endNow(undefined), Channel.failNow),
-                    Right: Channel.failCauseNow,
-                  }),
+                  cause.failureOrCause.match(
+                    (maybeError) => maybeError.match(() => Channel.endNow(undefined), Channel.failNow),
+                    Channel.failCauseNow,
+                  ),
                 ),
               (as) => IO.succeed(Channel.writeNow(as) > loop),
             ),
@@ -579,7 +577,7 @@ function bufferSignalConsumer<R, E, A>(
  */
 export function catchAll<R1, E, E1, A1>(f: (e: E) => Stream<R1, E1, A1>, __tsplusTrace?: string) {
   return <R, A>(stream: Stream<R, E, A>): Stream<R | R1, E1, A | A1> => {
-    return stream.catchAllCause((cause) => cause.failureOrCause.match({ Left: f, Right: Stream.failCauseNow }));
+    return stream.catchAllCause((cause) => cause.failureOrCause.match(f, Stream.failCauseNow));
   };
 }
 
@@ -1592,6 +1590,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
  *
@@ -3210,7 +3228,7 @@ export function toPull<R, E, A>(
   __tsplusTrace?: string,
 ): IO<R | Scope, never, IO<R, Maybe<E>, Conc<A>>> {
   return stream.channel.toPull.map((io) =>
-    io.mapError(Maybe.just).flatMap((r) => r.match({ Left: () => IO.failNow(Nothing()), Right: IO.succeedNow })),
+    io.mapError(Maybe.just).flatMap((r) => r.match(() => IO.failNow(Nothing()), IO.succeedNow)),
   );
 }
 
@@ -3286,6 +3304,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]>>,
@@ -3432,22 +3485,22 @@ export function zipWithLatest<A, R1, E1, B, C>(fb: Stream<R1, E1, B>, f: (a: A,
                 Stream.repeatIOMaybe(left)
                   .mergeEither(Stream.repeatIOMaybe(right))
                   .mapIO((ab) =>
-                    ab.match({
-                      Left: (leftChunk) =>
+                    ab.match(
+                      (leftChunk) =>
                         latest.modify(([_, rightLatest]) =>
                           tuple(
                             leftChunk.map((a) => f(a, rightLatest)),
                             tuple(leftChunk.unsafeGet(leftChunk.length - 1), rightLatest),
                           ),
                         ),
-                      Right: (rightChunk) =>
+                      (rightChunk) =>
                         latest.modify(([leftLatest, _]) =>
                           tuple(
                             rightChunk.map((b) => f(leftLatest, b)),
                             tuple(leftLatest, rightChunk.unsafeGet(rightChunk.length - 1)),
                           ),
                         ),
-                    }),
+                    ),
                   )
                   .flatMap(Stream.fromChunkNow),
               ),

package/_src/TRef/definition.ts

@@ -162,8 +162,8 @@ export class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
       (getEither, setEither, value, atomic) =>
         new Derived((f) =>
           f(
-            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
-            (c) => ca(c).flatMap((a) => setEither(a).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
+            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
+            (c) => ca(c).flatMap((a) => setEither(a).match((e) => Either.left(ea(e)), Either.right)),
             value,
             atomic,
           ),
@@ -181,11 +181,11 @@ export class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
       (getEither, setEither, value, atomic) =>
         new DerivedAll((f) =>
           f(
-            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
+            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
             (c) => (s) =>
               getEither(s)
-                .match({ Left: (e) => Either.left(ec(e)), Right: ca(c) })
-                .flatMap((a) => setEither(a).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
+                .match((e) => Either.left(ec(e)), ca(c))
+                .flatMap((a) => setEither(a).match((e) => Either.left(ea(e)), Either.right)),
             value,
             atomic,
           ),
@@ -195,29 +195,27 @@ export class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
 
   get get(): STM<never, EB, B> {
     return this.use((getEither, _setEither, value, _atomic) =>
-      value.get.flatMap((s) => getEither(s).match({ Left: STM.failNow, Right: STM.succeedNow })),
+      value.get.flatMap((s) => getEither(s).match(STM.failNow, STM.succeedNow)),
     );
   }
 
   set(a: A, __tsplusTrace?: string | undefined): STM<never, EA, void> {
-    return this.use((_getEither, setEither, value, _atomic) =>
-      setEither(a).match({ Left: STM.failNow, Right: (s) => value.set(s) }),
-    );
+    return this.use((_getEither, setEither, value, _atomic) => setEither(a).match(STM.failNow, (s) => value.set(s)));
   }
 
   modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): STM<never, EA | EB, C> {
     return this.use((getEither, setEither, value, _atomic) =>
       value.modify((s) =>
-        getEither(s).match({
-          Left: (e) => [Either.left<EA | EB, C>(e), s],
-          Right: (a1) => {
+        getEither(s).match(
+          (e) => [Either.left<EA | EB, C>(e), s],
+          (a1) => {
             const [b, a2] = f(a1);
-            return setEither(a2).match({
-              Left: (e) => [Either.left(e), s],
-              Right: (s) => [Either.right(b), s],
-            });
+            return setEither(a2).match(
+              (e) => [Either.left(e), s],
+              (s) => [Either.right(b), s],
+            );
           },
-        }),
+        ),
       ),
     ).absolve;
   }
@@ -258,9 +256,8 @@ export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
       (getEither, setEither, value, atomic) =>
         new DerivedAll((f) =>
           f(
-            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
-            (c) => (s) =>
-              ca(c).flatMap((a) => setEither(a)(s).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
+            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
+            (c) => (s) => ca(c).flatMap((a) => setEither(a)(s).match((e) => Either.left(ea(e)), Either.right)),
             value,
             atomic,
           ),
@@ -278,11 +275,11 @@ export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
       (getEither, setEither, value, atomic) =>
         new DerivedAll((f) =>
           f(
-            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
+            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
             (c) => (s) =>
               getEither(s)
-                .match({ Left: (e) => Either.left(ec(e)), Right: ca(c) })
-                .flatMap((a) => setEither(a)(s).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
+                .match((e) => Either.left(ec(e)), ca(c))
+                .flatMap((a) => setEither(a)(s).match((e) => Either.left(ea(e)), Either.right)),
             value,
             atomic,
           ),
@@ -292,17 +289,17 @@ export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
 
   get get(): STM<never, EB, B> {
     return this.use((getEither, _setEither, value, _atomic) =>
-      value.get.flatMap((s) => getEither(s).match({ Left: STM.failNow, Right: STM.succeedNow })),
+      value.get.flatMap((s) => getEither(s).match(STM.failNow, STM.succeedNow)),
     );
   }
 
   set(a: A, __tsplusTrace?: string | undefined): STM<never, EA, void> {
     return this.use((_getEither, setEither, value, _atomic) =>
       value.modify((s) =>
-        setEither(a)(s).match({
-          Left: (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
-          Right: (s) => [Either.right(undefined), s],
-        }),
+        setEither(a)(s).match(
+          (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
+          (s) => [Either.right(undefined), s],
+        ),
       ),
     ).absolve;
   }
@@ -310,16 +307,16 @@ export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
   modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): STM<never, EA | EB, C> {
     return this.use((getEither, setEither, value, atomic) =>
       value.modify((s) =>
-        getEither(s).match({
-          Left: (e) => [Either.left<EA | EB, C>(e), s],
-          Right: (a1) => {
+        getEither(s).match(
+          (e) => [Either.left<EA | EB, C>(e), s],
+          (a1) => {
             const [b, a2] = f(a1);
-            return setEither(a2)(s).match({
-              Left: (e) => [Either.left(e), s],
-              Right: (s) => [Either.right(b), s],
-            });
+            return setEither(a2)(s).match(
+              (e) => [Either.left(e), s],
+              (s) => [Either.right(b), s],
+            );
           },
-        }),
+        ),
       ),
     ).absolve;
   }

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/index.ts

@@ -38,6 +38,7 @@ export type {} from "./IO.js";
 export type {} from "./Hub.js";
 export type {} from "./Future.js";
 export type {} from "./FiberStatus.js";
+export type {} from "./FiberSet.js";
 export type {} from "./FiberScope.js";
 export type {} from "./FiberRefs.js";
 export type {} from "./FiberRef.js";

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/index.d.ts

@@ -36,6 +36,7 @@ export type {} from "./IO.js";
 export type {} from "./Hub.js";
 export type {} from "./Future.js";
 export type {} from "./FiberStatus.js";
+export type {} from "./FiberSet.js";
 export type {} from "./FiberScope.js";
 export type {} from "./FiberRefs.js";
 export type {} from "./FiberRef.js";

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@fncts/io",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "dependencies": {
-    "@fncts/base": "0.0.33",
-    "@fncts/transformers": "0.0.7",
-    "@fncts/typelevel": "0.0.16"
+    "@fncts/base": "0.0.35",
+    "@fncts/transformers": "0.0.9",
+    "@fncts/typelevel": "0.0.18"
   },
   "exports": {
     "./*": {