@fncts/io 0.0.48 → 0.0.49

package/_src/IO/api/addFinalizerExit.ts

@@ -5,9 +5,9 @@ export function addFinalizerExit<R>(
   finalizer: (exit: Exit<any, any>) => URIO<R, any>,
   __tsplusTrace?: string,
 ): IO<R | Scope, never, void> {
-  return Do((_) => {
-    const environment = _(IO.environment<R>());
-    const scope       = _(IO.scope);
-    _(scope.addFinalizerExit(Finalizer.get((exit) => finalizer(exit).provideEnvironment(environment))));
+  return Do((Δ) => {
+    const environment = Δ(IO.environment<R>());
+    const scope       = Δ(IO.scope);
+    Δ(scope.addFinalizerExit(Finalizer.get((exit) => finalizer(exit).provideEnvironment(environment))));
   });
 }

package/_src/IO/api/array.ts

@@ -0,0 +1,49 @@
+/**
+ * @tsplus fluent fncts.ReadonlyArray mapIOWithIndexDiscard
+ */
+export function foreachArrayWithIndexDiscard<A, R, E>(
+  array: ReadonlyArray<A>,
+  f: (i: number, a: A) => IO<R, E, unknown>,
+): IO<R, E, void> {
+  return IO.defer(() => {
+    let out: IO<R, E, unknown> = IO.unit;
+    for (let i = 0; i < array.length; i++) {
+      out = out > f(i, array[i]);
+    }
+    return out;
+  });
+}
+
+/**
+ * @tsplus fluent fncts.ReadonlyArray mapIODiscard
+ */
+export function foreachArrayDiscard<A, R, E>(array: ReadonlyArray<A>, f: (a: A) => IO<R, E, unknown>): IO<R, E, void> {
+  return array.mapIOWithIndexDiscard((_, a) => f(a));
+}
+
+/**
+ * @tsplus fluent fncts.ReadonlyArray mapIOWithIndex
+ */
+export function foreachArrayWithIndex<A, R, E, B>(
+  array: ReadonlyArray<A>,
+  f: (i: number, a: A) => IO<R, E, B>,
+): IO<R, E, Conc<B>> {
+  return IO.defer(() => {
+    const acc: Array<B> = Array(array.length);
+    return array
+      .mapIOWithIndexDiscard((i, a) =>
+        f(i, a).flatMap((b) => {
+          acc[i] = b;
+          return IO.unit;
+        }),
+      )
+      .as(Conc.fromArray(acc));
+  });
+}
+
+/**
+ * @tsplus fluent fncts.ReadonlyArray mapIO
+ */
+export function foreachArray<A, R, E, B>(array: ReadonlyArray<A>, f: (a: A) => IO<R, E, B>): IO<R, E, Conc<B>> {
+  return array.mapIOWithIndex((_, a) => f(a));
+}

package/_src/IO/api/asyncInterrupt.ts

@@ -22,7 +22,7 @@ export function asyncInterrupt<R, E, A>(
   __tsplusTrace?: string,
 ): IO<R, E, A> {
   return IO.defer(() => {
-    let cancelerRef: URIO<R, any> = IO.unit!;
+    let cancelerRef: URIO<R, any> = IO.unit;
     return IO.async<R, E, A>((k) => {
       const result = register(k);
       result.match(

package/_src/IO/api/awaitAllChildren.ts

@@ -0,0 +1,6 @@
+/**
+ * @tsplus getter fncts.io.IO awaitAllChildren
+ */
+export function awaitAllChildren<R, E, A>(self: IO<R, E, A>): IO<R, E, A> {
+  return self.ensuringChildren(Fiber.awaitAll);
+}

package/_src/IO/api/cachedInvalidate.ts

@@ -0,0 +1,42 @@
+/**
+ * @tsplus pipeable fncts.io.IO cached
+ */
+export function cached(timeToLive: Lazy<Duration>, __tsplusTrace?: string) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R, never, FIO<E, A>> => {
+    return self.cachedInvalidate(timeToLive).map(([get]) => get);
+  };
+}
+/**
+ * @tsplus pipeable fncts.io.IO cachedInvalidate
+ */
+export function cachedInvalidate(timeToLive: Lazy<Duration>, __tsplusTrace?: string) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R, never, readonly [FIO<E, A>, UIO<void>]> => {
+    return IO.environmentWith((r) => {
+      const ttl   = timeToLive().milliseconds;
+      const cache = Ref.Synchronized.unsafeMake<Maybe<readonly [number, Future<E, A>]>>(Nothing());
+
+      function compute(start: number): IO<R, never, Maybe<readonly [number, Future<E, A>]>> {
+        return Do((Δ) => {
+          const f = Δ(Future.make<E, A>());
+          Δ(self.fulfill(f));
+          return Just([start + ttl, f] as const);
+        });
+      }
+
+      const get: IO<R, E, A> = IO.uninterruptibleMask((restore) =>
+        Clock.currentTime.flatMap((time) =>
+          cache
+            .updateJustAndGetIO((m) =>
+              m.match(
+                () => Just(restore(compute(time))),
+                ([end]) => (end - time <= 0 ? Just(restore(compute(time))) : Nothing()),
+              ),
+            )
+            .flatMap((a) => a.getOrThrow[1].await),
+        ),
+      );
+
+      return [get.provideEnvironment(r), cache.set(Nothing())];
+    });
+  };
+}

package/_src/IO/api/foreachConcurrent.ts

@@ -1,5 +1,8 @@
+import type { FiberRuntime } from "@fncts/io/Fiber";
+
 import { identity } from "@fncts/base/data/function";
 import { AtomicNumber } from "@fncts/base/internal/AtomicNumber";
+import { IOPrimitive, IOTag } from "@fncts/io/IO";
 
 /**
  * Applies the function `f` to each element of the `Iterable<A>` and runs
@@ -62,40 +65,53 @@ function foreachConcurrentUnboundedDiscard<R, E, A>(
     if (size === 0) {
       return IO.unit;
     }
+    if (size === 1) {
+      return f(arr[0]).asUnit;
+    }
     return IO.uninterruptibleMask((restore) => {
       const future = Future.unsafeMake<void, void>(FiberId.none);
       const ref    = new AtomicNumber(0);
       return IO.transplant((graft) =>
-        IO.concurrentFinalizersMask((restoreFinalizers) =>
-          IO.foreach(
-            as,
-            (a) =>
-              graft(
-                restore(restoreFinalizers(IO.defer(f(a)))).matchCauseIO(
-                  (cause) => future.fail(undefined).zipRight(IO.failCauseNow(cause)),
-                  () => {
-                    if (ref.incrementAndGet() === size) {
-                      future.unsafeDone(IO.unit);
-                    }
-                    return IO.unit;
-                  },
-                ),
-              ).forkDaemon,
-          ),
+        IO.foreach(
+          as,
+          (a) =>
+            graft.graftOnExitWith(restore(f(a)), (exit) =>
+              exit.match(
+                () => {
+                  future.unsafeDone(IO.failNow(undefined));
+                },
+                () => {
+                  if (ref.incrementAndGet() === size) {
+                    future.unsafeDone(IO.unit);
+                  }
+                },
+              ),
+            ).forkDaemon,
         ),
       ).flatMap((fibers) =>
         restore(future.await).matchCauseIO(
-          (cause) =>
+          (cause0) =>
             foreachConcurrentUnbounded(fibers, (f) => f.interrupt).flatMap((exits) =>
-              Exit.collectAllConcurrent(exits).match(
-                () => IO.failCauseNow(cause.stripFailures),
+              exits.collectAllConcurrent.match(
+                () => IO.failCauseNow(cause0.stripFailures),
                 (exit) =>
-                  exit.isFailure()
-                    ? IO.failCauseNow(Cause.parallel(cause.stripFailures, exit.cause))
-                    : IO.failCauseNow(cause.stripFailures),
+                  exit.match(
+                    (cause) => IO.failCauseNow(Cause.parallel(cause0.stripFailures, cause)),
+                    () => IO.failCauseNow(cause0.stripFailures),
+                  ),
               ),
             ),
-          () => IO.foreachDiscard(fibers, (fiber) => fiber.inheritRefs),
+          () => {
+            const it = fibers[Symbol.iterator]();
+            let result: IteratorResult<FiberRuntime<E, any>> = it.next();
+            return IO.whileLoop(
+              () => !result.done,
+              () => (result.value as FiberRuntime<E, any>).inheritAll,
+              () => {
+                result = it.next();
+              },
+            );
+          },
         ),
       );
     });

package/_src/IO/api/fork.ts

@@ -51,7 +51,7 @@ export function unsafeFork<R, E, A, E1, B>(
   trace?: string,
 ): FiberRuntime<E, A> {
   const fiber = unsafeMakeChildFiber(effect, parentFiber, parentRuntimeFlags, overrideScope, trace);
-  fiber.resume(effect);
+  fiber.startConcurrently(effect);
   return fiber;
 }
 

package/_src/IO/api/forkDaemon.ts

@@ -7,6 +7,6 @@ import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
  *
  * @tsplus getter fncts.io.IO forkDaemon
  */
-export function forkDaemon<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R, FiberRuntime<E, A>> {
-  return ma.fork.daemonChildren;
+export function forkDaemon<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): URIO<R, FiberRuntime<E, A>> {
+  return self.forkWithScopeOverride(FiberScope.global);
 }

package/_src/IO/api/memoize.ts

@@ -4,9 +4,9 @@ import type { FiberRefsPatch } from "@fncts/io/FiberRefs";
  * @tsplus getter fncts.io.IO memoize
  */
 export function memoize<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): UIO<IO<R, E, A>> {
-  return Do((_) => {
-    const future   = _(Future.make<E, readonly [FiberRefsPatch, A]>());
-    const complete = _(self.diffFiberRefs.fulfill(future).once);
+  return Do((Δ) => {
+    const future   = Δ(Future.make<E, readonly [FiberRefsPatch, A]>());
+    const complete = Δ(self.diffFiberRefs.fulfill(future).once);
     return complete > future.await.flatMap(([patch, a]) => IO.patchFiberRefs(patch).as(a));
   });
 }

package/_src/IO/api/onTermination.ts

@@ -2,8 +2,8 @@
  * @tsplus pipeable fncts.io.IO onTermination
  */
 export function onTermination<R1>(cleanup: (cause: Cause<never>) => URIO<R1, any>, __tsplusTrace?: string) {
-  return <R, E, A>(self: Lazy<IO<R, E, A>>): IO<R | R1, E, A> => {
-    return IO.defer(self).onExit((exit) =>
+  return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E, A> => {
+    return self.onExit((exit) =>
       exit.match(
         (cause) => {
           if (cause.isFailure) return IO.unit;

package/_src/IO/api/transplant.ts

@@ -1,5 +1,3 @@
-export type Grafter = <R, E, A>(effect: IO<R, E, A>) => IO<R, E, A>;
-
 /**
  * Transplants specified effects so that when those effects fork other
  * effects, the forked effects will be governed by the scope of the
@@ -14,6 +12,31 @@ export function transplant<R, E, A>(f: (_: Grafter) => IO<R, E, A>, __tsplusTrac
   return IO.withFiberRuntime((fiberState) => {
     const scopeOverride = fiberState.getFiberRef(FiberRef.forkScopeOverride);
     const scope         = scopeOverride.getOrElse(fiberState.scope);
-    return f(FiberRef.forkScopeOverride.locally(Just(scope)));
+    return f(new Grafter(scope));
   });
 }
+
+export class Grafter {
+  constructor(private readonly scope: FiberScope) {}
+
+  graft = <R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> =>
+    FiberRef.forkScopeOverride.locally(Just(this.scope))(io);
+
+  graftOnExit = <R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> =>
+    this.graftOnExitWith(io, () => IO.unit);
+
+  graftOnExitWith = <R, E, A>(
+    io: IO<R, E, A>,
+    ensuring: (exit: Exit<E, A>) => void,
+    __tsplusTrace?: string,
+  ): IO<R, E, A> =>
+    IO.uninterruptibleMask((restore) =>
+      restore(io).exitWith((exit) =>
+        IO.withFiberRuntime((fiber) => {
+          fiber.transferChildren(this.scope);
+          ensuring(exit);
+          return exit;
+        }),
+      ),
+    );
+}

package/_src/IO/api/zipConcurrent.ts

@@ -47,11 +47,11 @@ export function zipWithConcurrent<A, R1, E1, B, C>(that: IO<R1, E1, B>, f: (a: A
 function fork<R, E, A, C>(
   io: Lazy<IO<R, E, A>>,
   restore: InterruptibilityRestorer,
-  graft: Grafter,
+  grafter: Grafter,
   future: Future<void, void>,
   ref: AtomicBoolean,
 ): IO<R, never, Fiber<E, A>> {
-  return graft(restore(io())).matchCauseIO(
+  return grafter.graft(restore(io())).matchCauseIO(
     (cause) => future.fail(undefined) > IO.refailCause(cause),
     (a) => {
       if (ref.getAndSet(true)) {