@fncts/io 0.0.31 → 0.0.32

package/_src/IO/api/provideSomeLayer.ts

@@ -1,11 +1,9 @@
-import type { Spreadable } from "@fncts/base/types";
-import type { Erase } from "@fncts/typelevel/Intersection";
 /**
  * @tsplus static fncts.io.IOAspects provideSomeLayer
  * @tsplus pipeable fncts.io.IO provideSomeLayer
  */
 export function provideSomeLayer<RIn, E1, ROut>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string) {
-  return <R, E, A>(self: IO<R, E, A>): IO<RIn & Erase<R, ROut>, E | E1, A> => {
+  return <R, E, A>(self: IO<R, E, A>): IO<RIn | Exclude<R, ROut>, E | E1, A> => {
     // @ts-expect-error
     return self.provideLayer(Layer.environment<RIn>().and(layer));
   };

package/_src/IO/api/raceWith.ts

@@ -31,15 +31,13 @@ export function raceFibersWith<R, E, A, R1, E1, B, R2, E2, C, R3, E3, D>(
       const raceIndicator = new AtomicBoolean(true);
       const leftFiber     = IO.unsafeMakeChildFiber(left, parentState, parentRuntimeFlags, null, __tsplusTrace);
       const rightFiber    = IO.unsafeMakeChildFiber(right0, parentState, parentRuntimeFlags, null, __tsplusTrace);
-      leftFiber.setFiberRef(FiberRef.forkScopeOverride, Just(parentState.scope));
-      rightFiber.setFiberRef(FiberRef.forkScopeOverride, Just(parentState.scope));
 
       return IO.async((cb) => {
         leftFiber.addObserver(() => complete(leftFiber, rightFiber, leftWins, raceIndicator, cb));
         rightFiber.addObserver(() => complete(rightFiber, leftFiber, rightWins, raceIndicator, cb));
         leftFiber.startFork(left);
         rightFiber.startFork(right0);
-      });
+      }, leftFiber.fiberId.combine(rightFiber.fiberId));
     });
   };
 }

package/_src/IO/api/stateful.ts

@@ -9,5 +9,5 @@ export function stateful<S, R, E, A>(
   tag: Tag<State<S>>,
   __tsplusTrace?: string,
 ): IO<R, E, A> {
-  return IO.defer(io)(IO.$.provideSomeLayer(State.initial(s, tag)));
+  return IO.defer(io).provideSomeLayer(State.initial(s, tag));
 }

package/_src/IO/api/zipConcurrent.ts

@@ -1,16 +1,14 @@
 import type { InterruptibilityRestorer } from "./interrupt.js";
 import type { Grafter } from "./transplant.js";
 
-import { tuple } from "@fncts/base/data/function";
 import { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
-import { AtomicReference } from "@fncts/base/internal/AtomicReference";
 
 /**
  * @tsplus pipeable fncts.io.IO zipConcurrent
  */
 export function zipConcurrent<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: string) {
-  return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E | E1, readonly [A, B]> => {
-    return self.zipWithConcurrent(that, tuple);
+  return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E | E1, Zipped.Make<A, B>> => {
+    return self.zipWithConcurrent(that, (a, b) => Zipped(a, b));
   };
 }
 
@@ -19,32 +17,30 @@ export function zipConcurrent<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: st
  */
 export function zipWithConcurrent<A, R1, E1, B, C>(that: IO<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string) {
   return <R, E>(self: IO<R, E, A>): IO<R | R1, E | E1, C> => {
-    return IO.fiberId.flatMap((fiberId) =>
-      IO.uninterruptibleMask((restore) => {
-        return IO.transplant((graft) => {
-          const future = Future.unsafeMake<void, void>(FiberId.none);
-          const ref    = new AtomicBoolean(false);
-          return fork(self, restore, graft, future, ref)
-            .zip(fork(that, restore, graft, future, ref))
-            .flatMap(([left, right]) =>
-              restore(future.await).matchCauseIO(
-                (cause) =>
-                  left.interruptFork >
-                  right.interruptFork >
-                  left.await.zip(right.await).flatMap(([left, right]) =>
-                    left
-                      .zipWithCause(right, f, (a, b) => Cause.both(a, b))
-                      .match(
-                        (causes) => IO.refailCause(Cause.both(cause.stripFailures, causes)),
-                        () => IO.refailCause(cause.stripFailures),
-                      ),
-                  ),
-                () => left.join.zipWith(right.join, f),
-              ),
-            );
-        });
-      }),
-    );
+    return IO.uninterruptibleMask((restore) => {
+      return IO.transplant((graft) => {
+        const future = Future.unsafeMake<void, void>(FiberId.none);
+        const ref    = new AtomicBoolean(false);
+        return fork(self, restore, graft, future, ref)
+          .zip(fork(that, restore, graft, future, ref))
+          .flatMap(([left, right]) =>
+            restore(future.await).matchCauseIO(
+              (cause) =>
+                left.interruptFork >
+                right.interruptFork >
+                left.await.zip(right.await).flatMap(([left, right]) =>
+                  left
+                    .zipWithCause(right, f, (a, b) => Cause.both(a, b))
+                    .match(
+                      (causes) => IO.refailCause(Cause.both(cause.stripFailures, causes)),
+                      () => IO.refailCause(cause.stripFailures),
+                    ),
+                ),
+              () => left.join.zipWith(right.join, f),
+            ),
+          );
+      });
+    });
   };
 }
 

package/_src/IO/runtime.ts

@@ -59,7 +59,7 @@ export class Runtime<R> {
       this.unsafeRunAsyncWith(io, resolve);
     });
 
-  unsafeRunSyncExit = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): Exit<E, A> => {
+  unsafeRunOrFork = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): Either<Fiber.Runtime<E, A>, Exit<E, A>> => {
     const fiberId   = FiberId.unsafeMake(__tsplusTrace);
     const scheduler = new StagedScheduler();
     const fiberRefs = this.fiberRefs.updateAs(fiberId, FiberRef.currentEnvironment, this.environment);
@@ -83,10 +83,10 @@ export class Runtime<R> {
 
     const result = fiber.exitValue();
     if (result !== null) {
-      return result;
+      return Either.right(result);
     }
 
-    return Exit.halt(fiber);
+    return Either.left(fiber);
   };
 }
 
@@ -135,4 +135,4 @@ export const unsafeRunWith = defaultRuntime.unsafeRunWith;
 /**
  * @tsplus getter fncts.io.IO unsafeRunSyncExit
  */
-export const unsafeRunSyncExit = defaultRuntime.unsafeRunSyncExit;
+export const unsafeRunOrFork = defaultRuntime.unsafeRunOrFork;

package/_src/Queue/api/filterInputIO.ts

@@ -1,6 +1,6 @@
 import type { PEnqueue, PEnqueueInternal } from "@fncts/io/Queue/definition";
 
-import { concrete, EnqueueTypeId, QueueInternal, QueueTypeId , QueueVariance } from "@fncts/io/Queue/definition";
+import { concrete, EnqueueTypeId, QueueInternal, QueueTypeId, QueueVariance } from "@fncts/io/Queue/definition";
 
 class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends QueueInternal<RA | R2, RB, EA | E2, EB, A1, B> {
   constructor(readonly queue: QueueInternal<RA, RB, EA, EB, A, B>, readonly f: (_: A1) => IO<R2, E2, boolean>) {

package/_src/Queue/api/filterOutputIO.ts

@@ -1,6 +1,6 @@
 import type { PDequeue, PDequeueInternal } from "@fncts/io/Queue/definition";
 
-import { concrete, DequeueTypeId, QueueInternal, QueueTypeId , QueueVariance } from "@fncts/io/Queue/definition";
+import { concrete, DequeueTypeId, QueueInternal, QueueTypeId, QueueVariance } from "@fncts/io/Queue/definition";
 
 class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInternal<RA, RB | RB1, EA, EB | EB1, A, B> {
   constructor(readonly queue: QueueInternal<RA, RB, EA, EB, A, B>, readonly f: (b: B) => IO<RB1, EB1, boolean>) {

package/_src/State/definition.ts

@@ -1,4 +1,4 @@
-import type { StateInternal} from "./internal.js";
+import type { StateInternal } from "./internal.js";
 
 import { StateVariance } from "./internal.js";
 import { StateTypeId } from "./internal.js";

package/_src/Stream/api.ts

@@ -812,9 +812,10 @@ function combineChunksProducer<Err, Elem>(
 ): Channel<never, Err, Conc<Elem>, unknown, never, never, any> {
   return Channel.fromIO(latch.take).zipRight(
     Channel.readWithCause(
-      (chunk) => Channel.fromIO(handoff.offer(Take.chunk(chunk))).zipRight(combineChunksProducer(handoff, latch)),
+      (chunk: Conc<Elem>) =>
+        Channel.fromIO(handoff.offer(Take.chunk(chunk))).zipRight(combineChunksProducer(handoff, latch)),
       (cause) => Channel.fromIO(handoff.offer(Take.failCause(cause))),
-      () => Channel.fromIO(handoff.offer(Take.end)).zipRight(combineChunksProducer(handoff, latch)),
+      () => Channel.fromIO(handoff.offer(Take.end)),
     ),
   );
 }
@@ -991,6 +992,13 @@ export function debounce(duration: Lazy<Duration>, __tsplusTrace?: string) {
   };
 }
 
+/**
+ * @tsplus static fncts.io.StreamOps defer
+ */
+export function defer<R, E, A>(self: Lazy<Stream<R, E, A>>): Stream<R, E, A> {
+  return new Stream(Channel.defer(self().channel));
+}
+
 function defaultIfEmptyWriter<R, E, A, R1, E1, B>(
   fb: Stream<R1, E1, B>,
   __tsplusTrace?: string,
@@ -2189,14 +2197,27 @@ function mapIOLoop<R, E, A, R1, E1, B>(
  *
  * @note This combinator destroys the chunking structure. It's recommended to use chunkN afterwards.
  *
- * @tsplus pipeable fncts.io.Stream mapIOC
+ * @tsplus pipeable fncts.io.Stream mapIOConcurrently
  */
-export function mapIOC<A, R1, E1, B>(n: number, f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string) {
+export function mapIOConcurrently<A, R1, E1, B>(n: number, f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string) {
   return <R, E>(stream: Stream<R, E, A>): Stream<R | R1, E | E1, B> => {
     return new Stream(stream.channel.concatMap(Channel.writeChunk).mapOutConcurrentIO(n, f).mapOut(Conc.single));
   };
 }
 
+/**
+ * @tsplus pipeable fncts.io.Stream mapIOConcurrentlyUnordered
+ */
+export function mapIOConcurrentlyUnordered<A, R1, E1, B>(n: number, f: (a: A) => IO<R1, E1, B>) {
+  return <R, E>(self: Stream<R, E, A>): Stream<R | R1, E | E1, B> => {
+    return self.pipeThroughChannelOrFail(
+      Channel.id<never, Conc<A>, any>()
+        .concatMap((chunk) => Channel.writeChunk(chunk))
+        .mergeMap((inp) => Stream.fromIO(f(inp)).channel, n, 16),
+    );
+  };
+}
+
 /**
  * Maps each element of this stream to another stream and returns the
  * non-deterministic merge of those streams, executing up to `n` inner streams
@@ -2243,7 +2264,7 @@ export function mergeEither<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplusTrace?: st
   };
 }
 
-export function mergeWithHandler<R, E>(
+function mergeWithHandler<R, E>(
   terminate: boolean,
   __tsplusTrace?: string,
 ): (exit: Exit<E, unknown>) => MergeDecision<R, E, unknown, E, unknown> {
@@ -2366,6 +2387,15 @@ export function pipeThrough<A, R1, E1, L, Z>(sa: Sink<R1, E1, A, L, Z>, __tsplus
   };
 }
 
+/**
+ * @tsplus pipeable fncts.io.Stream pipeThroughChannelOrFail
+ */
+export function pipeThroughChannelOrFail<A, R1, E1, B>(channel: Channel<R1, never, Conc<A>, any, E1, Conc<B>, any>) {
+  return <R, E>(self: Stream<R, E, A>): Stream<R | R1, E | E1, B> => {
+    return new Stream(self.channel >>> channel);
+  };
+}
+
 /**
  * Provides the stream with its required environment, which eliminates
  * its dependency on `R`.
@@ -2603,6 +2633,27 @@ export function runIntoQueueScoped<RA, RB, EA, EB, E1, A, B>(
   };
 }
 
+/**
+ * Like runIntoQueue, but provides the result as a scoped IO
+ * to allow for scope composition.
+ *
+ * @tsplus pipeable fncts.io.Stream runIntoQueueElementsScoped
+ */
+export function runIntoQueueElementsScoped<E, A>(queue: Lazy<Queue.Enqueue<Exit<Maybe<E>, A>>>) {
+  return <R>(self: Stream<R, E, A>): IO<R | Scope, never, void> => {
+    return IO.defer(() => {
+      const queue0 = queue();
+      const writer: Channel<R, E, Conc<A>, any, never, Exit<Maybe<E>, A>, any> = Channel.readWithCause(
+        (inp: Conc<A>) => Channel.fromIO(queue0.offerAll(inp.map((a) => Exit.succeed(a)))) > writer,
+        (cause) => Channel.fromIO(queue0.offer(Exit.failCause(cause.map((e) => Just(e))))),
+        () => Channel.fromIO(queue0.offer(Exit.fail(Nothing()))),
+      );
+
+      return (self.channel >>> writer).drain.runScoped.asUnit;
+    });
+  };
+}
+
 /**
  * Like `Stream#runIntoHub`, but provides the result as a `Managed` to allow for scope
  * composition.
@@ -2947,7 +2998,7 @@ export function toQueueOfElements(capacity = 2, __tsplusTrace?: string) {
   return <R, E, A>(stream: Stream<R, E, A>): IO<R | Scope, never, Queue.Dequeue<Exit<Maybe<E>, A>>> => {
     return Do((Δ) => {
       const queue = Δ(IO.acquireRelease(Queue.makeBounded<Exit<Maybe<E>, A>>(capacity), (_) => _.shutdown));
-      Δ(stream.runIntoElementsScoped(queue).fork);
+      Δ(stream.runIntoQueueElementsScoped(queue).forkScoped);
       return queue;
     });
   };

package/_src/Subject/Atomic.ts

@@ -1,4 +1,4 @@
-import type { Emitter} from "@fncts/io/Push/definition";
+import type { Emitter } from "@fncts/io/Push/definition";
 import type { Subject } from "@fncts/io/Subject/definition";
 
 import { Multicast, Push } from "@fncts/io/Push";

package/_src/global.ts

@@ -99,10 +99,6 @@ import { Random } from "@fncts/io/Random/definition";
  * @tsplus global
  */
 import { PRef, Ref } from "@fncts/io/Ref/definition";
-/**
- * @tsplus global
- */
-import { RuntimeConfig } from "@fncts/io/RuntimeConfig";
 /**
  * @tsplus global
  */

package/_src/index.ts

@@ -5,7 +5,6 @@ export type {} from "./Channel.js";
 export type {} from "./Clock.js";
 export type {} from "./Console.js";
 export type {} from "./CountdownLatch.js";
-export type {} from "./demo.js";
 export type {} from "./Fiber.js";
 export type {} from "./FiberDescriptor.js";
 export type {} from "./FiberRef.js";
@@ -22,18 +21,19 @@ export type {} from "./Layer.js";
 export type {} from "./Logger.js";
 export type {} from "./LogLevel.js";
 export type {} from "./LogSpan.js";
+export type {} from "./MVar.js";
 export type {} from "./Push.js";
 export type {} from "./Queue.js";
 export type {} from "./Random.js";
 export type {} from "./Ref.js";
 export type {} from "./RefSubject.js";
 export type {} from "./Reloadable.js";
-export type {} from "./RuntimeConfig.js";
 export type {} from "./RuntimeFlag.js";
 export type {} from "./RuntimeFlags.js";
 export type {} from "./Schedule.js";
 export type {} from "./Scope.js";
 export type {} from "./ScopedRef.js";
+export type {} from "./Semaphore.js";
 export type {} from "./Sink.js";
 export type {} from "./State.js";
 export type {} from "./STM.js";

package/global.d.ts

@@ -98,10 +98,6 @@ import { Random } from "@fncts/io/Random/definition";
  * @tsplus global
  */
 import { PRef, Ref } from "@fncts/io/Ref/definition";
-/**
- * @tsplus global
- */
-import { RuntimeConfig } from "@fncts/io/RuntimeConfig";
 /**
  * @tsplus global
  */

package/index.d.ts

@@ -4,7 +4,6 @@ export type {} from "./Channel.js";
 export type {} from "./Clock.js";
 export type {} from "./Console.js";
 export type {} from "./CountdownLatch.js";
-export type {} from "./demo.js";
 export type {} from "./Fiber.js";
 export type {} from "./FiberDescriptor.js";
 export type {} from "./FiberRef.js";
@@ -21,18 +20,19 @@ export type {} from "./Layer.js";
 export type {} from "./Logger.js";
 export type {} from "./LogLevel.js";
 export type {} from "./LogSpan.js";
+export type {} from "./MVar.js";
 export type {} from "./Push.js";
 export type {} from "./Queue.js";
 export type {} from "./Random.js";
 export type {} from "./Ref.js";
 export type {} from "./RefSubject.js";
 export type {} from "./Reloadable.js";
-export type {} from "./RuntimeConfig.js";
 export type {} from "./RuntimeFlag.js";
 export type {} from "./RuntimeFlags.js";
 export type {} from "./Schedule.js";
 export type {} from "./Scope.js";
 export type {} from "./ScopedRef.js";
+export type {} from "./Semaphore.js";
 export type {} from "./Sink.js";
 export type {} from "./State.js";
 export type {} from "./STM.js";

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@fncts/io",
-  "version": "0.0.31",
+  "version": "0.0.32",
   "dependencies": {
-    "@fncts/base": "0.0.26",
-    "@fncts/transformers": "0.0.4",
+    "@fncts/base": "0.0.27",
+    "@fncts/transformers": "0.0.5",
     "@fncts/typelevel": "0.0.15"
   },
   "exports": {

package/RuntimeConfig.d.ts

@@ -1,11 +0,0 @@
-import { CaseClass } from "@fncts/base/data/CaseClass";
-import { Cause } from "@fncts/base/data/Cause/definition";
-import { Supervisor } from "@fncts/io/Supervisor/definition";
-import { Logger } from "@fncts/io/Logger/definition";
-export declare class RuntimeConfig extends CaseClass<{
-    readonly reportFailure: (e: Cause<unknown>) => void;
-    readonly supervisor: Supervisor<any>;
-    readonly yieldOpCount: number;
-    readonly logger: Logger<string, any>;
-}> {
-}

package/_cjs/RuntimeConfig.cjs

@@ -1,12 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.RuntimeConfig = void 0;
-var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/CaseClass"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-class RuntimeConfig extends tsplus_module_1.CaseClass {}
-exports.RuntimeConfig = RuntimeConfig;
-//# sourceMappingURL=RuntimeConfig.cjs.map

package/_cjs/RuntimeConfig.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"RuntimeConfig.cjs","mappings":";;;;;;;;;AAAM,MAAOA,aAAc,SAAQC,yBAKjC;AAAG","names":["RuntimeConfig","tsplus_module_1"],"sourceRoot":"","sources":["../_src/RuntimeConfig.ts"],"sourcesContent":[null]}

package/_mjs/RuntimeConfig.mjs

@@ -1,3 +0,0 @@
-import * as tsplus_module_1 from "@fncts/base/data/CaseClass";
-export class RuntimeConfig extends tsplus_module_1.CaseClass {}
-//# sourceMappingURL=RuntimeConfig.mjs.map

package/_mjs/RuntimeConfig.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"RuntimeConfig.mjs","mappings":";AAAA,OAAM,MAAOA,aAAc,SAAQC,yBAKjC","names":["RuntimeConfig","tsplus_module_1"],"sourceRoot":"","sources":["../_src/RuntimeConfig.ts"],"sourcesContent":[null]}

package/_src/RuntimeConfig.ts

@@ -1,6 +0,0 @@
-export class RuntimeConfig extends CaseClass<{
-  readonly reportFailure: (e: Cause<unknown>) => void;
-  readonly supervisor: Supervisor<any>;
-  readonly yieldOpCount: number;
-  readonly logger: Logger<string, any>;
-}> {}