effect 4.0.0-beta.100 → 4.0.0-beta.102

package/dist/internal/effect.js

@@ -20,7 +20,8 @@ import { internalCall } from "../Utils.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";
+import * as InternalRecord from "./record.js";
+import { CurrentErrorReporters, CurrentLogAnnotations, CurrentLogLevel, CurrentLogSpans, CurrentStackFrame, MinimumLogLevel, TracerEnabled, TracerSpanAnnotations, TracerSpanLinks, TracerTimingEnabled } from "./references.js";
 import { getStackTraceLimit, setStackTraceLimit } from "./stackTraceLimit.js";
 import { addSpanStackTrace, makeStackCleaner } from "./tracer.js";
 import { version } from "./version.js";
@@ -545,7 +546,7 @@ const fiberMiddleware = {
 const fiberStackAnnotations = fiber => {
   if (!fiber.currentStackFrame) return undefined;
   const annotations = new Map();
-  annotations.set(CauseStackTrace.key, fiber.currentStackFrame);
+  annotations.set(InterruptorStackTrace.key, fiber.currentStackFrame);
   return Context.makeUnsafe(annotations);
 };
 const fiberInterruptChildren = fiber => {
@@ -619,6 +620,10 @@ export const fiberJoinAll = self => callback(resume => {
       }
     }));
   }
+  return sync(() => {
+    failed = true;
+    cancels.forEach(cancel => cancel());
+  });
 });
 /** @internal */
 export const fiberInterrupt = self => withFiber(fiber => fiberInterruptAs(self, fiber.id));
@@ -1177,6 +1182,24 @@ export const updateService = /*#__PURE__*/dual(3, (self, service, f) => updateCo
   return Context.add(s, service, next);
 }));
 /** @internal */
+export const updateServiceScoped = (service, update, options) => uninterruptible(withFiber(fiber => {
+  const original = Context.getUnsafe(fiber.context, service);
+  const updated = update(original);
+  fiber.setContext(Context.add(fiber.context, service, updated));
+  return scopeAddFinalizerExit(Context.getUnsafe(fiber.context, scopeTag), _ => {
+    const current = Context.getUnsafe(fiber.context, service);
+    let next;
+    if (options?.reset === undefined) {
+      if (current !== updated) return void_;
+      next = original;
+    } else {
+      next = options.reset(original, updated, current);
+    }
+    fiber.setContext(Context.add(fiber.context, service, next));
+    return void_;
+  });
+}));
+/** @internal */
 export const context = () => getContext;
 const getContext = /*#__PURE__*/withFiber(fiber => succeed(fiber.context));
 /** @internal */
@@ -1202,8 +1225,6 @@ const provideServiceImpl = (self, service, implementation) => updateContext(self
 });
 /** @internal */
 export const provideServiceEffect = /*#__PURE__*/dual(3, (self, service, acquire) => flatMap(acquire, implementation => provideService(self, service, implementation)));
-/** @internal */
-export const withConcurrency = /*#__PURE__*/provideService(CurrentConcurrency);
 // ----------------------------------------------------------------------------
 // zipping
 // ----------------------------------------------------------------------------
@@ -1775,13 +1796,15 @@ const setInterruptible = /*#__PURE__*/makePrimitive({
 });
 const setInterruptibleTrue = /*#__PURE__*/setInterruptible(true);
 const setInterruptibleFalse = /*#__PURE__*/setInterruptible(false);
-/** @internal */
-export const interruptible = self => withFiber(fiber => {
-  if (fiber.interruptible) return self;
+const setFiberInterruptible = fiber => {
   fiber.interruptible = true;
   fiber._stack.push(setInterruptibleFalse);
   if (fiber._interruptedCause) return failCause(fiber._interruptedCause);
-  return self;
+};
+/** @internal */
+export const interruptible = self => withFiber(fiber => {
+  if (fiber.interruptible) return self;
+  return setFiberInterruptible(fiber) ?? self;
 });
 /** @internal */
 export const uninterruptibleMask = f => withFiber(fiber => {
@@ -1793,9 +1816,9 @@ export const uninterruptibleMask = f => withFiber(fiber => {
 /** @internal */
 export const interruptibleMask = f => withFiber(fiber => {
   if (fiber.interruptible) return f(identity);
-  fiber.interruptible = true;
-  fiber._stack.push(setInterruptibleFalse);
-  return f(uninterruptible);
+  const interrupted = setFiberInterruptible(fiber);
+  const effect = f(uninterruptible);
+  return interrupted ?? effect;
 });
 /** @internal */
 export const abortSignal = /*#__PURE__*/map(/*#__PURE__*/acquireRelease(/*#__PURE__*/sync(() => new AbortController()), controller => sync(() => controller.abort())), _ => _.signal);
@@ -1812,7 +1835,7 @@ export const all = (arg, options) => {
   return suspend(() => {
     const out = {};
     return as(forEach(Object.entries(arg), ([key, effect]) => map(options?.mode === "result" ? result(effect) : effect, value => {
-      out[key] = value;
+      InternalRecord.assignProperty(out, key, value);
     }), {
       discard: true,
       concurrency: options?.concurrency
@@ -1905,8 +1928,8 @@ export const whileLoop = /*#__PURE__*/makePrimitive({
   }
 });
 /** @internal */
-export const forEach = /*#__PURE__*/dual(args => typeof args[1] === "function", (iterable, f, options) => withFiber(parent => {
-  const concurrencyOption = options?.concurrency === "inherit" ? parent.getRef(CurrentConcurrency) : options?.concurrency ?? 1;
+export const forEach = /*#__PURE__*/dual(args => typeof args[1] === "function", (iterable, f, options) => suspend(() => {
+  const concurrencyOption = options?.concurrency ?? 1;
   const concurrency = concurrencyOption === "unbounded" ? Number.POSITIVE_INFINITY : Math.max(1, concurrencyOption);
   if (concurrency === 1) {
     return forEachSequential(iterable, f, options);
@@ -1956,6 +1979,13 @@ const iterateEagerImpl = options => {
     let effect;
     let nextIndex = index;
     const exits = orderedStep ? new Array(end) : undefined;
+    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;
+    };
     const runStep = (item, exit, currentIndex) => {
       if (!orderedStep) return step(state, item, exit, currentIndex);
       if (terminal) return terminal;
@@ -1989,9 +2019,15 @@ const iterateEagerImpl = options => {
         } else if (!parentFiber) {
           return callback(cb => {
             parentFiber = getCurrentFiber();
+            fibers = new Set();
             effect = eff;
             resume = cb;
-            const result = go();
+            let result;
+            try {
+              result = go();
+            } catch (error) {
+              return cb(failDefect(error));
+            }
             if (result) return cb(result);
             return suspend(() => {
               terminal = exitVoid;
@@ -2010,33 +2046,37 @@ const iterateEagerImpl = options => {
             continue;
           }
           // Add the fiber to the Set
-          if (fibers) fibers.add(fiber);else fibers = new Set([fiber]);
+          fibers.add(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]));
+            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]));
+                    }
                   }
                 }
+              } else {
+                const result = runStep(item, exit, currentIndex);
+                if (result) {
+                  terminal = result._tag === "Failure" ? exitFailCause(causeFromReasons(result.cause.reasons.slice())) : result;
+                  go();
+                }
               }
-            } else {
-              const result = runStep(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_);
               }
-            }
-            if (paused) {
-              const eff = go();
-              if (eff) resume(eff);
-            } else if (done && fibers.size === 0) {
-              resume(terminal ?? void_);
+            } catch (error) {
+              resume(failDefect(error));
             }
           });
           // Check if we have reached the concurrency limit
@@ -2170,13 +2210,13 @@ export const forkUnsafe = (parent, effect, immediate = false, daemon = false, un
 export const forkDetach = /*#__PURE__*/dual(args => isEffect(args[0]), (self, options) => withFiber(fiber => succeed(forkUnsafe(fiber, self, options?.startImmediately, true, options?.uninterruptible))));
 /** @internal */
 export const awaitAllChildren = self => withFiber(fiber => {
-  const initialChildren = fiber._children && Arr.fromIterable(fiber._children);
+  const initialChildren = fiber._children && new Set(fiber._children);
   return onExit(self, _ => {
     let children = fiber._children;
     if (children === undefined || children.size === 0) {
       return void_;
     } else if (initialChildren) {
-      children = Iterable.filter(children, child => !initialChildren.includes(child));
+      children = Iterable.filter(children, child => !initialChildren.has(child));
     }
     return asVoid(fiberAwaitAll(children));
   });
@@ -2285,7 +2325,7 @@ export const runSyncExitWith = context => {
     const fiber = runFork(effect, {
       scheduler
     });
-    fiber.currentDispatcher?.flush();
+    fiber._dispatcher?.flush();
     return fiber._exit ?? exitDie(new AsyncFiberError(fiber));
   };
 };
@@ -2306,27 +2346,45 @@ const succeedTrue = /*#__PURE__*/succeed(true);
 const succeedFalse = /*#__PURE__*/succeed(false);
 class Latch {
   waiters = [];
-  scheduled = false;
+  scheduled = undefined;
   _isOpen;
   constructor(isOpen) {
     this._isOpen = isOpen;
   }
   scheduleUnsafe(fiber) {
-    if (this.scheduled || this.waiters.length === 0) {
+    if (this.waiters.length === 0) {
       return succeedTrue;
     }
-    this.scheduled = true;
-    fiber.currentDispatcher.scheduleTask(this.flushWaiters, 0);
+    if (this.scheduled === undefined) {
+      this.scheduled = this.waiters;
+      fiber.currentDispatcher.scheduleTask(this.flushScheduled, 0);
+    } else {
+      for (let i = 0; i < this.waiters.length; i++) {
+        this.scheduled.push(this.waiters[i]);
+      }
+    }
+    this.waiters = [];
     return succeedTrue;
   }
-  flushWaiters = () => {
-    this.scheduled = false;
+  flushScheduled = () => {
+    if (this.scheduled === undefined) return;
+    const waiters = this.scheduled;
+    this.scheduled = undefined;
+    for (let i = 0; i < waiters.length; i++) {
+      waiters[i](exitVoid);
+    }
+  };
+  flushWaiters() {
+    // swap both arrays out before any resume runs: a resumed waiter can
+    // reentrantly close the latch and register new waiters, which must not
+    // be drained by this flush
     const waiters = this.waiters;
     this.waiters = [];
+    this.flushScheduled();
     for (let i = 0; i < waiters.length; i++) {
       waiters[i](exitVoid);
     }
-  };
+  }
   open = /*#__PURE__*/withFiber(fiber => {
     if (this._isOpen) return succeedFalse;
     this._isOpen = true;
@@ -2345,9 +2403,14 @@ class Latch {
     }
     this.waiters.push(resume);
     return sync(() => {
-      const index = this.waiters.indexOf(resume);
+      let index = this.waiters.indexOf(resume);
       if (index !== -1) {
         this.waiters.splice(index, 1);
+      } else if (this.scheduled !== undefined) {
+        index = this.scheduled.indexOf(resume);
+        if (index !== -1) {
+          this.scheduled.splice(index, 1);
+        }
       }
     });
   });
@@ -2534,13 +2597,16 @@ export const withSpan = function () {
 };
 /** @internal */
 export const annotateSpans = /*#__PURE__*/dual(args => isEffect(args[0]), (effect, ...args) => updateService(effect, TracerSpanAnnotations, annotations => {
-  const newAnnotations = {
+  const newAnnotations = args.length === 1 ? {
+    ...annotations,
+    ...args[0]
+  } : {
     ...annotations
   };
   if (args.length === 1) {
-    Object.assign(newAnnotations, args[0]);
+    return newAnnotations;
   } else {
-    newAnnotations[args[0]] = args[1];
+    InternalRecord.assignProperty(newAnnotations, args[0], args[1]);
   }
   return newAnnotations;
 }));
@@ -2747,7 +2813,7 @@ export const annotateLogsScoped = function () {
     };
     for (let i = 0; i < entries.length; i++) {
       const [key, value] = entries[i];
-      next[key] = value;
+      InternalRecord.assignProperty(next, key, value);
     }
     fiber.setContext(Context.add(fiber.context, CurrentLogAnnotations, next));
     return scopeAddFinalizerExit(Context.getUnsafe(fiber.context, scopeTag), _ => {
@@ -2758,8 +2824,8 @@ export const annotateLogsScoped = function () {
       for (let i = 0; i < entries.length; i++) {
         const [key, value] = entries[i];
         if (current[key] !== value) continue;
-        if (key in prev) {
-          next[key] = prev[key];
+        if (Object.hasOwn(prev, key)) {
+          InternalRecord.assignProperty(next, key, prev[key]);
         } else {
           delete next[key];
         }
@@ -3071,7 +3137,7 @@ export const tracerLogger = /*#__PURE__*/loggerMake(({
   if (span === undefined || span._tag === "ExternalSpan") return;
   const attributes = {};
   for (const [key, value] of Object.entries(annotations)) {
-    attributes[key] = value;
+    InternalRecord.assignProperty(attributes, key, value);
   }
   attributes["effect.fiberId"] = fiber.id;
   attributes["effect.logLevel"] = logLevel.toUpperCase();