effect 4.0.0-beta.97 → 4.0.0-beta.99

package/dist/internal/effect.js

@@ -605,16 +605,22 @@ export const fiberInterruptAs = /*#__PURE__*/dual(args => hasProperty(args[0], F
 /** @internal */
 export const fiberInterruptAll = fibers => withFiber(parent => {
   const annotations = fiberStackAnnotations(parent);
+  let fiberArr = Arr.empty();
   for (const fiber of fibers) {
     fiber.interruptUnsafe(parent.id, annotations);
+    fiberArr.push(fiber);
   }
-  return asVoid(fiberAwaitAll(fibers));
+  return asVoid(fiberAwaitAll(fiberArr));
 });
 /** @internal */
 export const fiberInterruptAllAs = /*#__PURE__*/dual(2, (fibers, fiberId) => withFiber(parent => {
   const annotations = fiberStackAnnotations(parent);
-  for (const fiber of fibers) fiber.interruptUnsafe(fiberId, annotations);
-  return asVoid(fiberAwaitAll(fibers));
+  const fiberArr = Arr.empty();
+  for (const fiber of fibers) {
+    fiber.interruptUnsafe(fiberId, annotations);
+    fiberArr.push(fiber);
+  }
+  return asVoid(fiberAwaitAll(fiberArr));
 }));
 /** @internal */
 export const succeed = exitSucceed;
@@ -1896,6 +1902,7 @@ const iterateEagerImpl = options => {
     let index = opts?.start ?? 0;
     const end = opts?.end ?? items.length;
     const concurrency = opts?.concurrency ?? 1;
+    const orderedStep = opts?.orderedStep === true && concurrency > 1;
     let done = false;
     let parentFiber;
     let fibers;
@@ -1903,6 +1910,21 @@ const iterateEagerImpl = options => {
     let interrupted = false;
     let terminal;
     let effect;
+    let nextIndex = index;
+    const exits = orderedStep ? new Array(end) : undefined;
+    const runStep = (item, exit, currentIndex) => {
+      if (!orderedStep) return step(state, item, exit, currentIndex);
+      if (terminal) return terminal;
+      exits[currentIndex] = exit;
+      while (nextIndex < end) {
+        const nextExit = exits[nextIndex];
+        if (nextExit === undefined) return;
+        exits[nextIndex] = undefined;
+        const index = nextIndex++;
+        const result = step(state, items[index], nextExit, index);
+        if (result) return result;
+      }
+    };
     const go = () => {
       let paused = false;
       for (; !terminal && index < end; index++) {
@@ -1910,12 +1932,12 @@ const iterateEagerImpl = options => {
         const eff = effect ?? onItem(state, item, index);
         // fast case (already an exit)
         if (effectIsExit(eff)) {
-          terminal = step(state, item, eff, index);
+          terminal = runStep(item, eff, index);
           if (terminal) break;
           // Use flatMap for concurrency of 1
         } else if (concurrency === 1) {
           return flatMap(exit(eff), exit => {
-            terminal = step(state, item, exit, index);
+            terminal = runStep(item, exit, index);
             index++;
             return terminal ?? go() ?? void_;
           });
@@ -1939,7 +1961,7 @@ const iterateEagerImpl = options => {
           effect = undefined;
           const fiber = forkUnsafe(parentFiber, eff, true, true, "inherit");
           if (fiber._exit) {
-            terminal = step(state, item, fiber._exit, index);
+            terminal = runStep(item, fiber._exit, index);
             if (terminal) break;
             continue;
           }
@@ -1960,7 +1982,7 @@ const iterateEagerImpl = options => {
                 }
               }
             } else {
-              const result = step(state, item, exit, currentIndex);
+              const result = runStep(item, exit, currentIndex);
               if (result) {
                 terminal = result._tag === "Failure" ? exitFailCause(causeFromReasons(result.cause.reasons.slice())) : result;
                 go();
@@ -2517,11 +2539,13 @@ class ClockImpl {
   }
   currentTimeNanos = /*#__PURE__*/sync(() => this.currentTimeNanosUnsafe());
   sleep(duration) {
-    const millis = Duration.toMillis(duration);
-    if (millis <= 0) return yieldNow;
+    return this.sleepMillis(Duration.toMillis(duration));
+  }
+  sleepMillis(millis) {
+    if (millis <= 0) return yieldNow;else if (!Number.isFinite(millis)) return never;
     return callback(resume => {
-      if (millis > MAX_TIMER_MILLIS) return;
-      const handle = setTimeout(() => resume(void_), millis);
+      const continuation = millis > MAX_TIMER_MILLIS ? this.sleepMillis(millis - MAX_TIMER_MILLIS) : void_;
+      const handle = setTimeout(() => resume(continuation), Math.min(millis, MAX_TIMER_MILLIS));
       return sync(() => clearTimeout(handle));
     });
   }