effect 4.0.0-rc.118 → 4.0.0

package/dist/internal/effect.js

@@ -852,7 +852,7 @@ const asyncFinalizer = /*#__PURE__*/makePrimitive({
     }
   },
   [contE](cause, _fiber) {
-    return hasInterrupts(cause) ? flatMap(this[args](), () => failCause(cause)) : failCause(cause);
+    return hasInterrupts(cause) ? flatMap(combineFinalizerCause(exitFailCause(cause), this[args]()), () => failCause(cause)) : failCause(cause);
   }
 });
 /** @internal */
@@ -1079,73 +1079,75 @@ export const asVoid = self => new ContImpl(self, returnPayload, exitVoid);
 /** @internal */
 export const sandbox = self => catchCause(self, fail);
 /** @internal */
-export const raceAll = (all, options) => withFiber(parent => callback(resume => {
-  const effects = Arr.fromIterable(all);
-  const len = effects.length;
-  let doneCount = 0;
-  let done = false;
+export const raceAll = (all, options) => withFiber(parent => {
   const fibers = new Set();
-  const failures = [];
-  const onExit = (exit, fiber, i) => {
-    doneCount++;
-    if (exit._tag === "Failure") {
-      failures.push(...exit.cause.reasons);
-      if (doneCount >= len) {
-        resume(failCause(causeFromReasons(failures)));
+  // Read fibers on exit to include losers forked after the race settles.
+  onExitUnsafe(parent, () => fibers.size === 0 ? undefined : fiberInterruptAll(fibers));
+  return callback(resume => {
+    const effects = Arr.fromIterable(all);
+    const len = effects.length;
+    let doneCount = 0;
+    let done = false;
+    const failures = [];
+    const onExit = (exit, fiber, i) => {
+      doneCount++;
+      if (exit._tag === "Failure") {
+        failures.push(...exit.cause.reasons);
+        if (doneCount >= len) {
+          resume(failCause(causeFromReasons(failures)));
+        }
+        return;
       }
-      return;
-    }
-    const isWinner = !done;
-    done = true;
-    resume(fibers.size === 0 ? exit : flatMap(uninterruptible(fiberInterruptAll(fibers)), () => exit));
-    if (isWinner && options?.onWinner) {
-      options.onWinner({
-        fiber,
-        index: i,
-        parentFiber: parent
-      });
-    }
-  };
-  for (let i = 0; i < len; i++) {
-    const fiber = forkUnsafe(parent, effects[i], true, true, false);
-    fibers.add(fiber);
-    fiber.addObserver(exit => {
-      fibers.delete(fiber);
-      onExit(exit, fiber, i);
-    });
-    if (done) break;
-  }
-  return fiberInterruptAll(fibers);
-}));
-/** @internal */
-export const raceAllFirst = (all, options) => withFiber(parent => callback(resume => {
-  let done = false;
-  const fibers = new Set();
-  const onExit = exit => {
-    done = true;
-    resume(fibers.size === 0 ? exit : flatMap(uninterruptible(fiberInterruptAll(fibers)), () => exit));
-  };
-  let i = 0;
-  for (const effect of all) {
-    if (done) break;
-    const index = i++;
-    const fiber = forkUnsafe(parent, effect, true, true, false);
-    fibers.add(fiber);
-    fiber.addObserver(exit => {
-      fibers.delete(fiber);
       const isWinner = !done;
-      onExit(exit);
+      done = true;
+      resume(exit);
       if (isWinner && options?.onWinner) {
         options.onWinner({
           fiber,
-          index,
+          index: i,
           parentFiber: parent
         });
       }
-    });
-  }
-  return fiberInterruptAll(fibers);
-}));
+    };
+    for (let i = 0; i < len; i++) {
+      const fiber = forkUnsafe(parent, effects[i], true, true, false);
+      fibers.add(fiber);
+      fiber.addObserver(exit => {
+        fibers.delete(fiber);
+        onExit(exit, fiber, i);
+      });
+      if (done) break;
+    }
+  });
+});
+/** @internal */
+export const raceAllFirst = (all, options) => withFiber(parent => {
+  const fibers = new Set();
+  onExitUnsafe(parent, () => fibers.size === 0 ? undefined : fiberInterruptAll(fibers));
+  return callback(resume => {
+    let done = false;
+    let i = 0;
+    for (const effect of all) {
+      if (done) break;
+      const index = i++;
+      const fiber = forkUnsafe(parent, effect, true, true, false);
+      fibers.add(fiber);
+      fiber.addObserver(exit => {
+        fibers.delete(fiber);
+        const isWinner = !done;
+        done = true;
+        resume(exit);
+        if (isWinner && options?.onWinner) {
+          options.onWinner({
+            fiber,
+            index,
+            parentFiber: parent
+          });
+        }
+      });
+    }
+  });
+});
 /** @internal */
 export const race = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, options) => raceAll([self, that], options));
 /** @internal */
@@ -2100,11 +2102,11 @@ export const reduce = /*#__PURE__*/dual(3, (elements, zero, f) => {
 /** @internal */
 export const validate = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, f, options) => flatMap(partition(elements, f, {
   concurrency: options?.concurrency
-}), ([excluded, satisfying]) => {
-  if (Arr.isArrayNonEmpty(excluded)) {
-    return fail(excluded);
+}), ([passes, fails]) => {
+  if (Arr.isArrayNonEmpty(fails)) {
+    return fail(fails);
   }
-  return options?.discard ? void_ : succeed(satisfying);
+  return options?.discard ? void_ : succeed(passes);
 }));
 /** @internal */
 export const findFirst = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, predicate) => suspend(() => {
@@ -2233,26 +2235,22 @@ const iterateConcurrentImpl = options => {
     let parentFiber;
     let fibers;
     let resume;
-    let interrupted = false;
     let terminal;
     let effect;
     const failDefect = error => {
       const defect = exitDie(error);
       terminal = defect;
       done = true;
-      interrupted = true;
-      return fibers && fibers.size > 0 ? flatMap(uninterruptible(fiberInterruptAll(Array.from(fibers))), () => defect) : defect;
+      return fibers && fibers.size > 0 ? flatMap(uninterruptible(fiberInterruptAll(Array.from(fibers))), () => terminal ?? defect) : defect;
     };
     const go = () => {
       let paused = false;
       for (; !terminal && index < end; index++) {
         const item = items[index];
         const eff = effect ?? onItem(state, item, index);
-        // fast case (already an exit)
         if (effectIsExit(eff)) {
           terminal = step(state, item, eff, index);
           if (terminal) break;
-          // We have an effect, so enter "async" mode
         } else if (!parentFiber) {
           return callback(cb => {
             parentFiber = getCurrentFiber();
@@ -2267,14 +2265,12 @@ const iterateConcurrentImpl = options => {
             }
             if (result) return cb(result);
             return suspend(() => {
-              terminal = exitVoid;
-              interrupted = true;
-              return fibers ? fiberInterruptAll(fibers) : void_;
+              terminal ??= exitVoid;
+              return flatMap(fibers ? fiberInterruptAll(fibers) : void_, () => terminal?._tag === "Failure" ? terminal : void_);
             });
           });
-          // Fork the effect with concurrency > 1
         } else {
-          // Clear the temporary effect from capturing the parentFiber
+          // Clear the effect cached before the parent fiber was available.
           effect = undefined;
           const fiber = forkUnsafe(parentFiber, eff, true, true, "inherit");
           if (fiber._exit) {
@@ -2282,27 +2278,23 @@ const iterateConcurrentImpl = options => {
             if (terminal) break;
             continue;
           }
-          // Add the fiber to the Set
           fibers.add(fiber);
           const currentIndex = index;
           fiber.addObserver(exit => {
             fibers.delete(fiber);
             try {
               if (terminal) {
-                if (!interrupted && exit._tag === "Failure") {
-                  for (const reason of exit.cause.reasons) {
-                    if (reason._tag === "Interrupt") continue;else if (terminal._tag === "Failure") {
-                      ;
-                      terminal.cause.reasons.push(reason);
-                    } else {
-                      terminal = exitFailCause(causeFromReasons([reason]));
-                    }
+                if (exit._tag === "Failure") {
+                  const reasons = exit.cause.reasons.filter(reason => reason._tag !== "Interrupt");
+                  if (reasons.length > 0) {
+                    const cause = causeFromReasons(reasons);
+                    terminal = exitFailCause(terminal._tag === "Failure" ? causeCombine(terminal.cause, cause) : cause);
                   }
                 }
               } else {
                 const result = step(state, item, exit, currentIndex);
                 if (result) {
-                  terminal = result._tag === "Failure" ? exitFailCause(causeFromReasons(result.cause.reasons.slice())) : result;
+                  terminal = result;
                   go();
                 }
               }
@@ -2316,7 +2308,6 @@ const iterateConcurrentImpl = options => {
               resume(failDefect(error));
             }
           });
-          // Check if we have reached the concurrency limit
           if (fibers.size < concurrency) continue;
           paused = true;
           index++;