effect 4.0.0-beta.50 → 4.0.0-beta.52

package/dist/internal/effect.js

@@ -17,7 +17,7 @@ import * as Result from "../Result.js";
 import * as Scheduler from "../Scheduler.js";
 import * as Tracer from "../Tracer.js";
 import { internalCall } from "../Utils.js";
-import { args, causeAnnotate, causeEmpty, causeFromReasons, CauseImpl, constEmptyAnnotations, contA, contAll, contE, Die, evaluate, exitDie, exitFail, exitFailCause, exitSucceed, ExitTypeId, Fail, InterruptorStackTrace, isCause, isDieReason, isEffect, isFailReason, isInterruptReason, isNoSuchElementError, makePrimitive, makePrimitiveProto, NoSuchElementError, ReasonBase, StackTraceKey as CauseStackTrace, TaggedError, withFiber, Yield } from "./core.js";
+import { args, causeAnnotate, causeEmpty, causeFromReasons, CauseImpl, constEmptyAnnotations, contA, contAll, contE, evaluate, exitDie, exitFail, exitFailCause, exitSucceed, ExitTypeId, Fail, InterruptorStackTrace, isCause, isDieReason, isEffect, isFailReason, isInterruptReason, isNoSuchElementError, makePrimitive, makePrimitiveProto, NoSuchElementError, ReasonBase, StackTraceKey as CauseStackTrace, TaggedError, withFiber, Yield } from "./core.js";
 import * as doNotation from "./doNotation.js";
 import * as InternalMetric from "./metric.js";
 import { CurrentConcurrency, CurrentErrorReporters, CurrentLogAnnotations, CurrentLogLevel, CurrentLogSpans, CurrentStackFrame, MinimumLogLevel, TracerEnabled, TracerSpanAnnotations, TracerSpanLinks, TracerTimingEnabled } from "./references.js";
@@ -1834,70 +1834,13 @@ export const forEach = /*#__PURE__*/dual(args => typeof args[1] === "function",
     return options?.discard ? void_ : succeed([]);
   }
   const out = options?.discard ? undefined : new Array(length);
-  let index = 0;
-  const annotations = fiberStackAnnotations(parent);
-  return callback(resume => {
-    const fibers = new Set();
-    const failures = [];
-    let failed = false;
-    let inProgress = 0;
-    let doneCount = 0;
-    let pumping = false;
-    let interrupted = false;
-    function pump() {
-      pumping = true;
-      while (inProgress < concurrency && index < length) {
-        const currentIndex = index;
-        const item = items[currentIndex];
-        index++;
-        inProgress++;
-        try {
-          const child = forkUnsafe(parent, f(item, currentIndex), true, true, "inherit");
-          fibers.add(child);
-          child.addObserver(exit => {
-            if (interrupted) {
-              return;
-            }
-            fibers.delete(child);
-            if (exit._tag === "Failure") {
-              if (!failed) {
-                failed = true;
-                length = index;
-                failures.push(...exit.cause.reasons);
-                fibers.forEach(fiber => fiber.interruptUnsafe(parent.id, annotations));
-              } else {
-                for (const f of exit.cause.reasons) {
-                  if (f._tag === "Interrupt") continue;
-                  failures.push(f);
-                }
-              }
-            } else if (out !== undefined) {
-              out[currentIndex] = exit.value;
-            }
-            doneCount++;
-            inProgress--;
-            if (doneCount === length) {
-              resume(failures.length > 0 ? exitFailCause(causeFromReasons(failures)) : succeed(out));
-            } else if (!pumping && !failed && inProgress < concurrency) {
-              pump();
-            }
-          });
-        } catch (err) {
-          failed = true;
-          length = index;
-          failures.push(new Die(err));
-          fibers.forEach(fiber => fiber.interruptUnsafe(parent.id, annotations));
-        }
-      }
-      pumping = false;
-    }
-    pump();
-    return suspend(() => {
-      interrupted = true;
-      index = length;
-      return fiberInterruptAll(fibers);
-    });
+  const eff = forEachConcurrent({
+    f,
+    out
+  }, items, {
+    concurrency
   });
+  return eff ? as(eff, out) : succeed(out);
 }));
 const forEachSequential = (iterable, f, options) => suspend(() => {
   const out = options?.discard ? undefined : [];
@@ -1913,6 +1856,130 @@ const forEachSequential = (iterable, f, options) => suspend(() => {
     }
   }), out);
 });
+const iterateEagerImpl = options => {
+  const onItem = options.onItem;
+  const step = options.step;
+  return (state, items, opts) => {
+    let index = opts?.start ?? 0;
+    const end = opts?.end ?? items.length;
+    const concurrency = opts?.concurrency ?? 1;
+    let done = false;
+    let parentFiber;
+    let fibers;
+    let resume;
+    let interrupted = false;
+    let terminal;
+    let effect;
+    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;
+          // Use flatMap for concurrency of 1
+        } else if (concurrency === 1) {
+          return flatMap(exit(eff), exit => {
+            terminal = step(state, item, exit, index);
+            index++;
+            return terminal ?? go() ?? void_;
+          });
+          // We have an effect, so enter "async" mode
+        } else if (!parentFiber) {
+          return callback(cb => {
+            parentFiber = getCurrentFiber();
+            effect = eff;
+            resume = cb;
+            const result = go();
+            if (result) return cb(result);
+            return suspend(() => {
+              terminal = exitVoid;
+              interrupted = true;
+              return fibers ? fiberInterruptAll(fibers) : void_;
+            });
+          });
+          // Fork the effect with concurrency > 1
+        } else {
+          // Clear the temporary effect from capturing the parentFiber
+          effect = undefined;
+          const fiber = forkUnsafe(parentFiber, eff, true, true, "inherit");
+          if (fiber._exit) {
+            terminal = step(state, item, fiber._exit, index);
+            if (terminal) break;
+            continue;
+          }
+          // Add the fiber to the Set
+          if (fibers) fibers.add(fiber);else fibers = new Set([fiber]);
+          const currentIndex = index;
+          fiber.addObserver(exit => {
+            fibers.delete(fiber);
+            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]));
+                  }
+                }
+              }
+            } else {
+              const result = step(state, item, exit, currentIndex);
+              if (result) {
+                terminal = result._tag === "Failure" ? exitFailCause(causeFromReasons(result.cause.reasons.slice())) : result;
+                go();
+              }
+            }
+            if (paused) {
+              const eff = go();
+              if (eff) resume(eff);
+            } else if (done && fibers.size === 0) {
+              resume(terminal ?? void_);
+            }
+          });
+          // Check if we have reached the concurrency limit
+          if (fibers.size < concurrency) continue;
+          paused = true;
+          index++;
+          return;
+        }
+      }
+      done = true;
+      if (terminal) {
+        if (fibers && fibers.size > 0) {
+          const annotations = fiberStackAnnotations(parentFiber);
+          fibers.forEach(f => f.interruptUnsafe(parentFiber.id, annotations));
+          return;
+        }
+        if (resume || terminal._tag === "Failure") {
+          return terminal;
+        }
+      } else if (resume) {
+        if (!fibers) {
+          return exitVoid;
+        } else if (fibers.size === 0) {
+          resume(void_);
+        }
+      }
+    };
+    return go();
+  };
+};
+/** @internal */
+export const iterateEager = () => iterateEagerImpl;
+const forEachConcurrent = /*#__PURE__*/iterateEagerImpl({
+  onItem(state, item, index) {
+    return state.f(item, index);
+  },
+  step(state, _, exit, index) {
+    if (exit._tag === "Failure") return exit;else if (state.out) {
+      state.out[index] = exit.value;
+    }
+  }
+});
 /* @internal */
 export const filterOrElse = /*#__PURE__*/dual(3, (self, predicate, orElse) => flatMap(self, a => predicate(a) ? succeed(a) : orElse(a)));
 /** @internal */
@@ -2258,7 +2325,7 @@ export const makeSpanUnsafe = (fiber, name, options) => {
       parent,
       annotations: options?.annotations ?? Context.empty(),
       links,
-      startTime: timingEnabled ? clock.currentTimeNanosUnsafe() : 0n,
+      startTime: timingEnabled ? clock.currentTimeNanosUnsafe() : BigInt(0),
       kind: options?.kind ?? "internal",
       root: options?.root ?? Option.isNone(parent),
       sampled: options?.sampled ?? (Option.isSome(parent) && parent.value.sampled === false ? false : !isLogLevelGreaterThan(fiber.getRef(Tracer.MinimumTraceLevel), level))
@@ -2756,6 +2823,7 @@ const prettyLoggerTty = options => {
     message: message_
   }) => {
     const console = fiber.getRef(ConsoleRef);
+    // oxlint-disable-next-line no-console
     const log = fiber.getRef(LogToStderr) ? console.error : console.log;
     const message = Array.isArray(message_) ? message_.slice() : [message_];
     let firstLine = color(`[${options.formatDate(date)}]`, colors.white) + ` ${color(logLevel.toUpperCase(), ...logLevelColors[logLevel])}` + ` (#${fiber.id})`;
@@ -2774,6 +2842,7 @@ const prettyLoggerTty = options => {
       }
     }
     log(firstLine);
+    // oxlint-disable-next-line no-console
     if (!processIsBun) console.group();
     if (cause.reasons.length > 0) {
       log(causePretty(cause));
@@ -2787,6 +2856,7 @@ const prettyLoggerTty = options => {
     for (const [key, value] of Object.entries(annotations)) {
       log(color(`${key}:`, colors.bold, colors.white), redact(value));
     }
+    // oxlint-disable-next-line no-console
     if (!processIsBun) console.groupEnd();
   });
 };
@@ -2827,12 +2897,15 @@ const prettyLoggerBrowser = options => {
         messageIndex++;
       }
     }
+    // oxlint-disable-next-line no-console
     console.groupCollapsed(firstLine, ...firstParams);
     if (cause.reasons.length > 0) {
+      // oxlint-disable-next-line no-console
       console.error(causePretty(cause));
     }
     if (messageIndex < message.length) {
       for (; messageIndex < message.length; messageIndex++) {
+        // oxlint-disable-next-line no-console
         console.log(redact(message[messageIndex]));
       }
     }
@@ -2840,11 +2913,14 @@ const prettyLoggerBrowser = options => {
     for (const [key, value] of Object.entries(annotations)) {
       const redacted = redact(value);
       if (options.colors) {
+        // oxlint-disable-next-line no-console
         console.log(`%c${key}:`, "color:gray", redacted);
       } else {
+        // oxlint-disable-next-line no-console
         console.log(`${key}:`, redacted);
       }
     }
+    // oxlint-disable-next-line no-console
     console.groupEnd();
   });
 };
@@ -2871,6 +2947,7 @@ export const defaultLogger = /*#__PURE__*/loggerMake(({
     message_.push(annotations);
   }
   const console = fiber.getRef(ConsoleRef);
+  // oxlint-disable-next-line no-console
   const log = fiber.getRef(LogToStderr) ? console.error : console.log;
   log(`[${defaultDateFormat(date)}] ${logLevel.toUpperCase()} (#${fiber.id})${spanString}:`, ...message_);
 });