effect 4.0.0-beta.83 → 4.0.0-beta.84

package/dist/Equivalence.js

@@ -43,7 +43,7 @@ import * as Reducer from "./Reducer.js";
  * console.log(caseInsensitive(str, str)) // true (fast path)
  * ```
  *
- * **Example** (Numeric tolerance equivalence)
+ * **Example** (Comparing numbers with tolerance)
  *
  * ```ts
  * import { Equivalence } from "effect"
@@ -79,7 +79,7 @@ const isStrictEquivalent = (x, y) => x === y;
  *
  * `NaN !== NaN`, so `NaN` values are never considered equivalent.
  *
- * **Example** (Primitive types)
+ * **Example** (Comparing primitive types)
  *
  * ```ts
  * import { Equivalence } from "effect"
@@ -91,7 +91,7 @@ const isStrictEquivalent = (x, y) => x === y;
  * console.log(strictEq(NaN, NaN)) // false (NaN !== NaN)
  * ```
  *
- * **Example** (Reference equality for objects)
+ * **Example** (Comparing objects by reference)
  *
  * ```ts
  * import { Equivalence } from "effect"
@@ -289,7 +289,7 @@ export const combine = /*#__PURE__*/dual(2, (self, that) => make((x, y) => self(
  * console.log(point3DEq(point1, point3)) // false (different z)
  * ```
  *
- * **Example** (Empty collection edge case)
+ * **Example** (Handling empty collections)
  *
  * ```ts
  * import { Equivalence } from "effect"
@@ -328,7 +328,7 @@ export const combineAll = collection => make((x, y) => {
  * - Useful for comparing by one property or normalizing values before
  *   comparison, such as case-insensitive strings
  *
- * **Example** (Equivalence based on object property)
+ * **Example** (Deriving equivalence from an object property)
  *
  * ```ts
  * import { Equivalence } from "effect"
@@ -389,7 +389,7 @@ export const mapInput = /*#__PURE__*/dual(2, (self, f) => make((x, y) => self(f(
  * respective equivalences, and it also satisfies reflexive, symmetric, and
  * transitive properties.
  *
- * **Example** (Homogeneous tuple equivalence)
+ * **Example** (Comparing homogeneous tuples)
  *
  * ```ts
  * import { Equivalence } from "effect"
@@ -408,7 +408,7 @@ export const mapInput = /*#__PURE__*/dual(2, (self, f) => make((x, y) => self(f(
  * console.log(stringTupleEq(tuple1, tuple3)) // false (different third element)
  * ```
  *
- * **Example** (Tuple with custom equivalences)
+ * **Example** (Comparing tuples with custom equivalences)
  *
  * ```ts
  * import { Equivalence } from "effect"
@@ -473,7 +473,7 @@ export {
  * - Empty arrays are considered equivalent
  * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties
  *
- * **Example** (Number array equivalence)
+ * **Example** (Comparing number arrays)
  *
  * ```ts
  * import { Equivalence } from "effect"
@@ -523,7 +523,7 @@ Array_ as Array };
  * are equivalent according to their equivalences, and it also satisfies
  * reflexive, symmetric, and transitive properties.
  *
- * **Example** (Struct with different equivalences per field)
+ * **Example** (Comparing structs with different equivalences per field)
  *
  * ```ts
  * import { Equivalence } from "effect"
@@ -553,7 +553,7 @@ Array_ as Array };
  * console.log(personEq(person1, person3)) // false (different age)
  * ```
  *
- * **Example** (Partial equivalence for specific fields)
+ * **Example** (Comparing specific fields)
  *
  * ```ts
  * import { Equivalence } from "effect"
@@ -601,7 +601,7 @@ export function Struct(fields) {
  * - Empty objects are considered equivalent
  * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties
  *
- * **Example** (Record with string values)
+ * **Example** (Defining records with string values)
  *
  * ```ts
  * import { Equivalence } from "effect"
@@ -618,7 +618,7 @@ export function Struct(fields) {
  * console.log(stringRecordEq(record1, record4)) // false (different keys)
  * ```
  *
- * **Example** (Record with number values)
+ * **Example** (Defining records with number values)
  *
  * ```ts
  * import { Equivalence } from "effect"
@@ -719,7 +719,7 @@ export function makeReducer() {
  * console.log(Equivalence.Date(invalidDate1, d1)) // false
  * ```
  *
- * **Example** (Reference vs value equality)
+ * **Example** (Comparing reference and value equality)
  *
  * ```ts
  * import { Equivalence } from "effect"

package/dist/Exit.d.ts

@@ -342,7 +342,7 @@ export {
  * Equivalent to `Exit.succeed(undefined)` but shared as a single instance,
  * avoiding allocation for a common case.
  *
- * **Example** (Using the void Exit)
+ * **Example** (Referencing the void Exit)
  *
  * ```ts
  * import { Exit } from "effect"
@@ -366,7 +366,7 @@ void_ as void };
  * Use as a type guard to narrow `Exit<A, E>` to `Success<A, E>` and access the
  * `value` property.
  *
- * **Example** (Narrowing to Success)
+ * **Example** (Narrowing to success)
  *
  * ```ts
  * import { Exit } from "effect"
@@ -393,7 +393,7 @@ export declare const isSuccess: <A, E>(self: Exit<A, E>) => self is Success<A, E
  * Use as a type guard to narrow `Exit<A, E>` to `Failure<A, E>` and access the
  * `cause` property.
  *
- * **Example** (Narrowing to Failure)
+ * **Example** (Narrowing to failure)
  *
  * ```ts
  * import { Exit } from "effect"

package/dist/Exit.js

@@ -193,7 +193,7 @@ export {
  * Equivalent to `Exit.succeed(undefined)` but shared as a single instance,
  * avoiding allocation for a common case.
  *
- * **Example** (Using the void Exit)
+ * **Example** (Referencing the void Exit)
  *
  * ```ts
  * import { Exit } from "effect"
@@ -217,7 +217,7 @@ void_ as void };
  * Use as a type guard to narrow `Exit<A, E>` to `Success<A, E>` and access the
  * `value` property.
  *
- * **Example** (Narrowing to Success)
+ * **Example** (Narrowing to success)
  *
  * ```ts
  * import { Exit } from "effect"
@@ -244,7 +244,7 @@ export const isSuccess = effect.exitIsSuccess;
  * Use as a type guard to narrow `Exit<A, E>` to `Failure<A, E>` and access the
  * `cause` property.
  *
- * **Example** (Narrowing to Failure)
+ * **Example** (Narrowing to failure)
  *
  * ```ts
  * import { Exit } from "effect"

package/dist/Formatter.d.ts

@@ -9,7 +9,7 @@
  *
  * This is a pure callable type and carries no runtime implementation. It is contravariant in `Value` and covariant in `Format`.
  *
- * **Example** (Define a custom formatter)
+ * **Example** (Defining a custom formatter)
  *
  * ```ts
  * import type { Formatter } from "effect"
@@ -58,7 +58,7 @@ export interface Formatter<in Value, out Format = string> {
  *   `"\t"`). Defaults to `0` (compact).
  * - `ignoreToString` — skip calling `toString()`. Defaults to `false`.
  *
- * **Example** (Compact output)
+ * **Example** (Formatting compact output)
  *
  * ```ts
  * import { Formatter } from "effect"
@@ -82,7 +82,7 @@ export interface Formatter<in Value, out Format = string> {
  * // }
  * ```
  *
- * **Example** (Circular reference handling)
+ * **Example** (Handling circular references)
  *
  * ```ts
  * import { Formatter } from "effect"
@@ -120,7 +120,7 @@ export declare function format(input: unknown, options?: {
  * `Symbol`, `undefined`, and functions, follow standard `JSON.stringify`
  * behavior. The `space` parameter controls indentation and defaults to `0`.
  *
- * **Example** (Compact JSON)
+ * **Example** (Formatting compact JSON)
  *
  * ```ts
  * import { Formatter } from "effect"
@@ -129,7 +129,7 @@ export declare function format(input: unknown, options?: {
  * // {"name":"Alice","age":30}
  * ```
  *
- * **Example** (Circular reference handling)
+ * **Example** (Handling circular references)
  *
  * ```ts
  * import { Formatter } from "effect"

package/dist/Formatter.js

@@ -41,7 +41,7 @@ import { getRedacted, redact, symbolRedactable } from "./Redactable.js";
  *   `"\t"`). Defaults to `0` (compact).
  * - `ignoreToString` — skip calling `toString()`. Defaults to `false`.
  *
- * **Example** (Compact output)
+ * **Example** (Formatting compact output)
  *
  * ```ts
  * import { Formatter } from "effect"
@@ -65,7 +65,7 @@ import { getRedacted, redact, symbolRedactable } from "./Redactable.js";
  * // }
  * ```
  *
- * **Example** (Circular reference handling)
+ * **Example** (Handling circular references)
  *
  * ```ts
  * import { Formatter } from "effect"
@@ -189,7 +189,7 @@ function safeToString(input) {
  * `Symbol`, `undefined`, and functions, follow standard `JSON.stringify`
  * behavior. The `space` parameter controls indentation and defaults to `0`.
  *
- * **Example** (Compact JSON)
+ * **Example** (Formatting compact JSON)
  *
  * ```ts
  * import { Formatter } from "effect"
@@ -198,7 +198,7 @@ function safeToString(input) {
  * // {"name":"Alice","age":30}
  * ```
  *
- * **Example** (Circular reference handling)
+ * **Example** (Handling circular references)
  *
  * ```ts
  * import { Formatter } from "effect"

package/dist/Function.d.ts

@@ -48,7 +48,7 @@ export interface FunctionTypeLambda extends TypeLambda {
  * whether the current call is data-first. Arity is the common case. Use a
  * predicate when optional arguments make arity ambiguous.
  *
- * **Example** (Using arity to determine data-first or data-last style)
+ * **Example** (Selecting data-first or data-last style by arity)
  *
  * ```ts
  * import { Function, pipe } from "effect"
@@ -62,7 +62,7 @@ export interface FunctionTypeLambda extends TypeLambda {
  * console.log(pipe(2, sum(3))) // 5
  * ```
  *
- * **Example** (Using call signatures to define the overloads)
+ * **Example** (Defining overloads with call signatures)
  *
  * ```ts
  * import { Function, pipe } from "effect"
@@ -76,7 +76,7 @@ export interface FunctionTypeLambda extends TypeLambda {
  * console.log(pipe(2, sum(3))) // 5
  * ```
  *
- * **Example** (Using a predicate to determine data-first or data-last style)
+ * **Example** (Selecting data-first or data-last style with a predicate)
  *
  * ```ts
  * import { Function, pipe } from "effect"
@@ -112,7 +112,7 @@ export declare const dual: {
      * whether the current call is data-first. Arity is the common case. Use a
      * predicate when optional arguments make arity ambiguous.
      *
-     * **Example** (Using arity to determine data-first or data-last style)
+     * **Example** (Selecting data-first or data-last style by arity)
      *
      * ```ts
      * import { Function, pipe } from "effect"
@@ -126,7 +126,7 @@ export declare const dual: {
      * console.log(pipe(2, sum(3))) // 5
      * ```
      *
-     * **Example** (Using call signatures to define the overloads)
+     * **Example** (Defining overloads with call signatures)
      *
      * ```ts
      * import { Function, pipe } from "effect"
@@ -140,7 +140,7 @@ export declare const dual: {
      * console.log(pipe(2, sum(3))) // 5
      * ```
      *
-     * **Example** (Using a predicate to determine data-first or data-last style)
+     * **Example** (Selecting data-first or data-last style with a predicate)
      *
      * ```ts
      * import { Function, pipe } from "effect"
@@ -176,7 +176,7 @@ export declare const dual: {
      * whether the current call is data-first. Arity is the common case. Use a
      * predicate when optional arguments make arity ambiguous.
      *
-     * **Example** (Using arity to determine data-first or data-last style)
+     * **Example** (Selecting data-first or data-last style by arity)
      *
      * ```ts
      * import { Function, pipe } from "effect"
@@ -190,7 +190,7 @@ export declare const dual: {
      * console.log(pipe(2, sum(3))) // 5
      * ```
      *
-     * **Example** (Using call signatures to define the overloads)
+     * **Example** (Defining overloads with call signatures)
      *
      * ```ts
      * import { Function, pipe } from "effect"
@@ -204,7 +204,7 @@ export declare const dual: {
      * console.log(pipe(2, sum(3))) // 5
      * ```
      *
-     * **Example** (Using a predicate to determine data-first or data-last style)
+     * **Example** (Selecting data-first or data-last style with a predicate)
      *
      * ```ts
      * import { Function, pipe } from "effect"
@@ -688,7 +688,7 @@ export declare const untupled: <A extends ReadonlyArray<unknown>, B>(f: (a: A) =
  * Each function passed after the initial value must accept a single argument,
  * because `pipe` calls each step with only the previous result.
  *
- * **Example** (Using pipeline syntax)
+ * **Example** (Piping values through functions)
  *
  * In this example, `1` is passed to the first function, and each result becomes
  * the input for the next function.

package/dist/Function.js

@@ -14,7 +14,7 @@ import { pipeArguments } from "./Pipeable.js";
  * whether the current call is data-first. Arity is the common case. Use a
  * predicate when optional arguments make arity ambiguous.
  *
- * **Example** (Using arity to determine data-first or data-last style)
+ * **Example** (Selecting data-first or data-last style by arity)
  *
  * ```ts
  * import { Function, pipe } from "effect"
@@ -28,7 +28,7 @@ import { pipeArguments } from "./Pipeable.js";
  * console.log(pipe(2, sum(3))) // 5
  * ```
  *
- * **Example** (Using call signatures to define the overloads)
+ * **Example** (Defining overloads with call signatures)
  *
  * ```ts
  * import { Function, pipe } from "effect"
@@ -42,7 +42,7 @@ import { pipeArguments } from "./Pipeable.js";
  * console.log(pipe(2, sum(3))) // 5
  * ```
  *
- * **Example** (Using a predicate to determine data-first or data-last style)
+ * **Example** (Selecting data-first or data-last style with a predicate)
  *
  * ```ts
  * import { Function, pipe } from "effect"

package/dist/HashMap.d.ts

@@ -1821,7 +1821,7 @@ export declare const map: {
  *
  * The hash and equality behavior of both maps have to be the same.
  *
- * **Example** (FlatMapping values)
+ * **Example** (Flat mapping values)
  *
  * ```ts
  * import { HashMap } from "effect"
@@ -1848,7 +1848,7 @@ export declare const flatMap: {
      *
      * The hash and equality behavior of both maps have to be the same.
      *
-     * **Example** (FlatMapping values)
+     * **Example** (Flat mapping values)
      *
      * ```ts
      * import { HashMap } from "effect"
@@ -1875,7 +1875,7 @@ export declare const flatMap: {
      *
      * The hash and equality behavior of both maps have to be the same.
      *
-     * **Example** (FlatMapping values)
+     * **Example** (Flat mapping values)
      *
      * ```ts
      * import { HashMap } from "effect"

package/dist/HashMap.js

@@ -741,7 +741,7 @@ export const map = internal.map;
  *
  * The hash and equality behavior of both maps have to be the same.
  *
- * **Example** (FlatMapping values)
+ * **Example** (Flat mapping values)
  *
  * ```ts
  * import { HashMap } from "effect"

package/dist/Iterable.d.ts

@@ -2868,7 +2868,7 @@ export declare const map: {
 /**
  * Applies a function to each element in an Iterable and returns a new Iterable containing the concatenated mapped elements.
  *
- * **Example** (FlatMapping iterables)
+ * **Example** (Flat mapping iterables)
  *
  * ```ts
  * import { Iterable } from "effect"
@@ -2907,7 +2907,7 @@ export declare const flatMap: {
     /**
      * Applies a function to each element in an Iterable and returns a new Iterable containing the concatenated mapped elements.
      *
-     * **Example** (FlatMapping iterables)
+     * **Example** (Flat mapping iterables)
      *
      * ```ts
      * import { Iterable } from "effect"
@@ -2946,7 +2946,7 @@ export declare const flatMap: {
     /**
      * Applies a function to each element in an Iterable and returns a new Iterable containing the concatenated mapped elements.
      *
-     * **Example** (FlatMapping iterables)
+     * **Example** (Flat mapping iterables)
      *
      * ```ts
      * import { Iterable } from "effect"
@@ -3579,7 +3579,7 @@ export declare const filter: {
  * Use when working with APIs or functions that return nullable values,
  * providing a clean way to filter out null or undefined while transforming.
  *
- * **Example** (FlatMapping nullable results)
+ * **Example** (Flat mapping nullable results)
  *
  * ```ts
  * import { Iterable } from "effect"
@@ -3625,7 +3625,7 @@ export declare const flatMapNullishOr: {
      * Use when working with APIs or functions that return nullable values,
      * providing a clean way to filter out null or undefined while transforming.
      *
-     * **Example** (FlatMapping nullable results)
+     * **Example** (Flat mapping nullable results)
      *
      * ```ts
      * import { Iterable } from "effect"
@@ -3671,7 +3671,7 @@ export declare const flatMapNullishOr: {
      * Use when working with APIs or functions that return nullable values,
      * providing a clean way to filter out null or undefined while transforming.
      *
-     * **Example** (FlatMapping nullable results)
+     * **Example** (Flat mapping nullable results)
      *
      * ```ts
      * import { Iterable } from "effect"

package/dist/Iterable.js

@@ -1425,7 +1425,7 @@ export const map = /*#__PURE__*/dual(2, (self, f) => ({
 /**
  * Applies a function to each element in an Iterable and returns a new Iterable containing the concatenated mapped elements.
  *
- * **Example** (FlatMapping iterables)
+ * **Example** (Flat mapping iterables)
  *
  * ```ts
  * import { Iterable } from "effect"
@@ -1875,7 +1875,7 @@ export const filter = /*#__PURE__*/dual(2, (self, predicate) => ({
  * Use when working with APIs or functions that return nullable values,
  * providing a clean way to filter out null or undefined while transforming.
  *
- * **Example** (FlatMapping nullable results)
+ * **Example** (Flat mapping nullable results)
  *
  * ```ts
  * import { Iterable } from "effect"

package/dist/JsonPatch.d.ts

@@ -16,7 +16,7 @@ import type * as Schema from "./Schema.ts";
  * discriminated by the `op` field, and the optional `description` field can be
  * used for documentation.
  *
- * **Example** (All operation types)
+ * **Example** (Defining all operation types)
  *
  * ```ts
  * import { JsonPatch } from "effect"
@@ -96,7 +96,7 @@ export type JsonPatchOperation = {
  * operations observe the document state produced by earlier operations. An empty
  * array represents a no-op patch and returns the original document.
  *
- * **Example** (Multi-operation patch)
+ * **Example** (Defining a multi-operation patch)
  *
  * ```ts
  * import { JsonPatch } from "effect"

package/dist/Layer.d.ts

@@ -3680,7 +3680,7 @@ export declare const span: (name: string, options?: SpanOptions) => Layer<Tracer
  * that are built with this layer. This API does not create, end, or close the
  * span; the caller remains responsible for the span's lifetime.
  *
- * **Example** (Using an existing parent span)
+ * **Example** (Referencing an existing parent span)
  *
  * ```ts
  * import { Console, Context, Effect, Layer, Tracer } from "effect"

package/dist/Layer.js

@@ -1743,7 +1743,7 @@ export const span = (name, options) => {
  * that are built with this layer. This API does not create, end, or close the
  * span; the caller remains responsible for the span's lifetime.
  *
- * **Example** (Using an existing parent span)
+ * **Example** (Referencing an existing parent span)
  *
  * ```ts
  * import { Console, Context, Effect, Layer, Tracer } from "effect"

package/dist/Logger.d.ts

@@ -347,7 +347,7 @@ export declare const make: <Message, Output>(log: (options: Options<Message>) =>
 /**
  * The default logging implementation used by the Effect runtime.
  *
- * **Example** (Using the default logger)
+ * **Example** (Referencing the default logger)
  *
  * ```ts
  * import { Effect, Logger } from "effect"

package/dist/Logger.js

@@ -357,7 +357,7 @@ export const make = effect.loggerMake;
 /**
  * The default logging implementation used by the Effect runtime.
  *
- * **Example** (Using the default logger)
+ * **Example** (Referencing the default logger)
  *
  * ```ts
  * import { Effect, Logger } from "effect"

package/dist/Match.d.ts

@@ -568,7 +568,7 @@ export declare const typeTags: {
  * **Important:** This function must be the first step in the matcher pipeline.
  * If used later, TypeScript will not enforce type consistency correctly.
  *
- * **Example** (Validating Return Type Consistency)
+ * **Example** (Validating return type consistency)
  *
  * ```ts
  * import { Match } from "effect"
@@ -604,7 +604,7 @@ export declare const withReturnType: <Ret>() => <I, F, R, A, Pr, _>(self: Matche
  * pattern matches, the associated function is executed and the matched input is
  * removed from the remaining cases tracked by the matcher.
  *
- * **Example** (Matching with Values and Predicates)
+ * **Example** (Matching with values and predicates)
  *
  * ```ts
  * import { Match } from "effect"
@@ -912,7 +912,7 @@ export declare const discriminatorsExhaustive: <D extends string>(field: D) => <
  * `"_tag"` as their discriminator field. Use {@link discriminator} for a
  * different discriminator field.
  *
- * **Example** (Matching a Discriminated Union by Tag)
+ * **Example** (Matching a discriminated union by tag)
  *
  * ```ts
  * import { Match } from "effect"
@@ -1068,7 +1068,7 @@ export declare const tagsExhaustive: <R, Ret, P extends {
  * Any excluded value bypasses the provided function and continues matching
  * through later cases.
  *
- * **Example** (Ignoring a Specific Value)
+ * **Example** (Ignoring a specific value)
  *
  * ```ts
  * import { Match } from "effect"
@@ -1706,7 +1706,7 @@ export declare const instanceOfUnsafe: <A extends abstract new (...args: any) =>
  * `default` clause in a `switch` statement or the final `else` in an `if-else`
  * chain.
  *
- * **Example** (Providing a Default Value When No Patterns Match)
+ * **Example** (Providing a default value when no patterns match)
  *
  * ```ts
  * import { Match } from "effect"
@@ -1793,7 +1793,7 @@ export declare const orElseAbsurd: <I, R, RA, A, Pr, Ret>(self: Matcher<I, R, RA
  * unmatched case should be explicitly handled rather than returning a default
  * value or throwing an error.
  *
- * **Example** (Extracting a User Role with `Match.result`)
+ * **Example** (Extracting a user role with `Match.result`)
  *
  * ```ts
  * import { Match } from "effect"
@@ -1836,7 +1836,7 @@ export declare const result: <I, F, R, A, Pr, Ret>(self: Matcher<I, F, R, A, Pr,
  * handled explicitly rather than throwing an error or returning a default
  * value.
  *
- * **Example** (Extracting a User Role with `Match.option`)
+ * **Example** (Extracting a user role with `Match.option`)
  *
  * ```ts
  * import { Match } from "effect"
@@ -1877,7 +1877,7 @@ export declare const option: <I, F, R, A, Pr, Ret>(self: Matcher<I, F, R, A, Pr,
  * If any case is still unmatched, the matcher does not type-check as
  * exhaustive.
  *
- * **Example** (Ensuring All Cases Are Covered)
+ * **Example** (Ensuring all cases are covered)
  *
  * ```ts
  * import { Match } from "effect"

package/dist/Match.js

@@ -192,7 +192,7 @@ export const typeTags = internal.typeTags;
  * **Important:** This function must be the first step in the matcher pipeline.
  * If used later, TypeScript will not enforce type consistency correctly.
  *
- * **Example** (Validating Return Type Consistency)
+ * **Example** (Validating return type consistency)
  *
  * ```ts
  * import { Match } from "effect"
@@ -228,7 +228,7 @@ export const withReturnType = internal.withReturnType;
  * pattern matches, the associated function is executed and the matched input is
  * removed from the remaining cases tracked by the matcher.
  *
- * **Example** (Matching with Values and Predicates)
+ * **Example** (Matching with values and predicates)
  *
  * ```ts
  * import { Match } from "effect"
@@ -528,7 +528,7 @@ export const discriminatorsExhaustive = internal.discriminatorsExhaustive;
  * `"_tag"` as their discriminator field. Use {@link discriminator} for a
  * different discriminator field.
  *
- * **Example** (Matching a Discriminated Union by Tag)
+ * **Example** (Matching a discriminated union by tag)
  *
  * ```ts
  * import { Match } from "effect"
@@ -676,7 +676,7 @@ export const tagsExhaustive = internal.tagsExhaustive;
  * Any excluded value bypasses the provided function and continues matching
  * through later cases.
  *
- * **Example** (Ignoring a Specific Value)
+ * **Example** (Ignoring a specific value)
  *
  * ```ts
  * import { Match } from "effect"
@@ -1312,7 +1312,7 @@ export const instanceOfUnsafe = internal.instanceOf;
  * `default` clause in a `switch` statement or the final `else` in an `if-else`
  * chain.
  *
- * **Example** (Providing a Default Value When No Patterns Match)
+ * **Example** (Providing a default value when no patterns match)
  *
  * ```ts
  * import { Match } from "effect"
@@ -1400,7 +1400,7 @@ export const orElseAbsurd = internal.orElseAbsurd;
  * unmatched case should be explicitly handled rather than returning a default
  * value or throwing an error.
  *
- * **Example** (Extracting a User Role with `Match.result`)
+ * **Example** (Extracting a user role with `Match.result`)
  *
  * ```ts
  * import { Match } from "effect"
@@ -1443,7 +1443,7 @@ export const result = internal.result;
  * handled explicitly rather than throwing an error or returning a default
  * value.
  *
- * **Example** (Extracting a User Role with `Match.option`)
+ * **Example** (Extracting a user role with `Match.option`)
  *
  * ```ts
  * import { Match } from "effect"
@@ -1484,7 +1484,7 @@ export const option = internal.option;
  * If any case is still unmatched, the matcher does not type-check as
  * exhaustive.
  *
- * **Example** (Ensuring All Cases Are Covered)
+ * **Example** (Ensuring all cases are covered)
  *
  * ```ts
  * import { Match } from "effect"