effect 2.0.0-next.55 → 2.0.0-next.57

package/dist/esm/internal/core.js

@@ -8,19 +8,19 @@ import { globalValue } from "../GlobalValue.js";
 import * as Hash from "../Hash.js";
 import * as HashMap from "../HashMap.js";
 import * as HashSet from "../HashSet.js";
-import { NodeInspectSymbol, toJSON, toString } from "../Inspectable.js";
+import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js";
 import * as List from "../List.js";
 import * as MutableRef from "../MutableRef.js";
 import * as Option from "../Option.js";
 import { pipeArguments } from "../Pipeable.js";
-import { hasProperty, isObject } from "../Predicate.js";
+import { hasProperty, isObject, isPromise, 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 } from "./effectable.js";
+import { effectVariance, StructuralCommitPrototype } from "./effectable.js";
 import * as DeferredOpCodes from "./opCodes/deferred.js";
 import * as OpCodes from "./opCodes/effect.js";
 import * as _runtimeFlags from "./runtimeFlags.js";
@@ -99,7 +99,7 @@ class EffectPrimitive {
     };
   }
   toString() {
-    return toString(this.toJSON());
+    return format(this.toJSON());
   }
   [NodeInspectSymbol]() {
     return this.toJSON();
@@ -138,7 +138,7 @@ class EffectPrimitiveFailure {
     };
   }
   toString() {
-    return toString(this.toJSON());
+    return format(this.toJSON());
   }
   [NodeInspectSymbol]() {
     return this.toJSON();
@@ -177,7 +177,7 @@ class EffectPrimitiveSuccess {
     };
   }
   toString() {
-    return toString(this.toJSON());
+    return format(this.toJSON());
   }
   [NodeInspectSymbol]() {
     return this.toJSON();
@@ -192,18 +192,13 @@ export const withFiberRuntime = withRuntime => {
   return effect;
 };
 /* @internal */
-export const acquireUseRelease = /*#__PURE__*/dual(3, (acquire, use, release) => uninterruptibleMask(restore => flatMap(acquire, a => flatMap(exit(suspend(() => restore(step(use(a))))), exit => {
-  if (exit._tag === "Success" && exit.value._op === "Blocked") {
-    const value = exit.value;
-    return blocked(value.i0, acquireUseRelease(succeed(a), () => value.i1, release));
-  }
-  const flat = exitFlatten(exit);
-  return suspend(() => release(a, flat)).pipe(matchCauseEffect({
+export const acquireUseRelease = /*#__PURE__*/dual(3, (acquire, use, release) => uninterruptibleMask(restore => flatMap(acquire, a => flatMap(exit(suspend(() => restore(use(a)))), exit => {
+  return suspend(() => release(a, exit)).pipe(matchCauseEffect({
     onFailure: cause => {
-      switch (flat._tag) {
+      switch (exit._tag) {
         case OpCodes.OP_FAILURE:
           {
-            return failCause(internalCause.parallel(flat.i0, cause));
+            return failCause(internalCause.parallel(exit.i0, cause));
           }
         case OpCodes.OP_SUCCESS:
           {
@@ -211,7 +206,7 @@ export const acquireUseRelease = /*#__PURE__*/dual(3, (acquire, use, release) =>
           }
       }
     },
-    onSuccess: () => flat
+    onSuccess: () => exit
   }));
 }))));
 /* @internal */
@@ -220,28 +215,37 @@ export const as = /*#__PURE__*/dual(2, (self, value) => flatMap(self, () => succ
 export const asUnit = self => as(self, void 0);
 /* @internal */
 export const async = (register, blockingOn = FiberId.none) => suspend(() => {
+  let backingResume = undefined;
+  let pendingEffect = undefined;
+  function proxyResume(effect) {
+    if (backingResume) {
+      backingResume(effect);
+    } else if (pendingEffect === undefined) {
+      pendingEffect = effect;
+    }
+  }
+  const effect = new EffectPrimitive(OpCodes.OP_ASYNC);
+  effect.i0 = resume => {
+    backingResume = resume;
+    if (pendingEffect) {
+      resume(pendingEffect);
+    }
+  };
+  effect.i1 = blockingOn;
   let cancelerRef = undefined;
   let controllerRef = undefined;
-  const effect = new EffectPrimitive(OpCodes.OP_ASYNC);
   if (register.length !== 1) {
-    const controller = new AbortController();
-    controllerRef = controller;
-    effect.i0 = resume => {
-      cancelerRef = register(resume, controller.signal);
-    };
+    controllerRef = new AbortController();
+    cancelerRef = register(proxyResume, controllerRef.signal);
   } else {
-    effect.i0 = resume => {
-      // @ts-expect-error
-      cancelerRef = register(resume);
-    };
+    cancelerRef = register(proxyResume);
   }
-  effect.i1 = blockingOn;
-  return onInterrupt(effect, () => {
+  return cancelerRef || controllerRef ? onInterrupt(effect, _ => {
     if (controllerRef) {
       controllerRef.abort();
     }
     return cancelerRef ?? unit;
-  });
+  }) : effect;
 });
 /* @internal */
 export const asyncEither = (register, blockingOn = FiberId.none) => async(resume => {
@@ -333,7 +337,7 @@ const capture = (obj, span) => {
 /* @internal */
 export const die = defect => isObject(defect) && !(spanSymbol in defect) ? withFiberRuntime(fiber => failCause(internalCause.die(capture(defect, currentSpanFromFiber(fiber))))) : failCause(internalCause.die(defect));
 /* @internal */
-export const dieMessage = message => failCauseSync(() => internalCause.die(internalCause.RuntimeException(message)));
+export const dieMessage = message => failCauseSync(() => internalCause.die(new RuntimeException(message)));
 /* @internal */
 export const dieSync = evaluate => flatMap(sync(evaluate), die);
 /* @internal */
@@ -370,17 +374,21 @@ export const flatMap = /*#__PURE__*/dual(2, (self, f) => {
   return effect;
 });
 /* @internal */
-export const step = self => {
-  const effect = new EffectPrimitive("OnStep");
-  effect.i0 = self;
-  effect.i1 = exitSucceed;
-  return effect;
-};
+export const andThen = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a => {
+  const b = typeof f === "function" ? f(a) : f;
+  if (isEffect(b)) {
+    return b;
+  } else if (isPromise(b)) {
+    return async(resume => {
+      b.then(a => resume(succeed(a))).catch(e => resume(fail(new UnknownException(e))));
+    });
+  }
+  return succeed(b);
+}));
 /* @internal */
-export const flatMapStep = (self, f) => {
+export const step = self => {
   const effect = new EffectPrimitive("OnStep");
   effect.i0 = self;
-  effect.i1 = f;
   return effect;
 };
 /* @internal */
@@ -465,28 +473,15 @@ export const interruptWith = fiberId => failCause(internalCause.interrupt(fiberI
 export const interruptible = self => {
   const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS);
   effect.i0 = RuntimeFlagsPatch.enable(_runtimeFlags.Interruption);
-  const _continue = orBlock => {
-    if (orBlock._tag === "Blocked") {
-      return blocked(orBlock.i0, interruptible(orBlock.i1));
-    } else {
-      return orBlock;
-    }
-  };
-  effect.i1 = () => flatMapStep(self, _continue);
+  effect.i1 = () => self;
   return effect;
 };
 /* @internal */
 export const interruptibleMask = f => {
   const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS);
   effect.i0 = RuntimeFlagsPatch.enable(_runtimeFlags.Interruption);
-  const _continue = step => {
-    if (step._op === "Blocked") {
-      return blocked(step.i0, interruptible(step.i1));
-    }
-    return step;
-  };
-  effect.i1 = oldFlags => _runtimeFlags.interruption(oldFlags) ? step(f(interruptible)) : step(f(uninterruptible));
-  return flatMap(effect, _continue);
+  effect.i1 = oldFlags => _runtimeFlags.interruption(oldFlags) ? f(interruptible) : f(uninterruptible);
+  return effect;
 };
 /* @internal */
 export const intoDeferred = /*#__PURE__*/dual(2, (self, deferred) => uninterruptibleMask(restore => flatMap(exit(restore(self)), exit => deferredDone(deferred, exit))));
@@ -578,7 +573,17 @@ export const sync = evaluate => {
   return effect;
 };
 /* @internal */
-export const tap = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a => as(f(a), a)));
+export const tap = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a => {
+  const b = typeof f === "function" ? f(a) : f;
+  if (isEffect(b)) {
+    return as(b, a);
+  } else if (isPromise(b)) {
+    return async(resume => {
+      b.then(_ => resume(succeed(a))).catch(e => resume(fail(new UnknownException(e))));
+    });
+  }
+  return succeed(a);
+}));
 /* @internal */
 export const transplant = f => withFiberRuntime(state => {
   const scopeOverride = state.getFiberRef(currentForkScopeOverride);
@@ -600,28 +605,15 @@ export const attemptOrElse = /*#__PURE__*/dual(3, (self, that, onSuccess) => mat
 export const uninterruptible = self => {
   const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS);
   effect.i0 = RuntimeFlagsPatch.disable(_runtimeFlags.Interruption);
-  effect.i1 = () => flatMapStep(self, _continue);
-  const _continue = orBlock => {
-    if (orBlock._tag === "Blocked") {
-      return blocked(orBlock.i0, uninterruptible(orBlock.i1));
-    } else {
-      return orBlock;
-    }
-  };
+  effect.i1 = () => self;
   return effect;
 };
 /* @internal */
 export const uninterruptibleMask = f => {
   const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS);
   effect.i0 = RuntimeFlagsPatch.disable(_runtimeFlags.Interruption);
-  const _continue = step => {
-    if (step._op === "Blocked") {
-      return blocked(step.i0, uninterruptible(step.i1));
-    }
-    return step;
-  };
-  effect.i1 = oldFlags => _runtimeFlags.interruption(oldFlags) ? step(f(interruptible)) : step(f(uninterruptible));
-  return flatMap(effect, _continue);
+  effect.i1 = oldFlags => _runtimeFlags.interruption(oldFlags) ? f(interruptible) : f(uninterruptible);
+  return effect;
 };
 /* @internal */
 export const unit = /*#__PURE__*/succeed(void 0);
@@ -781,8 +773,8 @@ export const allLogLevels = [logLevelAll, logLevelTrace, logLevelDebug, logLevel
 const FiberRefSymbolKey = "effect/FiberRef";
 /** @internal */
 export const FiberRefTypeId = /*#__PURE__*/Symbol.for(FiberRefSymbolKey);
-/** @internal */
 const fiberRefVariance = {
+  /* c8 ignore next */
   _A: _ => _
 };
 /* @internal */
@@ -831,15 +823,17 @@ export const fiberRefUpdateSomeAndGet = /*#__PURE__*/dual(2, (self, pf) => fiber
 const RequestResolverSymbolKey = "effect/RequestResolver";
 /** @internal */
 export const RequestResolverTypeId = /*#__PURE__*/Symbol.for(RequestResolverSymbolKey);
-const dataSourceVariance = {
-  _R: _ => _,
-  _A: _ => _
+const requestResolverVariance = {
+  /* c8 ignore next */
+  _A: _ => _,
+  /* c8 ignore next */
+  _R: _ => _
 };
 /** @internal */
 export class RequestResolverImpl {
   runAll;
   target;
-  [RequestResolverTypeId] = dataSourceVariance;
+  [RequestResolverTypeId] = requestResolverVariance;
   constructor(runAll, target) {
     this.runAll = runAll;
     this.target = target;
@@ -872,12 +866,7 @@ const LocallyReducer = (ref, value) => ({
   singleCase: (dataSource, blockedRequest) => _blockedRequests.single(resolverLocally(dataSource, ref, value), blockedRequest)
 });
 /* @internal */
-export const fiberRefLocally = /*#__PURE__*/dual(3, (use, self, value) => flatMap(acquireUseRelease(zipLeft(fiberRefGet(self), fiberRefSet(self, value)), () => step(use), oldValue => fiberRefSet(self, oldValue)), res => {
-  if (res._op === "Blocked") {
-    return blocked(res.i0, fiberRefLocally(res.i1, self, value));
-  }
-  return res;
-}));
+export const fiberRefLocally = /*#__PURE__*/dual(3, (use, self, value) => acquireUseRelease(zipLeft(fiberRefGet(self), fiberRefSet(self, value)), () => use, oldValue => fiberRefSet(self, oldValue)));
 /* @internal */
 export const fiberRefLocallyWith = /*#__PURE__*/dual(3, (use, self, f) => fiberRefGetWith(self, a => fiberRefLocally(use, self, f(a))));
 /** @internal */
@@ -1057,6 +1046,129 @@ export const releaseMapMake = /*#__PURE__*/sync(() => ({
   }
 }));
 // -----------------------------------------------------------------------------
+// Cause
+// -----------------------------------------------------------------------------
+/** @internal */
+export const causeSquash = self => {
+  return causeSquashWith(identity)(self);
+};
+/** @internal */
+export const causeSquashWith = /*#__PURE__*/dual(2, (self, f) => {
+  const option = pipe(self, internalCause.failureOption, Option.map(f));
+  switch (option._tag) {
+    case "None":
+      {
+        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}`));
+            return new InterruptedException(interrupts ? `Interrupted by fibers: ${interrupts.join(", ")}` : void 0);
+          },
+          onSome: identity
+        }));
+      }
+    case "Some":
+      {
+        return option.value;
+      }
+  }
+});
+// -----------------------------------------------------------------------------
+// Errors
+// -----------------------------------------------------------------------------
+/** @internal */
+export const YieldableError = /*#__PURE__*/function () {
+  class YieldableError extends globalThis.Error {
+    commit() {
+      return fail(this);
+    }
+    toString() {
+      return this.message ? `${this.name}: ${this.message}` : this.name;
+    }
+    toJSON() {
+      return {
+        ...this
+      };
+    }
+    [NodeInspectSymbol]() {
+      const stack = this.stack;
+      if (stack) {
+        return `${this.toString()}\n${stack.split("\n").slice(1).join("\n")}`;
+      }
+      return this.toString();
+    }
+  }
+  Object.assign(YieldableError.prototype, StructuralCommitPrototype);
+  return YieldableError;
+}();
+const makeException = (proto, tag) => {
+  class Base extends YieldableError {
+    _tag = tag;
+  }
+  Object.assign(Base.prototype, proto);
+  Base.prototype.name = tag;
+  return Base;
+};
+/** @internal */
+export const RuntimeExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/RuntimeException");
+/** @internal */
+export const RuntimeException = /*#__PURE__*/makeException({
+  [RuntimeExceptionTypeId]: RuntimeExceptionTypeId
+}, "RuntimeException");
+/** @internal */
+export const isRuntimeException = u => hasProperty(u, RuntimeExceptionTypeId);
+/** @internal */
+export const InterruptedExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/InterruptedException");
+/** @internal */
+export const InterruptedException = /*#__PURE__*/makeException({
+  [InterruptedExceptionTypeId]: InterruptedExceptionTypeId
+}, "InterruptedException");
+/** @internal */
+export const isInterruptedException = u => hasProperty(u, InterruptedExceptionTypeId);
+/** @internal */
+export const IllegalArgumentExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/IllegalArgument");
+/** @internal */
+export const IllegalArgumentException = /*#__PURE__*/makeException({
+  [IllegalArgumentExceptionTypeId]: IllegalArgumentExceptionTypeId
+}, "IllegalArgumentException");
+/** @internal */
+export const isIllegalArgumentException = u => hasProperty(u, IllegalArgumentExceptionTypeId);
+/** @internal */
+export const NoSuchElementExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/NoSuchElement");
+/** @internal */
+export const NoSuchElementException = /*#__PURE__*/makeException({
+  [NoSuchElementExceptionTypeId]: NoSuchElementExceptionTypeId
+}, "NoSuchElementException");
+/** @internal */
+export const isNoSuchElementException = u => hasProperty(u, NoSuchElementExceptionTypeId);
+/** @internal */
+export const InvalidPubSubCapacityExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/InvalidPubSubCapacityException");
+/** @internal */
+export const InvalidPubSubCapacityException = /*#__PURE__*/makeException({
+  [InvalidPubSubCapacityExceptionTypeId]: InvalidPubSubCapacityExceptionTypeId
+}, "InvalidPubSubCapacityException");
+/** @internal */
+export const isInvalidCapacityError = u => hasProperty(u, InvalidPubSubCapacityExceptionTypeId);
+/** @internal */
+export const UnknownExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/UnknownException");
+/** @internal */
+export const UnknownException = /*#__PURE__*/function () {
+  class UnknownException extends YieldableError {
+    error;
+    _tag = "UnknownException";
+    constructor(error, message) {
+      super(message ?? (hasProperty(error, "message") && isString(error.message) ? error.message : void 0));
+      this.error = error;
+    }
+  }
+  Object.assign(UnknownException.prototype, {
+    [UnknownExceptionTypeId]: UnknownExceptionTypeId,
+    name: "UnknownException"
+  });
+  return UnknownException;
+}();
+/** @internal */
+export const isUnknownException = u => hasProperty(u, UnknownExceptionTypeId);
+// -----------------------------------------------------------------------------
 // Exit
 // -----------------------------------------------------------------------------
 /** @internal */
@@ -1111,7 +1223,7 @@ export const exitCollectAll = (exits, options) => exitCollectAllInternal(exits,
 /** @internal */
 export const exitDie = defect => exitFailCause(internalCause.die(defect));
 /** @internal */
-export const exitExists = /*#__PURE__*/dual(2, (self, predicate) => {
+export const exitExists = /*#__PURE__*/dual(2, (self, refinement) => {
   switch (self._tag) {
     case OpCodes.OP_FAILURE:
       {
@@ -1119,7 +1231,7 @@ export const exitExists = /*#__PURE__*/dual(2, (self, predicate) => {
       }
     case OpCodes.OP_SUCCESS:
       {
-        return predicate(self.i0);
+        return refinement(self.i0);
       }
   }
 });