effect 4.0.0-beta.83 → 4.0.0-beta.85

package/dist/Types.d.ts

@@ -27,7 +27,7 @@ type TupleOf_<T, N extends number, R extends Array<unknown>> = `${N}` extends `-
  * - If `N` is the general `number` type (non-literal), degrades to `Array<T>`.
  * - Negative numbers produce `never`.
  *
- * **Example** (Fixed-length tuple)
+ * **Example** (Checking fixed-length tuples)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -61,7 +61,7 @@ export type TupleOf<N extends number, T> = N extends N ? number extends N ? Arra
  *
  * Produces a tuple with `N` fixed positions followed by `...Array<T>`.
  *
- * **Example** (Minimum-length tuple)
+ * **Example** (Checking minimum-length tuples)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -198,7 +198,7 @@ export type ExtractTag<E, K extends string> = E extends {
  * - If the union members are incompatible (e.g. `string | number`), the
  *   result is `never`.
  *
- * **Example** (Union to intersection)
+ * **Example** (Converting a union to an intersection)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -258,7 +258,7 @@ export type Simplify<A> = {
  *   distinguishing between `any`, `unknown`, `never`, and other types.
  * - Resolves to `true` if `X` and `Y` are identical, `false` otherwise.
  *
- * **Example** (Type equality check)
+ * **Example** (Checking type equality)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -285,7 +285,7 @@ export type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T ext
  *
  * Returns `Y` when `A` and `B` are equal, `N` otherwise.
  *
- * **Example** (Conditional type based on equality)
+ * **Example** (Choosing a conditional type based on equality)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -313,7 +313,7 @@ export type EqualsWith<A, B, Y, N> = (<T>() => T extends A ? 1 : 2) extends (<T>
  * Returns `true` if at least one key from `Key` exists in `A`, `false`
  * otherwise.
  *
- * **Example** (Key presence check)
+ * **Example** (Checking key presence)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -338,7 +338,7 @@ export type Has<A, Key extends string> = (Key extends infer K ? K extends keyof
  *
  * Implemented as `MergeRight<Target, Source>`.
  *
- * **Example** (Left-biased merge)
+ * **Example** (Merging with left bias)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -404,7 +404,7 @@ export type MergeRight<Target, Source> = Simplify<Source & {
  * - `"unbounded"` — run all effects concurrently with no limit.
  * - `"inherit"` — inherit the concurrency from the surrounding context.
  *
- * **Example** (Concurrency values)
+ * **Example** (Setting concurrency values)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -431,7 +431,7 @@ export type Concurrency = number | "unbounded" | "inherit";
  *
  * Only affects the top level; nested properties remain readonly.
  *
- * **Example** (Shallow mutable conversion)
+ * **Example** (Converting shallowly to mutable types)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -471,7 +471,7 @@ export type Mutable<T> = {
  * Recursion stops at primitives (`string`, `number`, `boolean`, `bigint`,
  * `symbol`) and functions.
  *
- * **Example** (Deep mutable conversion)
+ * **Example** (Converting deeply to mutable types)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -533,7 +533,7 @@ export type NoInfer<A> = [A][A extends any ? 0 : never];
  * A value of type `Invariant<A>` cannot be assigned to `Invariant<B>` unless
  * `A` and `B` are the same type.
  *
- * **Example** (Invariant phantom type)
+ * **Example** (Defining an invariant phantom type)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -599,7 +599,7 @@ export declare namespace Invariant {
  * `Covariant<A>` is assignable to `Covariant<B>` when `A extends B`, following
  * the subtype direction.
  *
- * **Example** (Covariant phantom type)
+ * **Example** (Defining a covariant phantom type)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -665,7 +665,7 @@ export declare namespace Covariant {
  * `Contravariant<A>` is assignable to `Contravariant<B>` when `B extends A`,
  * following the supertype direction.
  *
- * **Example** (Contravariant phantom type)
+ * **Example** (Defining a contravariant phantom type)
  *
  * ```ts
  * import type { Types } from "effect"

package/dist/internal/effect.js

@@ -21,6 +21,7 @@ import { args, causeAnnotate, causeEmpty, causeFromReasons, CauseImpl, constEmpt
 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 { getStackTraceLimit, setStackTraceLimit } from "./stackTraceLimit.js";
 import { addSpanStackTrace, makeStackCleaner } from "./tracer.js";
 import { version } from "./version.js";
 // ----------------------------------------------------------------------------
@@ -177,8 +178,8 @@ export const causePrettyErrors = self => {
   const errors = [];
   const interrupts = [];
   if (self.reasons.length === 0) return errors;
-  const prevStackLimit = Error.stackTraceLimit;
-  Error.stackTraceLimit = 1;
+  const prevStackLimit = getStackTraceLimit();
+  setStackTraceLimit(1);
   for (const failure of self.reasons) {
     if (failure._tag === "Interrupt") {
       interrupts.push(failure);
@@ -197,8 +198,7 @@ export const causePrettyErrors = self => {
     error.stack = `${error.name}: ${error.message}`;
     errors.push(causePrettyError(error, interrupts[0].annotations));
   }
-  ;
-  Error.stackTraceLimit = prevStackLimit;
+  setStackTraceLimit(prevStackLimit);
   return errors;
 };
 /** @internal */
@@ -667,6 +667,8 @@ export const succeedSome = a => succeed(Option.some(a));
 /** @internal */
 export const succeedNone = /*#__PURE__*/succeed(/*#__PURE__*/Option.none());
 /** @internal */
+export const transposeOption = self => Option.isNone(self) ? succeedNone : map(self.value, Option.some);
+/** @internal */
 export const failCauseSync = evaluate => suspend(() => failCause(internalCall(evaluate)));
 /** @internal */
 export const die = defect => exitDie(defect);
@@ -677,13 +679,17 @@ const void_ = /*#__PURE__*/succeed(void 0);
 /** @internal */
 export { void_ as void };
 /** @internal */
-const try_ = options => suspend(() => {
-  try {
-    return succeed(internalCall(options.try));
-  } catch (err) {
-    return fail(internalCall(() => options.catch(err)));
-  }
-});
+const try_ = options => {
+  const evaluate = typeof options === "function" ? options : options.try;
+  const catcher = typeof options === "function" ? cause => new UnknownError(cause, "An error occurred in Effect.try") : options.catch;
+  return suspend(() => {
+    try {
+      return succeed(internalCall(evaluate));
+    } catch (err) {
+      return fail(internalCall(() => catcher(err)));
+    }
+  });
+};
 /** @internal */
 export { try_ as try };
 /** @internal */
@@ -695,12 +701,19 @@ export const tryPromise = options => {
   const f = typeof options === "function" ? options : options.try;
   const catcher = typeof options === "function" ? cause => new UnknownError(cause, "An error occurred in Effect.tryPromise") : options.catch;
   return callbackOptions(function (resume, signal) {
+    const failWithCatch = cause => {
+      try {
+        resume(fail(internalCall(() => catcher(cause))));
+      } catch (err) {
+        resume(die(err));
+      }
+    };
     try {
-      internalCall(() => f(signal)).then(a => resume(succeed(a)), e => resume(fail(internalCall(() => catcher(e)))));
+      internalCall(() => f(signal)).then(a => resume(succeed(a)), failWithCatch);
     } catch (err) {
-      resume(fail(internalCall(() => catcher(err))));
+      failWithCatch(err);
     }
-  }, eval.length !== 0);
+  }, f.length !== 0);
 };
 /** @internal */
 export const withFiberId = f => withFiber(fiber => f(fiber.id));
@@ -782,10 +795,10 @@ export const fn = function () {
   const nameFirst = typeof arguments[0] === "string";
   const name = nameFirst ? arguments[0] : "Effect.fn";
   const spanOptions = nameFirst ? arguments[1] : undefined;
-  const prevLimit = globalThis.Error.stackTraceLimit;
-  globalThis.Error.stackTraceLimit = 2;
+  const prevLimit = getStackTraceLimit();
+  setStackTraceLimit(2);
   const defError = new globalThis.Error();
-  globalThis.Error.stackTraceLimit = prevLimit;
+  setStackTraceLimit(prevLimit);
   if (nameFirst) {
     return (body, ...pipeables) => makeFn(name, body, defError, pipeables, nameFirst, spanOptions);
   }
@@ -804,10 +817,10 @@ const makeFn = (name, bodyOrOptions, defError, pipeables, addSpan, spanOptions)
     if (!isEffect(result)) {
       return result;
     }
-    const prevLimit = globalThis.Error.stackTraceLimit;
-    globalThis.Error.stackTraceLimit = 2;
+    const prevLimit = getStackTraceLimit();
+    setStackTraceLimit(2);
     const callError = new globalThis.Error();
-    globalThis.Error.stackTraceLimit = prevLimit;
+    setStackTraceLimit(prevLimit);
     return updateService(addSpan ? useSpan(name, spanOptions, span => provideParentSpan(result, span)) : result, CurrentStackFrame, prev => ({
       name,
       stack: fnStackCleaner(() => callError.stack),