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

package/dist/Result.d.ts

@@ -311,7 +311,7 @@ export {
  * This is equivalent to `Result.succeed(undefined)`, but reuses a shared
  * `Success` wrapper instead of allocating one each time.
  *
- * **Example** (Using void result)
+ * **Example** (Referencing void results)
  *
  * ```ts
  * import { Result } from "effect"
@@ -342,7 +342,7 @@ void_ as void };
  * `Result<never, void>`, but reuses a shared `Failure` wrapper instead of
  * allocating one each time.
  *
- * **Example** (Using a failure without a payload)
+ * **Example** (Failing without a payload)
  *
  * ```ts
  * import { Result } from "effect"
@@ -655,7 +655,7 @@ export declare const isResult: (input: unknown) => input is Result<unknown, unkn
  * - Acts as a TypeScript type guard, narrowing to `Failure<A, E>`
  * - After narrowing, you can access `.failure` to read the error value
  *
- * **Example** (Narrowing to Failure)
+ * **Example** (Narrowing to failure)
  *
  * ```ts
  * import { Result } from "effect"
@@ -687,7 +687,7 @@ export declare const isFailure: <A, E>(self: Result<A, E>) => self is Failure<A,
  * - Acts as a TypeScript type guard, narrowing to `Success<A, E>`
  * - After narrowing, you can access `.success` to read the value
  *
- * **Example** (Narrowing to Success)
+ * **Example** (Narrowing to success)
  *
  * ```ts
  * import { Result } from "effect"
@@ -2096,7 +2096,7 @@ export declare const orElse: {
  * - The error types are merged into a union (`E | E2`)
  * - This is the monadic `bind` / `>>=` for `Result`
  *
- * **Example** (Sequential validation)
+ * **Example** (Validating sequentially)
  *
  * ```ts
  * import { pipe, Result } from "effect"
@@ -2133,7 +2133,7 @@ export declare const flatMap: {
      * - The error types are merged into a union (`E | E2`)
      * - This is the monadic `bind` / `>>=` for `Result`
      *
-     * **Example** (Sequential validation)
+     * **Example** (Validating sequentially)
      *
      * ```ts
      * import { pipe, Result } from "effect"
@@ -2170,7 +2170,7 @@ export declare const flatMap: {
      * - The error types are merged into a union (`E | E2`)
      * - This is the monadic `bind` / `>>=` for `Result`
      *
-     * **Example** (Sequential validation)
+     * **Example** (Validating sequentially)
      *
      * ```ts
      * import { pipe, Result } from "effect"
@@ -2211,7 +2211,7 @@ export declare const flatMap: {
  *
  * If `self` is a `Failure`, the second argument is never evaluated.
  *
- * **Example** (Using andThen with different argument types)
+ * **Example** (Chaining Result values with different argument types)
  *
  * ```ts
  * import { pipe, Result } from "effect"
@@ -2259,7 +2259,7 @@ export declare const andThen: {
      *
      * If `self` is a `Failure`, the second argument is never evaluated.
      *
-     * **Example** (Using andThen with different argument types)
+     * **Example** (Chaining Result values with different argument types)
      *
      * ```ts
      * import { pipe, Result } from "effect"
@@ -2307,7 +2307,7 @@ export declare const andThen: {
      *
      * If `self` is a `Failure`, the second argument is never evaluated.
      *
-     * **Example** (Using andThen with different argument types)
+     * **Example** (Chaining Result values with different argument types)
      *
      * ```ts
      * import { pipe, Result } from "effect"
@@ -2355,7 +2355,7 @@ export declare const andThen: {
      *
      * If `self` is a `Failure`, the second argument is never evaluated.
      *
-     * **Example** (Using andThen with different argument types)
+     * **Example** (Chaining Result values with different argument types)
      *
      * ```ts
      * import { pipe, Result } from "effect"
@@ -2403,7 +2403,7 @@ export declare const andThen: {
      *
      * If `self` is a `Failure`, the second argument is never evaluated.
      *
-     * **Example** (Using andThen with different argument types)
+     * **Example** (Chaining Result values with different argument types)
      *
      * ```ts
      * import { pipe, Result } from "effect"
@@ -2451,7 +2451,7 @@ export declare const andThen: {
      *
      * If `self` is a `Failure`, the second argument is never evaluated.
      *
-     * **Example** (Using andThen with different argument types)
+     * **Example** (Chaining Result values with different argument types)
      *
      * ```ts
      * import { pipe, Result } from "effect"
@@ -2499,7 +2499,7 @@ export declare const andThen: {
      *
      * If `self` is a `Failure`, the second argument is never evaluated.
      *
-     * **Example** (Using andThen with different argument types)
+     * **Example** (Chaining Result values with different argument types)
      *
      * ```ts
      * import { pipe, Result } from "effect"
@@ -2547,7 +2547,7 @@ export declare const andThen: {
      *
      * If `self` is a `Failure`, the second argument is never evaluated.
      *
-     * **Example** (Using andThen with different argument types)
+     * **Example** (Chaining Result values with different argument types)
      *
      * ```ts
      * import { pipe, Result } from "effect"
@@ -2595,7 +2595,7 @@ export declare const andThen: {
      *
      * If `self` is a `Failure`, the second argument is never evaluated.
      *
-     * **Example** (Using andThen with different argument types)
+     * **Example** (Chaining Result values with different argument types)
      *
      * ```ts
      * import { pipe, Result } from "effect"
@@ -3095,7 +3095,7 @@ export declare const transposeOption: <A = never, E = never>(self: Option<Result
  * - `Some(a)` where `f(a)` is `Success(b)` becomes `Success(Some(b))`
  * - `Some(a)` where `f(a)` is `Failure(e)` becomes `Failure(e)`
  *
- * **Example** (Map and transpose in one step)
+ * **Example** (Mapping and transposing in one step)
  *
  * ```ts
  * import { Option, Result } from "effect"
@@ -3131,7 +3131,7 @@ export declare const transposeMapOption: (<A, B, E = never>(f: (self: A) => Resu
  * This is equivalent to `Result.succeed(Option.none())`, but reuses a shared
  * `Success` wrapper instead of allocating one each time.
  *
- * **Example** (Using succeedNone)
+ * **Example** (Succeeding with None)
  *
  * ```ts
  * import { Result } from "effect"

package/dist/Result.js

@@ -86,7 +86,7 @@ export {
  * This is equivalent to `Result.succeed(undefined)`, but reuses a shared
  * `Success` wrapper instead of allocating one each time.
  *
- * **Example** (Using void result)
+ * **Example** (Referencing void results)
  *
  * ```ts
  * import { Result } from "effect"
@@ -117,7 +117,7 @@ void_ as void };
  * `Result<never, void>`, but reuses a shared `Failure` wrapper instead of
  * allocating one each time.
  *
- * **Example** (Using a failure without a payload)
+ * **Example** (Failing without a payload)
  *
  * ```ts
  * import { Result } from "effect"
@@ -296,7 +296,7 @@ export const isResult = result.isResult;
  * - Acts as a TypeScript type guard, narrowing to `Failure<A, E>`
  * - After narrowing, you can access `.failure` to read the error value
  *
- * **Example** (Narrowing to Failure)
+ * **Example** (Narrowing to failure)
  *
  * ```ts
  * import { Result } from "effect"
@@ -328,7 +328,7 @@ export const isFailure = result.isFailure;
  * - Acts as a TypeScript type guard, narrowing to `Success<A, E>`
  * - After narrowing, you can access `.success` to read the value
  *
- * **Example** (Narrowing to Success)
+ * **Example** (Narrowing to success)
  *
  * ```ts
  * import { Result } from "effect"
@@ -922,7 +922,7 @@ export const orElse = /*#__PURE__*/dual(2, (self, that) => isFailure(self) ? tha
  * - The error types are merged into a union (`E | E2`)
  * - This is the monadic `bind` / `>>=` for `Result`
  *
- * **Example** (Sequential validation)
+ * **Example** (Validating sequentially)
  *
  * ```ts
  * import { pipe, Result } from "effect"
@@ -962,7 +962,7 @@ export const flatMap = /*#__PURE__*/dual(2, (self, f) => isFailure(self) ? fail(
  *
  * If `self` is a `Failure`, the second argument is never evaluated.
  *
- * **Example** (Using andThen with different argument types)
+ * **Example** (Chaining Result values with different argument types)
  *
  * ```ts
  * import { pipe, Result } from "effect"
@@ -1341,7 +1341,7 @@ export const transposeOption = self => {
  * - `Some(a)` where `f(a)` is `Success(b)` becomes `Success(Some(b))`
  * - `Some(a)` where `f(a)` is `Failure(e)` becomes `Failure(e)`
  *
- * **Example** (Map and transpose in one step)
+ * **Example** (Mapping and transposing in one step)
  *
  * ```ts
  * import { Option, Result } from "effect"
@@ -1377,7 +1377,7 @@ export const transposeMapOption = /*#__PURE__*/dual(2, (self, f) => option_.isNo
  * This is equivalent to `Result.succeed(Option.none())`, but reuses a shared
  * `Success` wrapper instead of allocating one each time.
  *
- * **Example** (Using succeedNone)
+ * **Example** (Succeeding with None)
  *
  * ```ts
  * import { Result } from "effect"

package/dist/Runtime.d.ts

@@ -73,7 +73,7 @@ export interface Teardown {
  * The `130` code is used only when the Cause contains interruptions and no
  * other failure reasons. Mixed causes use the squashed error path instead.
  *
- * **Example** (Using default teardown)
+ * **Example** (Referencing default teardown)
  *
  * ```ts
  * import { Exit, Runtime } from "effect"

package/dist/Runtime.js

@@ -36,7 +36,7 @@ import { constVoid, dual } from "effect/Function";
  * The `130` code is used only when the Cause contains interruptions and no
  * other failure reasons. Mixed causes use the squashed error path instead.
  *
- * **Example** (Using default teardown)
+ * **Example** (Referencing default teardown)
  *
  * ```ts
  * import { Exit, Runtime } from "effect"