@fncts/io 0.0.48 → 0.0.50

package/_src/IO/definition.ts

@@ -37,6 +37,7 @@ export declare namespace IO {
   export type EnvironmentOf<T> = [T] extends [{ [IOVariance]: { _R: () => infer R } }] ? R : never;
   export type ErrorOf<T> = [T] extends [{ [IOVariance]: { _E: () => infer E } }] ? E : never;
   export type ValueOf<T> = [T] extends [{ [IOVariance]: { _A: () => infer A } }] ? A : never;
+  export type Concrete = Primitive;
 }
 
 declare module "@fncts/base/data/Either/definition" {
@@ -90,15 +91,12 @@ export const enum IOTag {
   Async,
   OnSuccessAndFailure,
   OnSuccess,
-  OnFailure,
   UpdateRuntimeFlags,
   UpdateRuntimeFlagsWithin,
-  GenerateStackTrace,
   Stateful,
   WhileLoop,
   YieldNow,
   Commit,
-  RevertFlags,
   UpdateTrace,
   External,
 }
@@ -130,7 +128,7 @@ export interface Sync<A = any>
     }
   > {}
 
-export interface Async<R = any, E = any, A = any>
+export interface Async
   extends IOOp<
     IOTag.Async,
     {
@@ -151,16 +149,6 @@ export interface OnSuccessAndFailure
     }
   > {}
 
-export interface OnFailure
-  extends IOOp<
-    IOTag.OnFailure,
-    {
-      readonly i0: Primitive;
-      readonly i1: (cause: Cause<unknown>) => Primitive;
-      readonly trace: string | undefined;
-    }
-  > {}
-
 export interface OnSuccess
   extends IOOp<
     IOTag.OnSuccess,
@@ -171,7 +159,7 @@ export interface OnSuccess
     }
   > {}
 
-export interface SucceedNow
+export interface Succeed
   extends IOOp<
     IOTag.SucceedNow,
     {
@@ -199,14 +187,6 @@ export interface UpdateRuntimeFlagsWithin
     }
   > {}
 
-export interface GenerateStackTrace
-  extends IOOp<
-    IOTag.GenerateStackTrace,
-    {
-      readonly trace: string | undefined;
-    }
-  > {}
-
 export interface Stateful
   extends IOOp<
     IOTag.Stateful,
@@ -246,14 +226,12 @@ export interface Fail
 
 export type Primitive =
   | OnSuccessAndFailure
-  | OnFailure
   | OnSuccess
   | UpdateRuntimeFlagsWithin
   | Sync
   | Async
-  | SucceedNow
+  | Succeed
   | UpdateRuntimeFlags
-  | GenerateStackTrace
   | Stateful
   | WhileLoop
   | YieldNow
@@ -276,8 +254,6 @@ export function concrete(io: IO<any, any, any>): Primitive {
   return io as Primitive;
 }
 
-export type EvaluationStep = OnSuccessAndFailure | OnFailure | OnSuccess;
-
 export type Canceler<R> = URIO<R, void>;
 
 export abstract class External<R, E, A> extends IOPrimitive implements IO<R, E, A> {

package/_src/IO/runtime.ts

@@ -1,4 +1,3 @@
-import { IOError } from "@fncts/base/data/exceptions";
 import { FiberRuntime } from "@fncts/io/Fiber";
 import { FiberRefs } from "@fncts/io/FiberRefs";
 import { RuntimeFlag } from "@fncts/io/RuntimeFlag";

package/_src/IO.ts

@@ -5,67 +5,69 @@ export * from "./IO/runtime.js";
 // codegen:end
 
 // codegen:start { preset: barrel, include: IO/api/*.ts }
-export * from "./IO/api/acquireRelease.js";
-export * from "./IO/api/acquireReleaseExit.js";
-export * from "./IO/api/acquireReleaseInterruptible.js";
-export * from "./IO/api/acquireReleaseInterruptibleExit.js";
-export * from "./IO/api/addFinalizer.js";
-export * from "./IO/api/addFinalizerExit.js";
-export * from "./IO/api/all.js";
-export * from "./IO/api/asyncInterrupt.js";
-export * from "./IO/api/asyncIO.js";
-export * from "./IO/api/blocking.js";
-export * from "./IO/api/bracket.js";
-export * from "./IO/api/bracketExit.js";
-export * from "./IO/api/clockWith.js";
-export * from "./IO/api/concurrency.js";
-export * from "./IO/api/concurrentFinalizers.js";
-export * from "./IO/api/consoleWith.js";
-export * from "./IO/api/daemonChildren.js";
-export * from "./IO/api/delay.js";
-export * from "./IO/api/descriptor.js";
-export * from "./IO/api/diffFiberRefs.js";
-export * from "./IO/api/disconnect.js";
-export * from "./IO/api/ensuringChildren.js";
-export * from "./IO/api/environment.js";
-export * from "./IO/api/foreachConcurrent.js";
-export * from "./IO/api/foreachExec.js";
-export * from "./IO/api/fork.js";
-export * from "./IO/api/forkAll.js";
-export * from "./IO/api/forkDaemon.js";
-export * from "./IO/api/forkIn.js";
-export * from "./IO/api/forkScoped.js";
-export * from "./IO/api/fulfill.js";
-export * from "./IO/api/interrupt.js";
-export * from "./IO/api/memoize.js";
-export * from "./IO/api/once.js";
-export * from "./IO/api/onTermination.js";
-export * from "./IO/api/patchFiberRefs.js";
-export * from "./IO/api/provideLayer.js";
-export * from "./IO/api/provideScope.js";
-export * from "./IO/api/provideSomeLayer.js";
-export * from "./IO/api/provideSomeRuntime.js";
-export * from "./IO/api/race.js";
-export * from "./IO/api/raceFirst.js";
-export * from "./IO/api/raceWith.js";
-export * from "./IO/api/randomWith.js";
-export * from "./IO/api/repeat.js";
-export * from "./IO/api/retry.js";
-export * from "./IO/api/schedule.js";
-export * from "./IO/api/scope.js";
-export * from "./IO/api/scoped.js";
-export * from "./IO/api/scopeWith.js";
-export * from "./IO/api/sequenceT.js";
-export * from "./IO/api/sleep.js";
-export * from "./IO/api/stateful.js";
-export * from "./IO/api/supervised.js";
-export * from "./IO/api/timeout.js";
-export * from "./IO/api/transplant.js";
-export * from "./IO/api/whenFiberRef.js";
-export * from "./IO/api/whenRef.js";
-export * from "./IO/api/withChildren.js";
-export * from "./IO/api/withEarlyRelease.js";
-export * from "./IO/api/withFinalizer.js";
-export * from "./IO/api/withFinalizerExit.js";
-export * from "./IO/api/zipConcurrent.js";
+export * from "./IO/api/acquireRelease.js"
+export * from "./IO/api/acquireReleaseExit.js"
+export * from "./IO/api/acquireReleaseInterruptible.js"
+export * from "./IO/api/acquireReleaseInterruptibleExit.js"
+export * from "./IO/api/addFinalizer.js"
+export * from "./IO/api/addFinalizerExit.js"
+export * from "./IO/api/all.js"
+export * from "./IO/api/array.js"
+export * from "./IO/api/asyncInterrupt.js"
+export * from "./IO/api/asyncIO.js"
+export * from "./IO/api/awaitAllChildren.js"
+export * from "./IO/api/blocking.js"
+export * from "./IO/api/bracket.js"
+export * from "./IO/api/bracketExit.js"
+export * from "./IO/api/cachedInvalidate.js"
+export * from "./IO/api/clockWith.js"
+export * from "./IO/api/concurrency.js"
+export * from "./IO/api/concurrentFinalizers.js"
+export * from "./IO/api/consoleWith.js"
+export * from "./IO/api/daemonChildren.js"
+export * from "./IO/api/delay.js"
+export * from "./IO/api/descriptor.js"
+export * from "./IO/api/diffFiberRefs.js"
+export * from "./IO/api/disconnect.js"
+export * from "./IO/api/ensuringChildren.js"
+export * from "./IO/api/environment.js"
+export * from "./IO/api/foreachConcurrent.js"
+export * from "./IO/api/foreachExec.js"
+export * from "./IO/api/fork.js"
+export * from "./IO/api/forkAll.js"
+export * from "./IO/api/forkDaemon.js"
+export * from "./IO/api/forkIn.js"
+export * from "./IO/api/forkScoped.js"
+export * from "./IO/api/fulfill.js"
+export * from "./IO/api/interrupt.js"
+export * from "./IO/api/memoize.js"
+export * from "./IO/api/once.js"
+export * from "./IO/api/onTermination.js"
+export * from "./IO/api/patchFiberRefs.js"
+export * from "./IO/api/provideLayer.js"
+export * from "./IO/api/provideScope.js"
+export * from "./IO/api/provideSomeLayer.js"
+export * from "./IO/api/provideSomeRuntime.js"
+export * from "./IO/api/race.js"
+export * from "./IO/api/raceFirst.js"
+export * from "./IO/api/raceWith.js"
+export * from "./IO/api/randomWith.js"
+export * from "./IO/api/repeat.js"
+export * from "./IO/api/retry.js"
+export * from "./IO/api/schedule.js"
+export * from "./IO/api/scope.js"
+export * from "./IO/api/scoped.js"
+export * from "./IO/api/scopeWith.js"
+export * from "./IO/api/sleep.js"
+export * from "./IO/api/stateful.js"
+export * from "./IO/api/supervised.js"
+export * from "./IO/api/timeout.js"
+export * from "./IO/api/transplant.js"
+export * from "./IO/api/whenFiberRef.js"
+export * from "./IO/api/whenRef.js"
+export * from "./IO/api/withChildren.js"
+export * from "./IO/api/withEarlyRelease.js"
+export * from "./IO/api/withFinalizer.js"
+export * from "./IO/api/withFinalizerExit.js"
+export * from "./IO/api/zipConcurrent.js"
 // codegen:end

package/_src/IOEnv/definition.ts

@@ -12,7 +12,4 @@ export const IOEnv: IOEnvOps = {};
 /**
  * @tsplus static fncts.io.IOEnvOps environment
  */
-export const environment = Environment()
-  .add(Clock.Live, Clock.Tag)
-  .add(Random.Live, Random.Tag)
-  .add(Console.Live, Console.Tag);
+export const environment = Environment().add(Clock.Live).add(Random.Live).add(Console.Live);

package/_src/Push/Bounds.ts

@@ -0,0 +1,4 @@
+export interface Bounds {
+  readonly min: number;
+  readonly max: number;
+}

package/_src/Push/FlattenStrategy.ts

@@ -0,0 +1,137 @@
+import { withScope } from "@fncts/io/Push/internal";
+
+type ScopedFork = <R, E, A>(io: IO<R, E, A>) => IO<R | Scope, never, Fiber.Runtime<E, A>>;
+
+type Fork = <R>(io: IO<R, never, void>) => IO<R | Scope, never, void>;
+
+/**
+ * @tsplus type fncts.io.Push.FlattenStrategy
+ * @tsplus companion fncts.io.Push.FlattenStrategyOps
+ */
+export abstract class FlattenStrategy {
+  abstract withFork<R>(
+    f: (fork: Fork, scope: Scope) => IO<R, never, void>,
+    executionStrategy: ExecutionStrategy,
+  ): IO<R | Scope, never, void>;
+}
+
+function withScopedFork<R, E, A>(
+  f: (fork: ScopedFork, scope: Scope.Closeable) => IO<R, E, A>,
+  executionStrategy: ExecutionStrategy,
+): IO<R | Scope, E, A> {
+  return withScope((scope) => f((io) => io.forkIn(scope), scope), executionStrategy);
+}
+
+/**
+ * @tsplus static fncts.io.Push.FlattenStrategyOps Switch
+ */
+export const SwitchStrategy = new (class SwitchStrategy extends FlattenStrategy {
+  withFork<R>(
+    f: (fork: Fork, scope: Scope) => IO<R, never, void>,
+    executionStrategy: ExecutionStrategy,
+  ): IO<R | Scope, never, void> {
+    return withScopedFork(
+      (fork, scope) =>
+        Ref.Synchronized.make<Fiber<never, void>>(Fiber.unit).flatMap(
+          (ref) =>
+            f((io) => ref.updateIO((fiber) => fiber.interrupt > fork(io)), scope) >
+            ref.get.flatMap((fiber) => fiber.join),
+        ),
+      executionStrategy,
+    );
+  }
+})();
+
+/**
+ * @tsplus static fncts.io.Push.FlattenStrategyOps Exhaust
+ */
+export const ExhaustStrategy = new (class ExhaustStrategy extends FlattenStrategy {
+  withFork<R>(
+    f: (fork: Fork, scope: Scope) => IO<R, never, void>,
+    executionStrategy: ExecutionStrategy,
+  ): IO<R | Scope, never, void> {
+    return withScopedFork(
+      (fork, scope) =>
+        Ref.Synchronized.make<Fiber.Runtime<never, void> | null>(null).flatMap(
+          (ref) =>
+            f(
+              (io) =>
+                ref.updateIO((fiber) => {
+                  if (fiber) {
+                    return IO.succeedNow(fiber);
+                  } else {
+                    return fork(io.onExit(() => ref.set(null)));
+                  }
+                }),
+              scope,
+            ) >
+            ref.get.flatMap((fiber) => {
+              if (fiber) {
+                return fiber.join;
+              } else {
+                return IO.unit;
+              }
+            }),
+        ),
+      executionStrategy,
+    );
+  }
+})();
+
+/**
+ * @tsplus static fncts.io.Push.FlattenStrategyOps Unbounded
+ */
+export const UnboundedStrategy = new (class UnboundedStrategy extends FlattenStrategy {
+  withFork<R>(f: (fork: Fork, scope: Scope) => IO<R, never, void>): IO<R | Scope, never, void> {
+    return IO.scopeWith((scope) =>
+      FiberSet.make<never, void>().flatMap((fiberSet) => f((io) => fiberSet.run(io), scope) > Fiber.joinAll(fiberSet)),
+    );
+  }
+})();
+
+/**
+ * @tsplus static fncts.io.Push.FlattenStrategyOps Bounded
+ */
+export function makeBounded(capacity: number): BoundedStrategy {
+  return new BoundedStrategy(capacity);
+}
+
+class BoundedStrategy extends FlattenStrategy {
+  constructor(readonly capacity: number) {
+    super();
+  }
+
+  withFork<R>(
+    f: (fork: Fork, scope: Scope) => IO<R, never, void>,
+    executionStrategy: ExecutionStrategy,
+  ): IO<R | Scope, never, void> {
+    return withScopedFork(
+      (fork, scope) =>
+        Do((Δ) => {
+          const ref       = Δ(Ref.make<HashSet<Fiber.Runtime<never, void>>>(HashSet.empty()));
+          const semaphore = Δ(Semaphore.make(this.capacity));
+          Δ(
+            f(
+              (io) =>
+                Do((Δ) => {
+                  const fiber = Δ(fork(semaphore.withPermit(io)));
+                  Δ(ref.update((set) => set.add(fiber)));
+                  Δ(scope.addFinalizer(ref.update((set) => set.remove(fiber))));
+                }),
+              scope,
+            ),
+          );
+          return ref;
+        }).flatMap((ref) =>
+          ref.get.flatMap((fibers) => {
+            if (fibers.size > 0) {
+              return Fiber.joinAll(fibers);
+            } else {
+              return IO.unit;
+            }
+          }),
+        ),
+      executionStrategy,
+    );
+  }
+}

package/_src/Push/IndexedBuffer.ts

@@ -0,0 +1,79 @@
+import type { Push } from "./definition.js";
+
+export class IndexedBuffer<R, E, A> {
+  constructor(
+    public ready: boolean,
+    readonly future: Future<never, void>,
+    readonly sink: Push.UnsafeSink<R, E, A>,
+    readonly onDone: UIO<void>,
+  ) {}
+
+  buffer: Array<A> = [];
+
+  onSuccess(value: A) {
+    if (this.ready) {
+      if (this.buffer.length === 0) {
+        return this.sink.onSuccess(value);
+      }
+
+      this.buffer.push(value);
+      const b     = this.buffer;
+      this.buffer = [];
+      return IO.foreach(b, this.sink.onSuccess);
+    } else {
+      this.buffer.push(value);
+      return IO.unit;
+    }
+  }
+
+  get onEnd() {
+    return (
+      this.future.await >
+      IO.defer(() => {
+        if (this.buffer.length === 0) {
+          return this.onDone;
+        }
+        const b     = this.buffer;
+        this.buffer = [];
+        return IO.foreach(b, this.sink.onSuccess) > this.onDone;
+      })
+    );
+  }
+}
+
+export const withBuffers = <R, E, A>(
+  size: number,
+  sink: Push.UnsafeSink<R, E, A>,
+  id: FiberId,
+): {
+  onSuccess: (index: number, value: A) => IO<R, never, void>;
+  onEnd: (index: number) => IO<R, never, void>;
+  buffers: Map<number, IndexedBuffer<R, E, A>>;
+} => {
+  const buffers = new Map<number, IndexedBuffer<R, E, A>>();
+  const last    = size - 1;
+
+  for (let i = 0; i < size; i++) {
+    const future = Future.unsafeMake<never, void>(id);
+    const ready  = i === 0;
+    if (i === 0) {
+      future.unsafeDone(IO.unit);
+    }
+    const onDone =
+      i === last
+        ? IO.unit
+        : IO.defer(() => {
+            const next = buffers.get(i + 1)!;
+            next.ready = true;
+            return next.future.done(Exit.unit);
+          });
+
+    buffers.set(i, new IndexedBuffer(ready, future, sink, onDone));
+  }
+
+  return {
+    buffers,
+    onSuccess: (index, value) => buffers.get(index)!.onSuccess(value),
+    onEnd: (index) => buffers.get(index)!.onEnd,
+  };
+};

package/_src/Push/MergeStrategy.ts

@@ -0,0 +1,59 @@
+import type { Push } from "./definition.js";
+
+import { withBuffers } from "./IndexedBuffer.js";
+import { Sink } from "./Sink.js";
+
+export abstract class MergeStrategy {
+  abstract runMerge<Ps extends ReadonlyArray<Push<any, any, any>>, R>(
+    ps: Ps,
+    sink: Push.UnsafeSink<R, any, any>,
+  ): IO<R | Push.EnvironmentOf<Ps[number]>, never, void>;
+}
+
+export class Unordered extends MergeStrategy {
+  constructor(readonly executionStrategy: ExecutionStrategy) {
+    super();
+  }
+
+  runMerge<Ps extends ReadonlyArray<Push<any, any, any>>, R>(
+    ps: Ps,
+    sink: Push.UnsafeSink<R, any, any>,
+  ): IO<R | Push.EnvironmentOf<Ps[number]>, never, void> {
+    return IO.foreachExecDiscard(ps, this.executionStrategy, (p) => p.run(sink));
+  }
+}
+
+export class Ordered extends MergeStrategy {
+  constructor(readonly executionStrategy: ExecutionStrategy) {
+    super();
+  }
+
+  runMerge<Ps extends ReadonlyArray<Push<any, any, any>>, R>(
+    ps: Ps,
+    sink: Push.UnsafeSink<R, any, any>,
+  ): IO<R | Push.EnvironmentOf<Ps[number]>, never, void> {
+    return IO.fiberIdWith((fiberId) => {
+      const buffers = withBuffers(ps.length, sink, fiberId);
+      return IO.foreachWithIndexDiscardExec(
+        ps,
+        this.executionStrategy,
+        (index, p) =>
+          p.run(
+            Sink.unsafeMake(
+              (value) => buffers.onSuccess(index, value),
+              (cause) => (cause.isInterruptedOnly ? buffers.onEnd(index) : sink.onFailure(cause)),
+            ),
+          ) > buffers.onEnd(index),
+      );
+    });
+  }
+}
+
+export class Switch extends MergeStrategy {
+  runMerge<Ps extends ReadonlyArray<Push<any, any, any>>, R>(
+    ps: Ps,
+    sink: Push.UnsafeSink<R, any, any>,
+  ): IO<R | Push.EnvironmentOf<Ps[number]>, never, void> {
+    return IO.foreachDiscard(ps, (p) => p.run(sink));
+  }
+}