effect 2.4.18 → 3.0.0

package/dist/esm/internal/core.js

@@ -1,3 +1,4 @@
+import * as Array from "../Array.js";
 import * as Chunk from "../Chunk.js";
 import * as Context from "../Context.js";
 import * as Either from "../Either.js";
@@ -13,13 +14,13 @@ import * as MutableRef from "../MutableRef.js";
 import * as Option from "../Option.js";
 import { pipeArguments } from "../Pipeable.js";
 import { hasProperty, isObject, isPromiseLike, isString } from "../Predicate.js";
-import * as ReadonlyArray from "../ReadonlyArray.js";
 import * as RuntimeFlagsPatch from "../RuntimeFlagsPatch.js";
 import * as _blockedRequests from "./blockedRequests.js";
 import * as internalCause from "./cause.js";
 import * as deferred from "./deferred.js";
 import * as internalDiffer from "./differ.js";
 import { effectVariance, StructuralCommitPrototype } from "./effectable.js";
+import { getBugErrorMessage } from "./errors.js";
 import * as DeferredOpCodes from "./opCodes/deferred.js";
 import * as OpCodes from "./opCodes/effect.js";
 import * as _runtimeFlags from "./runtimeFlags.js";
@@ -207,7 +208,7 @@ export const acquireUseRelease = /*#__PURE__*/dual(3, (acquire, use, release) =>
 /* @internal */
 export const as = /*#__PURE__*/dual(2, (self, value) => flatMap(self, () => succeed(value)));
 /* @internal */
-export const asUnit = self => as(self, void 0);
+export const asVoid = self => as(self, void 0);
 /* @internal */
 export const custom = function () {
   const wrapper = new EffectPrimitive(OpCodes.OP_COMMIT);
@@ -235,7 +236,7 @@ export const custom = function () {
       }
     default:
       {
-        throw new Error("Bug, you're not supposed to end up here");
+        throw new Error(getBugErrorMessage("you're not supposed to end up here"));
       }
   }
   return wrapper;
@@ -272,7 +273,7 @@ export const async = (register, blockingOn = FiberId.none) => {
       if (controllerRef) {
         controllerRef.abort();
       }
-      return cancelerRef ?? unit;
+      return cancelerRef ?? void_;
     }) : effect;
   });
 };
@@ -435,8 +436,8 @@ export const matchEffect = /*#__PURE__*/dual(2, (self, options) => matchCauseEff
 }));
 /* @internal */
 export const forEachSequential = /*#__PURE__*/dual(2, (self, f) => suspend(() => {
-  const arr = ReadonlyArray.fromIterable(self);
-  const ret = new Array(arr.length);
+  const arr = Array.fromIterable(self);
+  const ret = Array.allocate(arr.length);
   let i = 0;
   return as(whileLoop({
     while: () => i < arr.length,
@@ -448,7 +449,7 @@ export const forEachSequential = /*#__PURE__*/dual(2, (self, f) => suspend(() =>
 }));
 /* @internal */
 export const forEachSequentialDiscard = /*#__PURE__*/dual(2, (self, f) => suspend(() => {
-  const arr = ReadonlyArray.fromIterable(self);
+  const arr = Array.fromIterable(self);
   let i = 0;
   return whileLoop({
     while: () => i < arr.length,
@@ -459,10 +460,7 @@ export const forEachSequentialDiscard = /*#__PURE__*/dual(2, (self, f) => suspen
   });
 }));
 /* @internal */
-export const if_ = /*#__PURE__*/dual(args => typeof args[0] === "boolean" || isEffect(args[0]), (self, {
-  onFalse,
-  onTrue
-}) => isEffect(self) ? flatMap(self, b => b ? onTrue : onFalse) : Boolean(self) ? onTrue : onFalse);
+export const if_ = /*#__PURE__*/dual(args => typeof args[0] === "boolean" || isEffect(args[0]), (self, options) => isEffect(self) ? flatMap(self, b => b ? options.onTrue() : options.onFalse()) : self ? options.onTrue() : options.onFalse());
 /* @internal */
 export const interrupt = /*#__PURE__*/flatMap(fiberId, fiberId => interruptWith(fiberId));
 /* @internal */
@@ -508,7 +506,7 @@ export const mapError = /*#__PURE__*/dual(2, (self, f) => matchCauseEffect(self,
   onSuccess: succeed
 }));
 /* @internal */
-export const onError = /*#__PURE__*/dual(2, (self, cleanup) => onExit(self, exit => exitIsSuccess(exit) ? unit : cleanup(exit.effect_instruction_i0)));
+export const onError = /*#__PURE__*/dual(2, (self, cleanup) => onExit(self, exit => exitIsSuccess(exit) ? void_ : cleanup(exit.effect_instruction_i0)));
 /* @internal */
 export const onExit = /*#__PURE__*/dual(2, (self, cleanup) => uninterruptibleMask(restore => matchCauseEffect(restore(self), {
   onFailure: cause1 => {
@@ -525,8 +523,8 @@ export const onExit = /*#__PURE__*/dual(2, (self, cleanup) => uninterruptibleMas
 })));
 /* @internal */
 export const onInterrupt = /*#__PURE__*/dual(2, (self, cleanup) => onExit(self, exitMatch({
-  onFailure: cause => internalCause.isInterruptedOnly(cause) ? asUnit(cleanup(internalCause.interruptors(cause))) : unit,
-  onSuccess: () => unit
+  onFailure: cause => internalCause.isInterruptedOnly(cause) ? asVoid(cleanup(internalCause.interruptors(cause))) : void_,
+  onSuccess: () => void_
 })));
 /* @internal */
 export const orElse = /*#__PURE__*/dual(2, (self, that) => attemptOrElse(self, that, succeed));
@@ -538,7 +536,7 @@ export const orDieWith = /*#__PURE__*/dual(2, (self, f) => matchEffect(self, {
   onSuccess: succeed
 }));
 /* @internal */
-export const partitionMap = (elements, f) => ReadonlyArray.fromIterable(elements).reduceRight(([lefts, rights], current) => {
+export const partitionMap = (elements, f) => Array.fromIterable(elements).reduceRight(([lefts, rights], current) => {
   const either = f(current);
   switch (either._tag) {
     case "Left":
@@ -550,7 +548,7 @@ export const partitionMap = (elements, f) => ReadonlyArray.fromIterable(elements
         return [lefts, [either.right, ...rights]];
       }
   }
-}, [new Array(), new Array()]);
+}, [Array.empty(), Array.empty()]);
 /* @internal */
 export const runtimeFlags = /*#__PURE__*/withFiberRuntime((_, status) => succeed(status.runtimeFlags));
 /* @internal */
@@ -610,8 +608,9 @@ export const uninterruptibleMask = f => custom(f, function () {
   effect.effect_instruction_i1 = oldFlags => _runtimeFlags.interruption(oldFlags) ? this.effect_instruction_i0(interruptible) : this.effect_instruction_i0(uninterruptible);
   return effect;
 });
-/* @internal */
-export const unit = /*#__PURE__*/succeed(void 0);
+const void_ = /*#__PURE__*/succeed(void 0);
+export { /* @internal */
+void_ as void };
 /* @internal */
 export const updateRuntimeFlags = patch => {
   const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS);
@@ -789,7 +788,7 @@ export const fiberRefSet = /*#__PURE__*/dual(2, (self, value) => fiberRefModify(
 /* @internal */
 export const fiberRefDelete = self => withFiberRuntime(state => {
   state.unsafeDeleteFiberRef(self);
-  return unit;
+  return void_;
 });
 /* @internal */
 export const fiberRefReset = self => fiberRefSet(self, self.initial);
@@ -941,7 +940,7 @@ export const currentUnhandledErrorLogLevel = /*#__PURE__*/globalValue( /*#__PURE
 /** @internal */
 export const withUnhandledErrorLogLevel = /*#__PURE__*/dual(2, (self, level) => fiberRefLocally(self, currentUnhandledErrorLogLevel, level));
 /** @internal */
-export const currentMetricLabels = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentMetricLabels"), () => fiberRefUnsafeMakeReadonlyArray(ReadonlyArray.empty()));
+export const currentMetricLabels = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentMetricLabels"), () => fiberRefUnsafeMakeReadonlyArray(Array.empty()));
 /* @internal */
 export const metricLabels = /*#__PURE__*/fiberRefGet(currentMetricLabels);
 /** @internal */
@@ -970,88 +969,13 @@ export const ScopeTypeId = /*#__PURE__*/Symbol.for("effect/Scope");
 /** @internal */
 export const CloseableScopeTypeId = /*#__PURE__*/Symbol.for("effect/CloseableScope");
 /* @internal */
-export const scopeAddFinalizer = (self, finalizer) => self.addFinalizer(() => asUnit(finalizer));
+export const scopeAddFinalizer = (self, finalizer) => self.addFinalizer(() => asVoid(finalizer));
 /* @internal */
 export const scopeAddFinalizerExit = (self, finalizer) => self.addFinalizer(finalizer);
 /* @internal */
 export const scopeClose = (self, exit) => self.close(exit);
 /* @internal */
 export const scopeFork = (self, strategy) => self.fork(strategy);
-/* @internal */
-export const releaseMapAdd = /*#__PURE__*/dual(2, (self, finalizer) => map(releaseMapAddIfOpen(self, finalizer), Option.match({
-  onNone: () => () => unit,
-  onSome: key => exit => releaseMapRelease(key, exit)(self)
-})));
-/* @internal */
-export const releaseMapRelease = /*#__PURE__*/dual(3, (self, key, exit) => suspend(() => {
-  switch (self.state._tag) {
-    case "Exited":
-      {
-        return unit;
-      }
-    case "Running":
-      {
-        const finalizer = self.state.finalizers.get(key);
-        self.state.finalizers.delete(key);
-        if (finalizer != null) {
-          return self.state.update(finalizer)(exit);
-        }
-        return unit;
-      }
-  }
-}));
-/* @internal */
-export const releaseMapAddIfOpen = /*#__PURE__*/dual(2, (self, finalizer) => suspend(() => {
-  switch (self.state._tag) {
-    case "Exited":
-      {
-        self.state.nextKey += 1;
-        return as(finalizer(self.state.exit), Option.none());
-      }
-    case "Running":
-      {
-        const key = self.state.nextKey;
-        self.state.finalizers.set(key, finalizer);
-        self.state.nextKey += 1;
-        return succeed(Option.some(key));
-      }
-  }
-}));
-/* @internal */
-export const releaseMapGet = /*#__PURE__*/dual(2, (self, key) => sync(() => self.state._tag === "Running" ? Option.fromNullable(self.state.finalizers.get(key)) : Option.none()));
-/* @internal */
-export const releaseMapReplace = /*#__PURE__*/dual(3, (self, key, finalizer) => suspend(() => {
-  switch (self.state._tag) {
-    case "Exited":
-      {
-        return as(finalizer(self.state.exit), Option.none());
-      }
-    case "Running":
-      {
-        const fin = Option.fromNullable(self.state.finalizers.get(key));
-        self.state.finalizers.set(key, finalizer);
-        return succeed(fin);
-      }
-  }
-}));
-/* @internal */
-export const releaseMapRemove = /*#__PURE__*/dual(2, (self, key) => sync(() => {
-  if (self.state._tag === "Exited") {
-    return Option.none();
-  }
-  const fin = Option.fromNullable(self.state.finalizers.get(key));
-  self.state.finalizers.delete(key);
-  return fin;
-}));
-/* @internal */
-export const releaseMapMake = /*#__PURE__*/sync(() => ({
-  state: {
-    _tag: "Running",
-    nextKey: 0,
-    finalizers: new Map(),
-    update: identity
-  }
-}));
 // -----------------------------------------------------------------------------
 // Cause
 // -----------------------------------------------------------------------------
@@ -1067,7 +991,7 @@ export const causeSquashWith = /*#__PURE__*/dual(2, (self, f) => {
       {
         return pipe(internalCause.defects(self), Chunk.head, Option.match({
           onNone: () => {
-            const interrupts = Array.from(internalCause.interruptors(self)).flatMap(fiberId => Array.from(FiberId.ids(fiberId)).map(id => `#${id}`));
+            const interrupts = Array.fromIterable(internalCause.interruptors(self)).flatMap(fiberId => Array.fromIterable(FiberId.ids(fiberId)).map(id => `#${id}`));
             return new InterruptedException(interrupts ? `Interrupted by fibers: ${interrupts.join(", ")}` : void 0);
           },
           onSome: identity
@@ -1215,7 +1139,7 @@ export const exitAs = /*#__PURE__*/dual(2, (self, value) => {
   }
 });
 /** @internal */
-export const exitAsUnit = self => exitAs(self, void 0);
+export const exitAsVoid = self => exitAs(self, void 0);
 /** @internal */
 export const exitCauseOption = self => {
   switch (self._tag) {
@@ -1386,7 +1310,7 @@ export const exitSucceed = value => {
   return effect;
 };
 /** @internal */
-export const exitUnit = /*#__PURE__*/exitSucceed(void 0);
+export const exitVoid = /*#__PURE__*/exitSucceed(void 0);
 /** @internal */
 export const exitZip = /*#__PURE__*/dual(2, (self, that) => exitZipWith(self, that, {
   onSuccess: (a, a2) => [a, a2],
@@ -1450,10 +1374,10 @@ const exitCollectAllInternal = (exits, combineCauses) => {
   if (!Chunk.isNonEmpty(list)) {
     return Option.none();
   }
-  return pipe(Chunk.tailNonEmpty(list), ReadonlyArray.reduce(pipe(Chunk.headNonEmpty(list), exitMap(Chunk.of)), (accumulator, current) => pipe(accumulator, exitZipWith(current, {
+  return pipe(Chunk.tailNonEmpty(list), Array.reduce(pipe(Chunk.headNonEmpty(list), exitMap(Chunk.of)), (accumulator, current) => pipe(accumulator, exitZipWith(current, {
     onSuccess: (list, value) => pipe(list, Chunk.prepend(value)),
     onFailure: combineCauses
-  }))), exitMap(Chunk.reverse), exitMap(chunk => Array.from(chunk)), Option.some);
+  }))), exitMap(Chunk.reverse), exitMap(chunk => Chunk.toReadonlyArray(chunk)), Option.some);
 };
 // -----------------------------------------------------------------------------
 // Deferred
@@ -1481,7 +1405,8 @@ export const deferredAwait = self => async(resume => {
       }
     case DeferredOpCodes.OP_STATE_PENDING:
       {
-        pipe(self.state, MutableRef.set(deferred.pending([resume, ...state.joiners])));
+        // we can push here as the internal state is mutable
+        state.joiners.push(resume);
         return deferredInterruptJoiner(self, resume);
       }
   }
@@ -1498,8 +1423,8 @@ export const deferredCompleteWith = /*#__PURE__*/dual(2, (self, effect) => sync(
       }
     case DeferredOpCodes.OP_STATE_PENDING:
       {
-        pipe(self.state, MutableRef.set(deferred.done(effect)));
-        for (let i = 0; i < state.joiners.length; i++) {
+        MutableRef.set(self.state, deferred.done(effect));
+        for (let i = 0, len = state.joiners.length; i < len; i++) {
           state.joiners[i](effect);
         }
         return true;
@@ -1548,8 +1473,8 @@ export const deferredSync = /*#__PURE__*/dual(2, (self, evaluate) => deferredCom
 export const deferredUnsafeDone = (self, effect) => {
   const state = MutableRef.get(self.state);
   if (state._tag === DeferredOpCodes.OP_STATE_PENDING) {
-    pipe(self.state, MutableRef.set(deferred.done(effect)));
-    for (let i = state.joiners.length - 1; i >= 0; i--) {
+    MutableRef.set(self.state, deferred.done(effect));
+    for (let i = 0, len = state.joiners.length; i < len; i++) {
       state.joiners[i](effect);
     }
   }
@@ -1557,7 +1482,11 @@ export const deferredUnsafeDone = (self, effect) => {
 const deferredInterruptJoiner = (self, joiner) => sync(() => {
   const state = MutableRef.get(self.state);
   if (state._tag === DeferredOpCodes.OP_STATE_PENDING) {
-    pipe(self.state, MutableRef.set(deferred.pending(state.joiners.filter(j => j !== joiner))));
+    const index = state.joiners.indexOf(joiner);
+    if (index >= 0) {
+      // we can splice here as the internal state is mutable
+      state.joiners.splice(index, 1);
+    }
   }
 });
 // -----------------------------------------------------------------------------
@@ -1596,7 +1525,7 @@ const NoopSpanProto = {
     _tag: "Ended",
     startTime: /*#__PURE__*/BigInt(0),
     endTime: /*#__PURE__*/BigInt(0),
-    exit: exitUnit
+    exit: exitVoid
   },
   attributes: /*#__PURE__*/new Map(),
   links: [],