effect 2.4.18 → 3.0.0

package/dist/esm/internal/fiberRuntime.js

@@ -1,3 +1,4 @@
+import * as RA from "../Array.js";
 import * as Boolean from "../Boolean.js";
 import * as Chunk from "../Chunk.js";
 import * as Context from "../Context.js";
@@ -18,7 +19,6 @@ import * as MRef from "../MutableRef.js";
 import * as Option from "../Option.js";
 import { pipeArguments } from "../Pipeable.js";
 import * as Predicate from "../Predicate.js";
-import * as RA from "../ReadonlyArray.js";
 import * as Ref from "../Ref.js";
 import * as RuntimeFlagsPatch from "../RuntimeFlagsPatch.js";
 import { currentScheduler } from "../Scheduler.js";
@@ -113,7 +113,7 @@ const contOpSuccess = {
       self.pushStack(cont);
       return cont.effect_instruction_i1();
     } else {
-      return core.unit;
+      return core.void;
     }
   }
 };
@@ -561,7 +561,7 @@ export class FiberRuntime {
       const body = () => {
         const next = it.next();
         if (!next.done) {
-          return core.asUnit(next.value.await);
+          return core.asVoid(next.value.await);
         } else {
           return core.sync(() => {
             isDone = true;
@@ -700,10 +700,10 @@ export class FiberRuntime {
           if (op._op === OpCodes.OP_YIELD) {
             if (_runtimeFlags.cooperativeYielding(this._runtimeFlags)) {
               this.tell(FiberMessage.yieldNow());
-              this.tell(FiberMessage.resume(core.exitUnit));
+              this.tell(FiberMessage.resume(core.exitVoid));
               effect = null;
             } else {
-              effect = core.exitUnit;
+              effect = core.exitVoid;
             }
           } else if (op._op === OpCodes.OP_ASYNC) {
             // Terminate this evaluation, async resumption will continue evaluation:
@@ -982,7 +982,7 @@ export class FiberRuntime {
         this.pushStack(new core.RevertFlags(revertFlags, op));
         return op.effect_instruction_i1(oldRuntimeFlags);
       } else {
-        return core.exitUnit;
+        return core.exitVoid;
       }
     }
   }
@@ -1020,7 +1020,7 @@ export class FiberRuntime {
       this.pushStack(op);
       return body();
     } else {
-      return core.exitUnit;
+      return core.exitVoid;
     }
   }
   [OpCodes.OP_COMMIT](op) {
@@ -1151,7 +1151,7 @@ export const batchedLogger = /*#__PURE__*/dual(3, (self, window, f) => core.flat
   let buffer = [];
   const flush = core.suspend(() => {
     if (buffer.length === 0) {
-      return core.unit;
+      return core.void;
     }
     const arr = buffer;
     buffer = [];
@@ -1191,8 +1191,8 @@ export const daemonChildren = self => {
 const _existsParFound = /*#__PURE__*/Symbol.for("effect/Effect/existsPar/found");
 /* @internal */
 export const exists = /*#__PURE__*/dual(args => Predicate.isIterable(args[0]), (elements, f, options) => concurrency.matchSimple(options?.concurrency, () => core.suspend(() => existsLoop(elements[Symbol.iterator](), 0, f)), () => core.matchEffect(forEach(elements, (a, i) => core.if_(f(a, i), {
-  onTrue: core.fail(_existsParFound),
-  onFalse: core.unit
+  onTrue: () => core.fail(_existsParFound),
+  onFalse: () => core.void
 }), options), {
   onFailure: e => e === _existsParFound ? core.succeed(true) : core.fail(e),
   onSuccess: () => core.succeed(false)
@@ -1252,7 +1252,7 @@ const allValidate = (effects, reconcile, options) => {
     if (errored) {
       return reconcile._tag === "Some" ? core.fail(reconcile.value(errors)) : core.fail(errors);
     } else if (options?.discard) {
-      return core.unit;
+      return core.void;
     }
     return reconcile._tag === "Some" ? core.succeed(reconcile.value(successes)) : core.succeed(successes);
   });
@@ -1314,7 +1314,7 @@ export const forEachConcurrentDiscard = (self, f, batching, processAll, n) => co
   let todos = Array.from(self).reverse();
   let target = todos.length;
   if (target === 0) {
-    return core.unit;
+    return core.void;
   }
   let counter = 0;
   let interrupted = false;
@@ -1336,7 +1336,7 @@ export const forEachConcurrentDiscard = (self, f, batching, processAll, n) => co
       exit
     }) => exit);
     if (exits.length === 0) {
-      exits.push(core.exitUnit);
+      exits.push(core.exitVoid);
     }
     return exits;
   };
@@ -1414,12 +1414,12 @@ export const forEachConcurrentDiscard = (self, f, batching, processAll, n) => co
           if (results.length === target) {
             resume(core.succeed(Option.getOrElse(core.exitCollectAll(collectExits(), {
               parallel: true
-            }), () => core.exitUnit)));
+            }), () => core.exitVoid)));
           } else if (residual.length + results.length === target) {
             const requests = residual.map(blocked => blocked.effect_instruction_i0).reduce(_RequestBlock.par);
             resume(core.succeed(core.blocked(requests, forEachConcurrentDiscard([Option.getOrElse(core.exitCollectAll(collectExits(), {
               parallel: true
-            }), () => core.exitUnit), ...residual.map(blocked => blocked.effect_instruction_i1)], i => i, batching, true, n))));
+            }), () => core.exitVoid), ...residual.map(blocked => blocked.effect_instruction_i1)], i => i, batching, true, n))));
           } else {
             next();
           }
@@ -1430,7 +1430,7 @@ export const forEachConcurrentDiscard = (self, f, batching, processAll, n) => co
       next();
     }
   }));
-  return core.asUnit(core.onExit(core.flatten(restore(internalFiber.join(processingFiber))), core.exitMatch({
+  return core.asVoid(core.onExit(core.flatten(restore(internalFiber.join(processingFiber))), core.exitMatch({
     onFailure: () => {
       onInterruptSignal();
       const target = residual.length + 1;
@@ -1522,7 +1522,7 @@ export const partition = /*#__PURE__*/dual(args => Predicate.isIterable(args[0])
 export const validateAll = /*#__PURE__*/dual(args => Predicate.isIterable(args[0]), (elements, f, options) => core.flatMap(partition(elements, f, {
   concurrency: options?.concurrency,
   batching: options?.batching
-}), ([es, bs]) => es.length === 0 ? options?.discard ? core.unit : core.succeed(bs) : core.fail(es)));
+}), ([es, bs]) => es.length === 0 ? options?.discard ? core.void : core.succeed(bs) : core.fail(es)));
 /* @internal */
 export const raceAll = all => {
   const list = Chunk.fromIterable(all);
@@ -1532,11 +1532,11 @@ export const raceAll = all => {
   const self = Chunk.headNonEmpty(list);
   const effects = Chunk.tailNonEmpty(list);
   const inheritAll = res => pipe(internalFiber.inheritAll(res[1]), core.as(res[0]));
-  return pipe(core.deferredMake(), core.flatMap(done => pipe(Ref.make(effects.length), core.flatMap(fails => core.uninterruptibleMask(restore => pipe(fork(core.interruptible(self)), core.flatMap(head => pipe(effects, core.forEachSequential(effect => fork(core.interruptible(effect))), core.map(fibers => Chunk.unsafeFromArray(fibers)), core.map(tail => pipe(tail, Chunk.prepend(head))), core.tap(fibers => pipe(fibers, RA.reduce(core.unit, (effect, fiber) => pipe(effect, core.zipRight(pipe(internalFiber._await(fiber), core.flatMap(raceAllArbiter(fibers, fiber, done, fails)), fork, core.asUnit)))))), core.flatMap(fibers => pipe(restore(pipe(Deferred.await(done), core.flatMap(inheritAll))), core.onInterrupt(() => pipe(fibers, RA.reduce(core.unit, (effect, fiber) => pipe(effect, core.zipLeft(core.interruptFiber(fiber))))))))))))))));
+  return pipe(core.deferredMake(), core.flatMap(done => pipe(Ref.make(effects.length), core.flatMap(fails => core.uninterruptibleMask(restore => pipe(fork(core.interruptible(self)), core.flatMap(head => pipe(effects, core.forEachSequential(effect => fork(core.interruptible(effect))), core.map(fibers => Chunk.unsafeFromArray(fibers)), core.map(tail => pipe(tail, Chunk.prepend(head))), core.tap(fibers => pipe(fibers, RA.reduce(core.void, (effect, fiber) => pipe(effect, core.zipRight(pipe(internalFiber._await(fiber), core.flatMap(raceAllArbiter(fibers, fiber, done, fails)), fork, core.asVoid)))))), core.flatMap(fibers => pipe(restore(pipe(Deferred.await(done), core.flatMap(inheritAll))), core.onInterrupt(() => pipe(fibers, RA.reduce(core.void, (effect, fiber) => pipe(effect, core.zipLeft(core.interruptFiber(fiber))))))))))))))));
 };
 const raceAllArbiter = (fibers, winner, deferred, fails) => exit => core.exitMatchEffect(exit, {
-  onFailure: cause => pipe(Ref.modify(fails, fails => [fails === 0 ? pipe(core.deferredFailCause(deferred, cause), core.asUnit) : core.unit, fails - 1]), core.flatten),
-  onSuccess: value => pipe(core.deferredSucceed(deferred, [value, winner]), core.flatMap(set => set ? pipe(Chunk.fromIterable(fibers), RA.reduce(core.unit, (effect, fiber) => fiber === winner ? effect : pipe(effect, core.zipLeft(core.interruptFiber(fiber))))) : core.unit))
+  onFailure: cause => pipe(Ref.modify(fails, fails => [fails === 0 ? pipe(core.deferredFailCause(deferred, cause), core.asVoid) : core.void, fails - 1]), core.flatten),
+  onSuccess: value => pipe(core.deferredSucceed(deferred, [value, winner]), core.flatMap(set => set ? pipe(Chunk.fromIterable(fibers), RA.reduce(core.void, (effect, fiber) => fiber === winner ? effect : pipe(effect, core.zipLeft(core.interruptFiber(fiber))))) : core.void))
 });
 /* @internal */
 export const reduceEffect = /*#__PURE__*/dual(args => Predicate.isIterable(args[0]), (elements, zero, f, options) => concurrency.matchSimple(options?.concurrency, () => RA.fromIterable(elements).reduce((acc, a, i) => core.zipWith(acc, a, (acc, a) => f(acc, a, i)), zero), () => core.suspend(() => pipe(mergeAll([zero, ...elements], Option.none(), (acc, elem, i) => {
@@ -1603,7 +1603,7 @@ export const finalizersMask = strategy => self => core.contextWithEffect(context
 /* @internal */
 export const scopeWith = f => core.flatMap(scopeTag, f);
 /* @internal */
-export const scopedEffect = effect => core.flatMap(scopeMake(), scope => scopeUse(scope)(effect));
+export const scopedEffect = effect => core.flatMap(scopeMake(), scope => scopeUse(effect, scope));
 /* @internal */
 export const sequentialFinalizers = self => core.contextWithEffect(context => Option.match(Context.getOption(context, scopeTag), {
   onNone: () => self,
@@ -1633,7 +1633,7 @@ export const validateWith = /*#__PURE__*/dual(args => core.isEffect(args[1]), (s
 /* @internal */
 export const validateAllPar = /*#__PURE__*/dual(2, (elements, f) => core.flatMap(partition(elements, f), ([es, bs]) => es.length === 0 ? core.succeed(bs) : core.fail(es)));
 /* @internal */
-export const validateAllParDiscard = /*#__PURE__*/dual(2, (elements, f) => core.flatMap(partition(elements, f), ([es, _]) => es.length === 0 ? core.unit : core.fail(es)));
+export const validateAllParDiscard = /*#__PURE__*/dual(2, (elements, f) => core.flatMap(partition(elements, f), ([es, _]) => es.length === 0 ? core.void : core.fail(es)));
 /* @internal */
 export const validateFirst = /*#__PURE__*/dual(args => Predicate.isIterable(args[0]), (elements, f, options) => core.flip(forEach(elements, (a, i) => core.flip(f(a, i)), options)));
 /* @internal */
@@ -1668,58 +1668,88 @@ export const zipWithOptions = /*#__PURE__*/dual(args => core.isEffect(args[1]),
 /* @internal */
 export const withRuntimeFlagsScoped = update => {
   if (update === RuntimeFlagsPatch.empty) {
-    return core.unit;
+    return core.void;
   }
   return pipe(core.runtimeFlags, core.flatMap(runtimeFlags => {
     const updatedRuntimeFlags = _runtimeFlags.patch(runtimeFlags, update);
     const revertRuntimeFlags = _runtimeFlags.diff(updatedRuntimeFlags, runtimeFlags);
-    return pipe(core.updateRuntimeFlags(update), core.zipRight(addFinalizer(() => core.updateRuntimeFlags(revertRuntimeFlags))), core.asUnit);
+    return pipe(core.updateRuntimeFlags(update), core.zipRight(addFinalizer(() => core.updateRuntimeFlags(revertRuntimeFlags))), core.asVoid);
   }), core.uninterruptible);
 };
-// circular with ReleaseMap
-/* @internal */
-export const releaseMapReleaseAll = (strategy, exit) => self => core.suspend(() => {
-  switch (self.state._tag) {
-    case "Exited":
-      {
-        return core.unit;
-      }
-    case "Running":
-      {
-        const finalizersMap = self.state.finalizers;
-        const update = self.state.update;
-        const finalizers = Array.from(finalizersMap.keys()).sort((a, b) => b - a).map(key => finalizersMap.get(key));
-        self.state = {
-          _tag: "Exited",
-          nextKey: self.state.nextKey,
-          exit,
-          update
-        };
-        return executionStrategy.isSequential(strategy) ? pipe(finalizers, core.forEachSequential(fin => core.exit(update(fin)(exit))), core.flatMap(results => pipe(core.exitCollectAll(results), Option.map(core.exitAsUnit), Option.getOrElse(() => core.exitUnit)))) : executionStrategy.isParallel(strategy) ? pipe(forEachParUnbounded(finalizers, fin => core.exit(update(fin)(exit)), false), core.flatMap(results => pipe(core.exitCollectAll(results, {
-          parallel: true
-        }), Option.map(core.exitAsUnit), Option.getOrElse(() => core.exitUnit)))) : pipe(forEachParN(finalizers, strategy.parallelism, fin => core.exit(update(fin)(exit)), false), core.flatMap(results => pipe(core.exitCollectAll(results, {
-          parallel: true
-        }), Option.map(core.exitAsUnit), Option.getOrElse(() => core.exitUnit))));
-      }
-  }
-});
 // circular with Scope
 /** @internal */
 export const scopeTag = /*#__PURE__*/Context.GenericTag("effect/Scope");
 /* @internal */
 export const scope = scopeTag;
-/* @internal */
-export const scopeMake = (strategy = executionStrategy.sequential) => core.map(core.releaseMapMake, rm => ({
+const scopeUnsafeAddFinalizer = (scope, fin) => {
+  if (scope.state._tag === "Open") {
+    scope.state.finalizers.add(fin);
+  }
+};
+const ScopeImplProto = {
   [core.ScopeTypeId]: core.ScopeTypeId,
   [core.CloseableScopeTypeId]: core.CloseableScopeTypeId,
-  strategy,
   pipe() {
     return pipeArguments(this, arguments);
   },
-  fork: strategy => core.uninterruptible(pipe(scopeMake(strategy), core.flatMap(scope => pipe(core.releaseMapAdd(rm, exit => core.scopeClose(scope, exit)), core.tap(fin => core.scopeAddFinalizerExit(scope, fin)), core.as(scope))))),
-  close: exit => core.asUnit(releaseMapReleaseAll(strategy, exit)(rm)),
-  addFinalizer: fin => core.asUnit(core.releaseMapAdd(fin)(rm))
-}));
+  fork(strategy) {
+    return core.sync(() => {
+      const newScope = scopeUnsafeMake(strategy);
+      if (this.state._tag === "Closed") {
+        newScope.state = this.state;
+        return newScope;
+      }
+      const fin = exit => newScope.close(exit);
+      this.state.finalizers.add(fin);
+      scopeUnsafeAddFinalizer(newScope, _ => core.sync(() => {
+        if (this.state._tag === "Open") {
+          this.state.finalizers.delete(fin);
+        }
+      }));
+      return newScope;
+    });
+  },
+  close(exit) {
+    return core.suspend(() => {
+      if (this.state._tag === "Closed") {
+        return core.void;
+      }
+      const finalizers = Array.from(this.state.finalizers.values()).reverse();
+      this.state = {
+        _tag: "Closed",
+        exit
+      };
+      if (finalizers.length === 0) {
+        return core.void;
+      }
+      return executionStrategy.isSequential(this.strategy) ? pipe(core.forEachSequential(finalizers, fin => core.exit(fin(exit))), core.flatMap(results => pipe(core.exitCollectAll(results), Option.map(core.exitAsVoid), Option.getOrElse(() => core.exitVoid)))) : executionStrategy.isParallel(this.strategy) ? pipe(forEachParUnbounded(finalizers, fin => core.exit(fin(exit)), false), core.flatMap(results => pipe(core.exitCollectAll(results, {
+        parallel: true
+      }), Option.map(core.exitAsVoid), Option.getOrElse(() => core.exitVoid)))) : pipe(forEachParN(finalizers, this.strategy.parallelism, fin => core.exit(fin(exit)), false), core.flatMap(results => pipe(core.exitCollectAll(results, {
+        parallel: true
+      }), Option.map(core.exitAsVoid), Option.getOrElse(() => core.exitVoid))));
+    });
+  },
+  addFinalizer(fin) {
+    return core.suspend(() => {
+      if (this.state._tag === "Closed") {
+        return fin(this.state.exit);
+      }
+      this.state.finalizers.add(fin);
+      return core.void;
+    });
+  }
+};
+const scopeUnsafeMake = (strategy = executionStrategy.sequential) => {
+  const scope = Object.create(ScopeImplProto);
+  scope.strategy = strategy;
+  scope.state = {
+    _tag: "Open",
+    finalizers: new Set()
+  };
+  return scope;
+};
+/* @internal */
+export const scopeMake = (strategy = executionStrategy.sequential) => core.sync(() => scopeUnsafeMake(strategy));
 /* @internal */
 export const scopeExtend = /*#__PURE__*/dual(2, (effect, scope) => core.mapInputContext(effect,
 // @ts-expect-error
@@ -1734,7 +1764,7 @@ export const fiberRefUnsafeMakeSupervisor = initial => core.fiberRefUnsafeMakePa
 });
 // circular with FiberRef
 /* @internal */
-export const fiberRefLocallyScoped = /*#__PURE__*/dual(2, (self, value) => core.asUnit(acquireRelease(core.flatMap(core.fiberRefGet(self), oldValue => core.as(core.fiberRefSet(self, value), oldValue)), oldValue => core.fiberRefSet(self, oldValue))));
+export const fiberRefLocallyScoped = /*#__PURE__*/dual(2, (self, value) => core.asVoid(acquireRelease(core.flatMap(core.fiberRefGet(self), oldValue => core.as(core.fiberRefSet(self, value), oldValue)), oldValue => core.fiberRefSet(self, oldValue))));
 /* @internal */
 export const fiberRefLocallyScopedWith = /*#__PURE__*/dual(2, (self, f) => core.fiberRefGetWith(self, a => fiberRefLocallyScoped(self, f(a))));
 /* @internal */
@@ -1751,7 +1781,7 @@ export const currentRuntimeFlags = /*#__PURE__*/core.fiberRefUnsafeMakeRuntimeFl
 export const currentSupervisor = /*#__PURE__*/fiberRefUnsafeMakeSupervisor(supervisor.none);
 // circular with Fiber
 /* @internal */
-export const fiberAwaitAll = fibers => core.asUnit(internalFiber._await(fiberAll(fibers)));
+export const fiberAwaitAll = fibers => core.asVoid(internalFiber._await(fiberAll(fibers)));
 /** @internal */
 export const fiberAll = fibers => ({
   [internalFiber.FiberTypeId]: internalFiber.fiberVariance,
@@ -1789,9 +1819,9 @@ export const fiberAll = fibers => ({
   }
 });
 /* @internal */
-export const fiberInterruptFork = self => core.asUnit(forkDaemon(core.interruptFiber(self)));
+export const fiberInterruptFork = self => core.asVoid(forkDaemon(core.interruptFiber(self)));
 /* @internal */
-export const fiberJoinAll = fibers => core.asUnit(internalFiber.join(fiberAll(fibers)));
+export const fiberJoinAll = fibers => internalFiber.join(fiberAll(fibers));
 /* @internal */
 export const fiberScoped = self => acquireRelease(core.succeed(self), core.interruptFiber);
 //
@@ -1905,7 +1935,18 @@ export const interruptWhenPossible = /*#__PURE__*/dual(2, (self, all) => core.fi
 })));
 // circular Tracer
 /** @internal */
-export const makeSpanScoped = (name, options) => acquireRelease(internalEffect.makeSpan(name, options), (span, exit) => span.status._tag === "Ended" ? core.unit : core.flatMap(internalEffect.currentTimeNanosTracing, endTime => core.sync(() => span.end(endTime, exit))));
+export const makeSpanScoped = (name, options) => core.uninterruptible(core.withFiberRuntime(fiber => {
+  const scope = Context.unsafeGet(fiber.getFiberRef(core.currentContext), scopeTag);
+  const span = internalEffect.unsafeMakeSpan(fiber, name, options);
+  const timingEnabled = fiber.getFiberRef(core.currentTracerTimingEnabled);
+  const clock_ = Context.get(fiber.getFiberRef(defaultServices.currentServices), clock.clockTag);
+  return core.as(core.scopeAddFinalizerExit(scope, exit => core.sync(() => {
+    if (span.status._tag === "Ended") {
+      return;
+    }
+    span.end(timingEnabled ? clock_.unsafeCurrentTimeNanos() : BigInt(0), exit);
+  })), span);
+}));
 /* @internal */
 export const withTracerScoped = value => fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(tracer.tracerTag, value));
 /** @internal */