effect 2.0.0-next.56 → 2.0.0-next.57

package/dist/esm/internal/fiberRuntime.js

@@ -68,9 +68,10 @@ const EvaluationSignalContinue = "Continue";
 const EvaluationSignalDone = "Done";
 /** @internal */
 const EvaluationSignalYieldNow = "Yield";
-/** @internal */
-export const runtimeFiberVariance = {
+const runtimeFiberVariance = {
+  /* c8 ignore next */
   _E: _ => _,
+  /* c8 ignore next */
   _A: _ => _
 };
 const absurd = _ => {
@@ -80,8 +81,8 @@ const contOpSuccess = {
   [OpCodes.OP_ON_SUCCESS]: (_, cont, value) => {
     return cont.i1(value);
   },
-  ["OnStep"]: (_, cont, value) => {
-    return cont.i1(core.exitSucceed(value));
+  ["OnStep"]: (_, _cont, value) => {
+    return core.exitSucceed(core.exitSucceed(value));
   },
   [OpCodes.OP_ON_SUCCESS_AND_FAILURE]: (_, cont, value) => {
     return cont.i2(value);
@@ -123,7 +124,7 @@ const drainQueueWhileRunningTable = {
 /**
  * Executes all requests, submitting requests to each data source in parallel.
  */
-const runBlockedRequests = self => core.forEachSequentialDiscard(_RequestBlock.flatten(self), requestsByRequestResolver => forEachParUnboundedDiscard(_RequestBlock.sequentialCollectionToChunk(requestsByRequestResolver), ([dataSource, sequential]) => {
+const runBlockedRequests = self => core.forEachSequentialDiscard(_RequestBlock.flatten(self), requestsByRequestResolver => forEachConcurrentDiscard(_RequestBlock.sequentialCollectionToChunk(requestsByRequestResolver), ([dataSource, sequential]) => {
   const map = new Map();
   for (const block of sequential) {
     for (const entry of block) {
@@ -131,7 +132,7 @@ const runBlockedRequests = self => core.forEachSequentialDiscard(_RequestBlock.f
     }
   }
   return core.fiberRefLocally(invokeWithInterrupt(dataSource.runAll(sequential), sequential.flat()), currentRequestMap, map);
-}, false));
+}, false, false));
 /** @internal */
 export class FiberRuntime {
   [internalFiber.FiberTypeId] = internalFiber.fiberVariance;
@@ -150,7 +151,7 @@ export class FiberRuntime {
   _asyncInterruptor = null;
   _asyncBlockingOn = null;
   _exitValue = null;
-  _steps = [false];
+  _steps = [];
   _supervisor;
   _scheduler;
   _tracer;
@@ -314,6 +315,12 @@ export class FiberRuntime {
   interruptAsFork(fiberId) {
     return core.sync(() => this.tell(FiberMessage.interruptSignal(internalCause.interrupt(fiberId))));
   }
+  /**
+   * In the background, interrupts the fiber as if interrupted from the specified fiber.
+   */
+  unsafeInterruptAsFork(fiberId) {
+    this.tell(FiberMessage.interruptSignal(internalCause.interrupt(fiberId)));
+  }
   /**
    * Adds an observer to the list of observers.
    *
@@ -792,16 +799,16 @@ export class FiberRuntime {
   pushStack(cont) {
     this._stack.push(cont);
     if (cont._op === "OnStep") {
-      this._steps.push(true);
-    }
-    if (cont._op === "RevertFlags") {
-      this._steps.push(false);
+      this._steps.push({
+        refs: this.getFiberRefs(),
+        flags: this._runtimeFlags
+      });
     }
   }
   popStack() {
     const item = this._stack.pop();
     if (item) {
-      if (item._op === "OnStep" || item._op === "RevertFlags") {
+      if (item._op === "OnStep") {
         this._steps.pop();
       }
       return item;
@@ -827,14 +834,7 @@ export class FiberRuntime {
     }
   }
   [OpCodes.OP_TAG](op) {
-    return core.map(core.fiberRefGet(core.currentContext), context => {
-      try {
-        return Context.unsafeGet(context, op);
-      } catch (e) {
-        console.log(e);
-        throw e;
-      }
-    });
+    return core.map(core.fiberRefGet(core.currentContext), context => Context.unsafeGet(context, op));
   }
   ["Left"](op) {
     return core.fail(op.left);
@@ -893,7 +893,7 @@ export class FiberRuntime {
         case "OnStep":
           {
             if (!(_runtimeFlags.interruptible(this._runtimeFlags) && this.isInterrupted())) {
-              return cont.i1(core.exitFailCause(cause));
+              return core.exitSucceed(core.exitFailCause(cause));
             } else {
               return core.exitFailCause(internalCause.stripFailures(cause));
             }
@@ -920,52 +920,30 @@ export class FiberRuntime {
     return op.i0(this, FiberStatus.running(this._runtimeFlags));
   }
   ["Blocked"](op) {
-    if (this._steps[this._steps.length - 1]) {
-      const nextOp = this.popStack();
-      if (nextOp) {
-        switch (nextOp._op) {
-          case "OnStep":
-            {
-              return nextOp.i1(op);
-            }
-          case "OnSuccess":
-            {
-              return core.blocked(op.i0, core.flatMap(op.i1, nextOp.i1));
-            }
-          case "OnSuccessAndFailure":
-            {
-              return core.blocked(op.i0, core.matchCauseEffect(op.i1, {
-                onFailure: nextOp.i1,
-                onSuccess: nextOp.i2
-              }));
-            }
-          case "OnFailure":
-            {
-              return core.blocked(op.i0, core.catchAllCause(op.i1, nextOp.i1));
-            }
-          case "While":
-            {
-              return core.blocked(op.i0, core.flatMap(op.i1, a => {
-                nextOp.i2(a);
-                if (nextOp.i0()) {
-                  return core.whileLoop({
-                    while: nextOp.i0,
-                    body: nextOp.i1,
-                    step: nextOp.i2
-                  });
-                }
-                return core.unit;
-              }));
-            }
-          case "RevertFlags":
-            {
-              this.pushStack(nextOp);
-              break;
-            }
-        }
+    const refs = this.getFiberRefs();
+    const flags = this._runtimeFlags;
+    if (this._steps.length > 0) {
+      const frames = [];
+      const snap = this._steps[this._steps.length - 1];
+      let frame = this.popStack();
+      while (frame && frame._op !== "OnStep") {
+        frames.push(frame);
+        frame = this.popStack();
       }
+      this.setFiberRefs(snap.refs);
+      this._runtimeFlags = snap.flags;
+      const patchRefs = FiberRefsPatch.diff(snap.refs, refs);
+      const patchFlags = _runtimeFlags.diff(snap.flags, flags);
+      return core.exitSucceed(core.blocked(op.i0, core.withFiberRuntime(newFiber => {
+        while (frames.length > 0) {
+          newFiber.pushStack(frames.pop());
+        }
+        newFiber.setFiberRefs(FiberRefsPatch.patch(newFiber.id(), newFiber.getFiberRefs())(patchRefs));
+        newFiber._runtimeFlags = _runtimeFlags.patch(patchFlags)(newFiber._runtimeFlags);
+        return op.i1;
+      })));
     }
-    return core.uninterruptibleMask(restore => core.flatMap(fork(core.runRequestBlock(op.i0)), () => restore(op.i1)));
+    return core.uninterruptibleMask(restore => core.flatMap(forkDaemon(core.runRequestBlock(op.i0)), () => restore(op.i1)));
   }
   ["RunBlocked"](op) {
     return runBlockedRequests(op.i0);
@@ -1061,7 +1039,6 @@ export class FiberRuntime {
       }
       try {
         if (!("_op" in cur) || !(cur._op in this)) {
-          console.log(cur);
           // @ts-expect-error
           absurd(cur);
         }
@@ -1200,7 +1177,7 @@ const existsLoop = (iterator, index, f) => {
 /* @internal */
 export const filter = /*#__PURE__*/dual(args => Predicate.isIterable(args[0]), (elements, f, options) => {
   const predicate = options?.negate ? (a, i) => core.map(f(a, i), Boolean.not) : f;
-  return concurrency.matchSimple(options?.concurrency, () => core.suspend(() => RA.fromIterable(elements).reduceRight((effect, a, i) => core.zipWith(effect, core.suspend(() => predicate(a, i)), (list, b) => b ? [a, ...list] : list), core.sync(() => new Array()))), () => core.map(forEach(elements, (a, i) => core.map(predicate(a, i), b => b ? Option.some(a) : Option.none()), options), RA.compact));
+  return concurrency.matchSimple(options?.concurrency, () => core.suspend(() => RA.fromIterable(elements).reduceRight((effect, a, i) => core.zipWith(effect, core.suspend(() => predicate(a, i)), (list, b) => b ? [a, ...list] : list), core.sync(() => new Array()))), () => core.map(forEach(elements, (a, i) => core.map(predicate(a, i), b => b ? Option.some(a) : Option.none()), options), RA.getSomes));
 });
 // === all
 const allResolveInput = input => {
@@ -1291,7 +1268,7 @@ export const replicateEffect = /*#__PURE__*/dual(args => core.isEffect(args[0]),
 export const forEach = /*#__PURE__*/dual(args => Predicate.isIterable(args[0]), (self, f, options) => core.withFiberRuntime(r => {
   const isRequestBatchingEnabled = options?.batching === true || options?.batching === "inherit" && r.getFiberRef(core.currentRequestBatching);
   if (options?.discard) {
-    return concurrency.match(options.concurrency, () => finalizersMask(ExecutionStrategy.sequential)(restore => isRequestBatchingEnabled ? forEachBatchedDiscard(self, (a, i) => restore(f(a, i))) : core.forEachSequentialDiscard(self, (a, i) => restore(f(a, i)))), () => finalizersMask(ExecutionStrategy.parallel)(restore => forEachParUnboundedDiscard(self, (a, i) => restore(f(a, i)), isRequestBatchingEnabled)), n => finalizersMask(ExecutionStrategy.parallelN(n))(restore => forEachParNDiscard(self, n, (a, i) => restore(f(a, i)), isRequestBatchingEnabled)));
+    return concurrency.match(options.concurrency, () => finalizersMask(ExecutionStrategy.sequential)(restore => isRequestBatchingEnabled ? forEachConcurrentDiscard(self, (a, i) => restore(f(a, i)), true, false, 1) : core.forEachSequentialDiscard(self, (a, i) => restore(f(a, i)))), () => finalizersMask(ExecutionStrategy.parallel)(restore => forEachConcurrentDiscard(self, (a, i) => restore(f(a, i)), isRequestBatchingEnabled, false)), n => finalizersMask(ExecutionStrategy.parallelN(n))(restore => forEachConcurrentDiscard(self, (a, i) => restore(f(a, i)), isRequestBatchingEnabled, false, n)));
   }
   return concurrency.match(options?.concurrency, () => finalizersMask(ExecutionStrategy.sequential)(restore => isRequestBatchingEnabled ? forEachParN(self, 1, (a, i) => restore(f(a, i)), true) : core.forEachSequential(self, (a, i) => restore(f(a, i)))), () => finalizersMask(ExecutionStrategy.parallel)(restore => forEachParUnbounded(self, (a, i) => restore(f(a, i)), isRequestBatchingEnabled)), n => finalizersMask(ExecutionStrategy.parallelN(n))(restore => forEachParN(self, n, (a, i) => restore(f(a, i)), isRequestBatchingEnabled)));
 }));
@@ -1300,155 +1277,137 @@ export const forEachParUnbounded = (self, f, batching) => core.suspend(() => {
   const as = RA.fromIterable(self);
   const array = new Array(as.length);
   const fn = (a, i) => core.flatMap(f(a, i), b => core.sync(() => array[i] = b));
-  return core.zipRight(forEachParUnboundedDiscard(as, fn, batching), core.succeed(array));
+  return core.zipRight(forEachConcurrentDiscard(as, fn, batching, false), core.succeed(array));
 });
-const forEachBatchedDiscard = (self, f) => core.suspend(() => {
-  const as = RA.fromIterable(self);
-  const size = as.length;
-  if (size === 0) {
+/** @internal */
+export const forEachConcurrentDiscard = (self, f, batching, processAll, n) => core.uninterruptibleMask(restore => core.transplant(graft => core.withFiberRuntime(parent => {
+  let todos = Array.from(self).reverse();
+  let target = todos.length;
+  if (target === 0) {
     return core.unit;
-  } else if (size === 1) {
-    return core.asUnit(f(as[0], 0));
-  }
-  const effects = as.map(f);
-  const blocked = new Array();
-  const loop = i => i === effects.length ? core.suspend(() => {
-    if (blocked.length > 0) {
-      const requests = blocked.map(b => b.i0).reduce(_RequestBlock.par);
-      return core.blocked(requests, forEachBatchedDiscard(blocked.map(b => b.i1), identity));
+  }
+  let counter = 0;
+  let interrupted = false;
+  const fibersCount = n ? Math.min(todos.length, n) : todos.length;
+  const fibers = new Set();
+  const results = new Array();
+  const interruptAll = () => fibers.forEach(fiber => {
+    fiber._scheduler.scheduleTask(() => {
+      fiber.unsafeInterruptAsFork(parent.id());
+    }, 0);
+  });
+  const startOrder = new Array();
+  const joinOrder = new Array();
+  const residual = new Array();
+  const collectExits = () => {
+    const exits = results.filter(({
+      exit
+    }) => exit._tag === "Failure").sort((a, b) => a.index < b.index ? -1 : a.index === b.index ? 0 : 1).map(({
+      exit
+    }) => exit);
+    if (exits.length === 0) {
+      exits.push(core.exitUnit);
     }
-    return core.unit;
-  }) : core.flatMapStep(effects[i], s => {
-    if (s._op === "Blocked") {
-      blocked.push(s);
-      return loop(i + 1);
-    } else if (s._op === "Failure") {
-      return core.suspend(() => {
-        if (blocked.length > 0) {
-          const requests = blocked.map(b => b.i0).reduce(_RequestBlock.par);
-          return core.blocked(requests, core.flatMap(forEachBatchedDiscard(blocked.map(b => b.i1), identity), () => s));
-        }
-        return core.unit;
-      });
-    } else {
-      return loop(i + 1);
+    return exits;
+  };
+  const runFiber = eff => {
+    const runnable = core.uninterruptible(graft(eff));
+    const fiber = unsafeForkUnstarted(runnable, parent, parent._runtimeFlags, fiberScope.globalScope);
+    parent._scheduler.scheduleTask(() => {
+      fiber.resume(runnable);
+    }, 0);
+    return fiber;
+  };
+  const onInterruptSignal = () => {
+    if (!processAll) {
+      target -= todos.length;
+      todos = [];
     }
-  });
-  return loop(0);
-});
-/* @internal */
-export const forEachParUnboundedDiscard = (self, f, batching) => core.suspend(() => {
-  const as = RA.fromIterable(self);
-  const size = as.length;
-  if (size === 0) {
-    return core.unit;
-  } else if (size === 1) {
-    return core.asUnit(f(as[0], 0));
-  }
-  return core.uninterruptibleMask(restore => {
-    const deferred = core.deferredUnsafeMake(FiberId.none);
-    let ref = 0;
-    const residual = [];
-    const joinOrder = [];
-    const process = core.transplant(graft => core.forEachSequential(as, (a, i) => pipe(graft(pipe(core.suspend(() => restore((batching ? core.step : core.exit)(f(a, i)))), core.flatMap(exit => {
-      switch (exit._op) {
-        case "Failure":
-          {
-            if (residual.length > 0) {
-              const requests = residual.map(blocked => blocked.i0).reduce(_RequestBlock.par);
-              const _continue = forEachParUnboundedDiscard(residual, blocked => blocked.i1, batching);
-              return core.blocked(requests, core.matchCauseEffect(_continue, {
-                onFailure: cause => core.zipRight(core.deferredFail(deferred, void 0), core.failCause(internalCause.parallel(cause, exit.cause))),
-                onSuccess: () => core.zipRight(core.deferredFail(deferred, void 0), core.failCause(exit.cause))
-              }));
+    interrupted = true;
+    interruptAll();
+  };
+  const stepOrExit = batching ? core.step : core.exit;
+  const processingFiber = runFiber(core.async(resume => {
+    const pushResult = (res, index) => {
+      if (res._op === "Blocked") {
+        residual.push(res);
+      } else {
+        results.push({
+          index,
+          exit: res
+        });
+        if (res._op === "Failure" && !interrupted) {
+          onInterruptSignal();
+        }
+      }
+    };
+    const next = () => {
+      if (todos.length > 0) {
+        const a = todos.pop();
+        let index = counter++;
+        const returnNextElement = () => {
+          const a = todos.pop();
+          index = counter++;
+          return core.flatMap(core.yieldNow(), () => core.flatMap(stepOrExit(restore(f(a, index))), onRes));
+        };
+        const onRes = res => {
+          if (todos.length > 0) {
+            pushResult(res, index);
+            if (todos.length > 0) {
+              return returnNextElement();
             }
-            return core.zipRight(core.deferredFail(deferred, void 0), core.failCause(exit.cause));
           }
-        default:
-          {
-            if (exit._op === "Blocked") {
-              residual.push(exit);
-            }
-            if (ref + 1 === size) {
-              if (residual.length > 0) {
-                const requests = residual.map(blocked => blocked.i0).reduce(_RequestBlock.par);
-                const _continue = forEachParUnboundedDiscard(residual, blocked => blocked.i1, batching);
-                return core.deferredSucceed(deferred, core.blocked(requests, _continue));
-              } else {
-                core.deferredUnsafeDone(deferred, core.exitSucceed(core.exitUnit));
-              }
-            } else {
-              ref = ref + 1;
-            }
-            return core.unit;
+          return core.succeed(res);
+        };
+        const todo = core.flatMap(stepOrExit(restore(f(a, index))), onRes);
+        const fiber = runFiber(todo);
+        startOrder.push(fiber);
+        fibers.add(fiber);
+        if (interrupted) {
+          fiber._scheduler.scheduleTask(() => {
+            fiber.unsafeInterruptAsFork(parent.id());
+          }, 0);
+        }
+        fiber.addObserver(wrapped => {
+          let exit;
+          if (wrapped._op === "Failure") {
+            exit = wrapped;
+          } else {
+            exit = wrapped.i0;
+          }
+          joinOrder.push(fiber);
+          fibers.delete(fiber);
+          pushResult(exit, index);
+          if (results.length === target) {
+            resume(core.succeed(Option.getOrElse(core.exitCollectAll(collectExits(), {
+              parallel: true
+            }), () => core.exitUnit)));
+          } else if (residual.length + results.length === target) {
+            const requests = residual.map(blocked => blocked.i0).reduce(_RequestBlock.par);
+            resume(core.succeed(core.blocked(requests, forEachConcurrentDiscard([Option.getOrElse(core.exitCollectAll(collectExits(), {
+              parallel: true
+            }), () => core.exitUnit), ...residual.map(blocked => blocked.i1)], i => i, batching, true, n))));
+          } else {
+            next();
           }
-      }
-    }))), forkDaemon, core.map(fiber => {
-      fiber.addObserver(() => {
-        joinOrder.push(fiber);
-      });
-      return fiber;
-    }))));
-    return core.flatMap(process, fibers => core.matchCauseEffect(restore(core.deferredAwait(deferred)), {
-      onFailure: cause => core.flatMap(forEachParUnbounded(fibers, core.interruptFiber, batching), exits => {
-        const exit = core.exitCollectAll(exits, {
-          parallel: true
         });
-        if (exit._tag === "Some" && core.exitIsFailure(exit.value)) {
-          return core.failCause(internalCause.parallel(internalCause.stripFailures(cause), exit.value.i0));
-        } else {
-          return core.failCause(internalCause.stripFailures(cause));
-        }
-      }),
-      onSuccess: rest => core.flatMap(rest, () => core.forEachSequentialDiscard(joinOrder, f => f.inheritAll))
-    }));
-  });
-});
+      }
+    };
+    for (let i = 0; i < fibersCount; i++) {
+      next();
+    }
+  }));
+  return core.asUnit(core.tap(core.flatten(core.onInterrupt(restore(internalFiber.join(processingFiber)), () => {
+    onInterruptSignal();
+    return internalFiber._await(processingFiber);
+  })), () => core.forEachSequential(joinOrder, f => f.inheritAll)));
+})));
 /* @internal */
 export const forEachParN = (self, n, f, batching) => core.suspend(() => {
   const as = RA.fromIterable(self);
   const array = new Array(as.length);
   const fn = (a, i) => core.map(f(a, i), b => array[i] = b);
-  return core.zipRight(forEachParNDiscard(as, n, fn, batching), core.succeed(array));
-});
-/* @internal */
-export const forEachParNDiscard = (self, n, f, batching) => core.suspend(() => {
-  let i = 0;
-  const iterator = self[Symbol.iterator]();
-  const residual = [];
-  const worker = core.flatMap(core.sync(() => iterator.next()), next => next.done ? core.unit : core.flatMap((batching ? core.step : core.exit)(core.asUnit(f(next.value, i++))), res => {
-    switch (res._op) {
-      case "Blocked":
-        {
-          residual.push(res);
-          return worker;
-        }
-      case "Failure":
-        {
-          return res;
-        }
-      case "Success":
-        return worker;
-    }
-  }));
-  const effects = [];
-  for (let i = 0; i < n; i++) {
-    effects.push(worker);
-  }
-  return core.flatMap(core.exit(forEachParUnboundedDiscard(effects, identity, batching)), exit => {
-    if (residual.length === 0) {
-      return exit;
-    }
-    const requests = residual.map(blocked => blocked.i0).reduce(_RequestBlock.par);
-    const _continue = forEachParNDiscard(residual, n, blocked => blocked.i1, batching);
-    if (exit._tag === "Failure") {
-      return core.blocked(requests, core.matchCauseEffect(_continue, {
-        onFailure: cause => core.exitFailCause(internalCause.parallel(exit.cause, cause)),
-        onSuccess: () => exit
-      }));
-    }
-    return core.blocked(requests, _continue);
-  });
+  return core.zipRight(forEachConcurrentDiscard(as, fn, batching, false, n), core.succeed(array));
 });
 /* @internal */
 export const fork = self => core.withFiberRuntime((state, status) => core.succeed(unsafeFork(self, state, status.runtimeFlags)));
@@ -1475,6 +1434,11 @@ export const unsafeFork = (effect, parentFiber, parentRuntimeFlags, overrideScop
   return childFiber;
 };
 /** @internal */
+export const unsafeForkUnstarted = (effect, parentFiber, parentRuntimeFlags, overrideScope = null) => {
+  const childFiber = unsafeMakeChildFiber(effect, parentFiber, parentRuntimeFlags, overrideScope);
+  return childFiber;
+};
+/** @internal */
 export const unsafeMakeChildFiber = (effect, parentFiber, parentRuntimeFlags, overrideScope = null) => {
   const childId = FiberId.unsafeMake();
   const parentFiberRefs = parentFiber.getFiberRefs();
@@ -1724,7 +1688,7 @@ export const fiberAll = fibers => ({
   [internalFiber.FiberTypeId]: internalFiber.fiberVariance,
   id: () => RA.fromIterable(fibers).reduce((id, fiber) => FiberId.combine(id, fiber.id()), FiberId.none),
   await: core.exit(forEachParUnbounded(fibers, fiber => core.flatten(fiber.await), false)),
-  children: core.map(forEachParUnbounded(fibers, fiber => fiber.children, false), RA.flatten),
+  children: core.map(forEachParUnbounded(fibers, fiber => fiber.children, false), children => RA.flatten(children)),
   inheritAll: core.forEachSequentialDiscard(fibers, fiber => fiber.inheritAll),
   poll: core.map(core.forEachSequential(fibers, fiber => fiber.poll), RA.reduceRight(Option.some(core.exitSucceed(new Array())), (optionB, optionA) => {
     switch (optionA._tag) {