@fncts/io 0.0.34 → 0.0.36

package/_src/IO/api/all.ts

@@ -0,0 +1,64 @@
+import type { _A, _E, _R } from "@fncts/base/types";
+import type { EnvironmentOf, ErrorOf, IOVariance, ValueOf } from "@fncts/io/IO";
+
+/**
+ * @tsplus static fncts.io.IOOps all
+ */
+export function all<T extends ReadonlyArray<IO<any, any, any>>>(
+  ios: [...T],
+): IO<
+  { [K in number]: EnvironmentOf<T[K]> }[number],
+  { [K in number]: ErrorOf<T[K]> }[number],
+  { [K in keyof T]: ValueOf<T[K]> }
+>;
+export function all<T extends Iterable<IO<any, any, any>>>(
+  ios: T,
+): [T] extends [Iterable<infer A>] ? IO<EnvironmentOf<A>, ErrorOf<A>, Conc<ValueOf<A>>> : never;
+export function all<T extends Record<string, IO<any, any, any>>>(
+  ios: T,
+): IO<
+  { [K in keyof T]: EnvironmentOf<T[K]> }[keyof T],
+  { [K in keyof T]: ErrorOf<T[K]> }[keyof T],
+  { [K in keyof T]: ValueOf<T[K]> }
+>;
+export function all(ios: Record<string, IO<any, any, any>> | Iterable<IO<any, any, any>>): IO<any, any, any> {
+  if (Symbol.iterator in ios) {
+    return IO.foreach(ios, Function.identity);
+  } else {
+    return IO.foreach(
+      Object.entries(ios).map(([k, io]) => io.map((value) => [k, value] as const)),
+      Function.identity,
+    ).map((result) => result.foldLeft({} as Record<string, any>, (b, a) => Object.assign(b, { [a[0]]: a[1] })));
+  }
+}
+
+/**
+ * @tsplus static fncts.io.IOOps allConcurrent
+ */
+export function allConcurrent<T extends ReadonlyArray<IO<any, any, any>>>(
+  ios: [...T],
+): IO<
+  { [K in number]: EnvironmentOf<T[K]> }[number],
+  { [K in number]: ErrorOf<T[K]> }[number],
+  { [K in keyof T]: ValueOf<T[K]> }
+>;
+export function allConcurrent<T extends Iterable<IO<any, any, any>>>(
+  ios: T,
+): [T] extends [Iterable<infer A>] ? IO<EnvironmentOf<A>, ErrorOf<A>, Conc<ValueOf<A>>> : never;
+export function allConcurrent<T extends Record<string, IO<any, any, any>>>(
+  ios: T,
+): IO<
+  { [K in keyof T]: EnvironmentOf<T[K]> }[keyof T],
+  { [K in keyof T]: ErrorOf<T[K]> }[keyof T],
+  { [K in keyof T]: ValueOf<T[K]> }
+>;
+export function allConcurrent(ios: Record<string, IO<any, any, any>> | Iterable<IO<any, any, any>>): IO<any, any, any> {
+  if (Symbol.iterator in ios) {
+    return IO.foreachConcurrent(ios, Function.identity);
+  } else {
+    return IO.foreachConcurrent(
+      Object.entries(ios).map(([k, io]) => io.map((value) => [k, value] as const)),
+      Function.identity,
+    ).map((result) => result.foldLeft({} as Record<string, any>, (b, a) => Object.assign(b, { [a[0]]: a[1] })));
+  }
+}

package/_src/IO/api/concurrency.ts

@@ -41,3 +41,36 @@ export function withConcurrency(n: number, __tsplusTrace?: string) {
 export function withConcurrencyUnbounded<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
   return IO.defer(Concurrency.locally(Nothing())(ma));
 }
+
+export type ConcurrencyRestorer = <R, E, A>(io: IO<R, E, A>) => IO<R, E, A>;
+
+const MakeConcurrent =
+  (n: number): ConcurrencyRestorer =>
+  (io) =>
+    io.withConcurrency(n);
+
+const MakeConcurrentUnbounded: ConcurrencyRestorer = (io) => io.withConcurrencyUnbounded;
+
+/**
+ * @tsplus static fncts.io.IOOps withConcurrencyMask
+ */
+export function withConcurrencyMask<R, E, A>(n: number, f: (restore: ConcurrencyRestorer) => IO<R, E, A>): IO<R, E, A> {
+  return Concurrency.getWith((concurrency) =>
+    concurrency.match(
+      () => Concurrency.locally(Just(n))(f(MakeConcurrentUnbounded)),
+      (n0) => Concurrency.locally(Just(n))(f(MakeConcurrent(n0))),
+    ),
+  );
+}
+
+/**
+ * @tsplus static fncts.io.IOOps withConcurrencyUnboundedMask
+ */
+export function withConcurrencyUnboundedMask<R, E, A>(f: (restore: ConcurrencyRestorer) => IO<R, E, A>): IO<R, E, A> {
+  return Concurrency.getWith((concurrency) =>
+    concurrency.match(
+      () => Concurrency.locally(Nothing())(f(MakeConcurrentUnbounded)),
+      (n0) => Concurrency.locally(Nothing())(f(MakeConcurrent(n0))),
+    ),
+  );
+}

package/_src/IO/api/foreachExec.ts

@@ -14,7 +14,7 @@ export function foreachExec<R, E, A, B>(
 ): IO<R, E, Conc<B>> {
   return es.match(
     () => IO.foreach(as, f),
-    () => IO.foreachConcurrent(as, f).withConcurrencyUnbounded,
-    (fiberBound) => IO.foreachConcurrent(as, f).withConcurrency(fiberBound),
+    () => IO.withConcurrencyUnboundedMask((restore) => IO.foreachConcurrent(as, (a) => restore(f(a)))),
+    (fiberBound) => IO.withConcurrencyMask(fiberBound, (restore) => IO.foreachConcurrent(as, (a) => restore(f(a)))),
   );
 }

package/_src/IO/api/interrupt.ts

@@ -1,4 +1,4 @@
-import { Dynamic, Interruptible, Uninterruptible } from "@fncts/io/IO/definition";
+import { IOPrimitive,IOTag } from "@fncts/io/IO/definition";
 import { RuntimeFlag } from "@fncts/io/RuntimeFlag";
 import { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 
@@ -40,7 +40,11 @@ export const interrupt: IO<never, never, never> = IO.fiberId.flatMap(IO.interrup
  * @tsplus static fncts.io.IOOps interruptible
  */
 export function interruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return new Interruptible(self, __tsplusTrace);
+  const io = new IOPrimitive(IOTag.UpdateRuntimeFlagsWithin) as any;
+  io.i0    = RuntimeFlags.enable(RuntimeFlag.Interruption);
+  io.i1    = () => self;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
@@ -55,7 +59,11 @@ export function interruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string
  * @tsplus static fncts.io.IOOps uninterruptible
  */
 export function uninterruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return new Uninterruptible(self, __tsplusTrace);
+  const io = new IOPrimitive(IOTag.UpdateRuntimeFlagsWithin) as any;
+  io.i0    = RuntimeFlags.disable(RuntimeFlag.Interruption);
+  io.i1    = () => self;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
@@ -65,10 +73,15 @@ export function uninterruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: stri
  *
  * @tsplus static fncts.io.IOOps uninterruptibleMask
  */
-export function uninterruptibleMask<R, E, A>(f: (restore: InterruptibilityRestorer) => IO<R, E, A>): IO<R, E, A> {
-  return new Dynamic(RuntimeFlags.disable(RuntimeFlag.Interruption), (oldFlags) =>
-    f(oldFlags.interruption ? RestoreInterruptible : RestoreUninterruptible),
-  );
+export function uninterruptibleMask<R, E, A>(
+  f: (restore: InterruptibilityRestorer) => IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
+  const io = new IOPrimitive(IOTag.UpdateRuntimeFlagsWithin) as any;
+  io.i0    = RuntimeFlags.disable(RuntimeFlag.Interruption);
+  io.i1    = (oldFlags: RuntimeFlags) => f(oldFlags.interruption ? RestoreInterruptible : RestoreUninterruptible);
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**

package/_src/IO/api/raceWith.ts

@@ -10,6 +10,8 @@ export function raceFibersWith<R, E, A, R1, E1, B, R2, E2, C, R3, E3, D>(
   right: Lazy<IO<R1, E1, B>>,
   leftWins: (winner: FiberRuntime<E, A>, loser: FiberRuntime<E1, B>) => IO<R2, E2, C>,
   rightWins: (winner: FiberRuntime<E1, B>, loser: FiberRuntime<E, A>) => IO<R3, E3, D>,
+  leftScope: FiberScope | null = null,
+  rightScope: FiberScope | null = null,
   __tsplusTrace?: string,
 ) {
   return (left: IO<R, E, A>): IO<R | R1 | R2 | R3, E2 | E3, C | D> => {
@@ -29,8 +31,8 @@ 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);
+      const leftFiber     = IO.unsafeMakeChildFiber(left, parentState, parentRuntimeFlags, leftScope, __tsplusTrace);
+      const rightFiber    = IO.unsafeMakeChildFiber(right0, parentState, parentRuntimeFlags, rightScope, __tsplusTrace);
 
       return IO.async((cb) => {
         leftFiber.addObserver(() => complete(leftFiber, rightFiber, leftWins, raceIndicator, cb));

package/_src/IO/api/timeout.ts

@@ -3,7 +3,27 @@
  */
 export function timeoutTo<A, B, B1>(duration: Lazy<Duration>, b: Lazy<B>, f: (a: A) => B1, __tsplusTrace?: string) {
   return <R, E>(self: IO<R, E, A>): IO<R, E, B | B1> => {
-    return self.map(f).raceFirst(IO.sleep(duration).interruptible.as(b));
+    return IO.fiberIdWith((parentFiberId) =>
+      self.raceFibersWith(
+        IO.sleep(duration).interruptible,
+        (winner, loser) =>
+          winner.await.flatMap((exit) =>
+            exit.match(
+              (cause) => loser.interruptAs(parentFiberId) > IO.refailCause(cause),
+              (a) => winner.inheritAll > loser.interruptAs(parentFiberId).as(f(a)),
+            ),
+          ),
+        (winner, loser) =>
+          winner.await.flatMap((exit) =>
+            exit.match(
+              (cause) => loser.interruptAs(parentFiberId) > IO.refailCause(cause),
+              () => winner.inheritAll > loser.interruptAs(parentFiberId).as(b),
+            ),
+          ),
+        null,
+        FiberScope.global,
+      ),
+    );
   };
 }
 

package/_src/IO/api.ts

@@ -6,17 +6,8 @@ import type { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 
 import { IOError } from "@fncts/base/data/exceptions";
 import { identity, pipe, tuple } from "@fncts/base/data/function";
-import {
-  Async,
-  GenerateStackTrace,
-  OnSuccess,
-  OnSuccessAndFailure,
-  Sync,
-  UpdateRuntimeFlags,
-  YieldNow,
-} from "@fncts/io/IO/definition";
-import { Stateful } from "@fncts/io/IO/definition";
-import { Fail, IO, SucceedNow } from "@fncts/io/IO/definition";
+import { IOPrimitive,IOTag } from "@fncts/io/IO/definition";
+import { IO } from "@fncts/io/IO/definition";
 
 /**
  * Imports an asynchronous side-effect into a `IO`
@@ -28,7 +19,11 @@ export function async<R, E, A>(
   blockingOn: FiberId = FiberId.none,
   __tsplusTrace?: string,
 ): IO<R, E, A> {
-  return new Async(register, () => blockingOn, __tsplusTrace);
+  const io = new IOPrimitive(IOTag.Async) as any;
+  io.i0    = register;
+  io.i1    = () => blockingOn;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
@@ -318,7 +313,11 @@ export function checkInterruptible<R, E, A>(
  */
 export function flatMap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string) {
   return <R, E>(ma: IO<R, E, A>): IO<R | R1, E | E1, B> => {
-    return new OnSuccess(ma, f, __tsplusTrace);
+    const io = new IOPrimitive(IOTag.OnSuccess) as any;
+    io.i0    = ma;
+    io.i1    = f;
+    io.trace = __tsplusTrace;
+    return io;
   };
 }
 
@@ -369,7 +368,7 @@ export function condIO<R, R1, E, A>(
  *
  * @tsplus static fncts.io.IOOps defer
  */
-export function defer<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, A> {
+export function defer<R = never, E = never, A = never>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, A> {
   return IO.succeed(io).flatMap(identity);
 }
 
@@ -379,7 +378,10 @@ export function defer<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): I
  *
  * @tsplus static fncts.io.IOOps deferTry
  */
-export function deferTry<R, E, A>(io: () => IO<R, E, A>, __tsplusTrace?: string): IO<R, unknown, A> {
+export function deferTry<R = never, E = never, A = never>(
+  io: () => IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R, unknown, A> {
   return IO.defer(() => {
     try {
       return io();
@@ -463,7 +465,10 @@ export function failNow<E>(e: E, __tsplusTrace?: string): FIO<E, never> {
  * @tsplus static fncts.io.IOOps refailCause
  */
 export function refailCause<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E, never> {
-  return new Fail(() => cause, __tsplusTrace);
+  const io = new IOPrimitive(IOTag.Fail) as any;
+  io.i0    = () => cause;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
@@ -472,7 +477,10 @@ export function refailCause<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E,
  * @tsplus static fncts.io.IOOps failCauseNow
  */
 export function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E, never> {
-  return new Fail(() => cause, __tsplusTrace);
+  const io = new IOPrimitive(IOTag.Fail) as any;
+  io.i0    = () => cause;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
@@ -1223,7 +1231,12 @@ export function matchCauseIO<E, A, R1, E1, A1, R2, E2, A2>(
   __tsplusTrace?: string,
 ) {
   return <R>(self: IO<R, E, A>): IO<R | R1 | R2, E1 | E2, A1 | A2> => {
-    return new OnSuccessAndFailure(self, onFailure, onSuccess, __tsplusTrace);
+    const io = new IOPrimitive(IOTag.OnSuccessAndFailure) as any;
+    io.i0    = self;
+    io.i1    = onFailure;
+    io.i2    = onSuccess;
+    io.trace = __tsplusTrace;
+    return io;
   };
 }
 
@@ -1664,7 +1677,10 @@ export function sequenceIterableDiscard<R, E, A>(as: Iterable<IO<R, E, A>>, __ts
  * @tsplus static fncts.io.IOOps succeedNow
  */
 export function succeedNow<A>(value: A, __tsplusTrace?: string): IO<never, never, A> {
-  return new SucceedNow(value, __tsplusTrace);
+  const io = new IOPrimitive(IOTag.SucceedNow) as any;
+  io.i0    = value;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
@@ -1676,7 +1692,10 @@ export function succeedNow<A>(value: A, __tsplusTrace?: string): IO<never, never
  * @tsplus static fncts.io.IOOps __call
  */
 export function succeed<A>(effect: Lazy<A>, __tsplusTrace?: string): UIO<A> {
-  return new Sync(effect, __tsplusTrace);
+  const io = new IOPrimitive(IOTag.Sync) as any;
+  io.i0    = effect;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
@@ -1721,17 +1740,42 @@ export function timedWith<R1, E1>(msTime: IO<R1, E1, number>, __tsplusTrace?: st
     ma.summarized(msTime, (start, end) => end - start);
 }
 
+/**
+ * @tsplus static fncts.io.IOOps attempt
+ */
+export function attempt<A>(effect: Lazy<A>, __tsplusTrace?: string): FIO<unknown, A> {
+  return IO.defer(() => {
+    try {
+      return Exit.succeed(effect());
+    } catch (u) {
+      return IO.withFiberRuntime((fiberState) => {
+        if (!fiberState.isFatal(u)) {
+          throw new IOError(Cause.fail(u));
+        } else {
+          throw u;
+        }
+      });
+    }
+  });
+}
+
 /**
  * Creates a `IO` that has succeeded with a pure value
  *
  * @tsplus static fncts.io.IOOps tryCatch
  */
 export function tryCatch<E, A>(effect: Lazy<A>, onThrow: (error: unknown) => E, __tsplusTrace?: string): FIO<E, A> {
-  return IO.succeed(() => {
+  return IO.defer(() => {
     try {
-      return effect();
+      return Exit.succeed(effect());
     } catch (u) {
-      throw new IOError(Cause.fail(onThrow(u)));
+      return IO.withFiberRuntime((fiberState) => {
+        if (!fiberState.isFatal(u)) {
+          throw new IOError(Cause.fail(u));
+        } else {
+          throw u;
+        }
+      });
     }
   });
 }
@@ -1902,21 +1946,29 @@ export function withFiberRuntime<R, E, A>(
   onState: (fiber: FiberRuntime<E, A>, status: Running) => IO<R, E, A>,
   __tsplusTrace?: string,
 ): IO<R, E, A> {
-  return new Stateful(onState, __tsplusTrace);
+  const io = new IOPrimitive(IOTag.Stateful) as any;
+  io.i0    = onState;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
  * @tsplus static fncts.io.IOOps updateRuntimeFlags
  */
 export function updateRuntimeFlags(patch: RuntimeFlags.Patch, __tsplusTrace?: string): IO<never, never, void> {
-  return new UpdateRuntimeFlags(patch, __tsplusTrace);
+  const io = new IOPrimitive(IOTag.UpdateRuntimeFlags) as any;
+  io.i0    = patch;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
  * @tsplus static fncts.io.IOOps stackTrace
  */
 export function stackTrace(__tsplusTrace?: string): UIO<Trace> {
-  return new GenerateStackTrace(__tsplusTrace);
+  const io = new IOPrimitive(IOTag.GenerateStackTrace) as any;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
@@ -1926,7 +1978,7 @@ export function stackTrace(__tsplusTrace?: string): UIO<Trace> {
  *
  * @tsplus static fncts.io.IOOps yieldNow
  */
-export const yieldNow: UIO<void> = new YieldNow();
+export const yieldNow: UIO<void> = new IOPrimitive(IOTag.YieldNow) as any;
 
 /**
  * @tsplus pipeable fncts.io.IO zip