effect 4.0.0-beta.101 → 4.0.0-beta.103

package/src/Match.ts

@@ -30,7 +30,7 @@ const TypeId = internal.TypeId
  *
  * **Example** (Matching string and number values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * // Simulated dynamic input that can be a string or a number
@@ -47,8 +47,7 @@ const TypeId = internal.TypeId
  *   Match.exhaustive
  * )
  *
- * console.log(result)
- * // Output: "string: some input"
+ * result // => "string: some input"
  * ```
  *
  * @category models
@@ -70,7 +69,7 @@ export type Matcher<Input, Filters, RemainingApplied, Result, Provided, Return =
  *
  * **Example** (Creating a type matcher)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * // Create a TypeMatcher for string | number
@@ -80,8 +79,8 @@ export type Matcher<Input, Filters, RemainingApplied, Result, Provided, Return =
  *   Match.exhaustive
  * )
  *
- * console.log(matcher("hello")) // "String: hello"
- * console.log(matcher(42)) // "Number: 42"
+ * matcher("hello") // => "String: hello"
+ * matcher(42) // => "Number: 42"
  * ```
  *
  * @category models
@@ -111,7 +110,7 @@ export interface TypeMatcher<in Input, out Filters, out Remaining, out Result, o
  *
  * **Example** (Creating a value matcher)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const input = { type: "user", name: "Alice", age: 30 }
@@ -123,7 +122,7 @@ export interface TypeMatcher<in Input, out Filters, out Remaining, out Result, o
  *   Match.orElse(() => "Unknown type")
  * )
  *
- * console.log(result) // "User: Alice"
+ * result // => "User: Alice"
  * ```
  *
  * @category models
@@ -177,7 +176,7 @@ export type Case = When | Not
  *
  * **Example** (Creating positive match cases)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * // When creates cases that match specific patterns
@@ -187,8 +186,8 @@ export type Case = When | Not
  *   Match.exhaustive
  * )
  *
- * console.log(stringMatcher("hello")) // "Got string: hello"
- * console.log(stringMatcher(42)) // "Got number: 42"
+ * stringMatcher("hello") // => "Got string: hello"
+ * stringMatcher(42) // => "Got number: 42"
  * ```
  *
  * @category models
@@ -211,7 +210,7 @@ export interface When {
  *
  * **Example** (Creating negative match cases)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * // Not creates cases that exclude specific patterns
@@ -221,8 +220,8 @@ export interface When {
  *   Match.orElse(() => "This string is forbidden")
  * )
  *
- * console.log(matcher("hello")) // "Allowed: hello"
- * console.log(matcher("forbidden")) // "This string is forbidden"
+ * matcher("hello") // => "Allowed: hello"
+ * matcher("forbidden") // => "This string is forbidden"
  * ```
  *
  * @category models
@@ -250,7 +249,7 @@ export interface Not {
  *
  * **Example** (Matching Numbers and Strings)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * // Create a matcher for values that are either strings or numbers
@@ -266,11 +265,9 @@ export interface Not {
  *   Match.exhaustive
  * )
  *
- * console.log(match(0))
- * // Output: "number: 0"
+ * match(0) // => "number: 0"
  *
- * console.log(match("hello"))
- * // Output: "string: hello"
+ * match("hello") // => "string: hello"
  * ```
  *
  * @see {@link value} for creating a matcher from a specific value.
@@ -299,7 +296,7 @@ export const type: <I>() => Matcher<I, Types.Without<never>, I, never, never> =
  *
  * **Example** (Matching an Object by Property)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const input = { name: "John", age: 30 }
@@ -315,8 +312,7 @@ export const type: <I>() => Matcher<I, Types.Without<never>, I, never, never> =
  *   Match.orElse(() => "Oh, not John")
  * )
  *
- * console.log(result)
- * // Output: "John is 30 years old"
+ * result // => "John is 30 years old"
  * ```
  *
  * @see {@link type} for creating a matcher from a specific type.
@@ -339,7 +335,7 @@ export const value: <const I>(
  *
  * **Example** (Matching value tags)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * type Status = { readonly _tag: "Success"; readonly data: string }
@@ -351,7 +347,7 @@ export const value: <const I>(
  *   Success: (result) => `Success: ${result.data}`
  * })
  *
- * console.log(message) // "Success: Hello"
+ * message // => "Success: Hello"
  * ```
  *
  * @category constructors
@@ -369,7 +365,7 @@ export const valueTags: {
    *
    * **Example** (Matching value tags)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Match } from "effect"
    *
    * type Status = { readonly _tag: "Success"; readonly data: string }
@@ -381,7 +377,7 @@ export const valueTags: {
    *   Success: (result) => `Success: ${result.data}`
    * })
    *
-   * console.log(message) // "Success: Hello"
+   * message // => "Success: Hello"
    * ```
    *
    * @category constructors
@@ -404,7 +400,7 @@ export const valueTags: {
    *
    * **Example** (Matching value tags)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Match } from "effect"
    *
    * type Status = { readonly _tag: "Success"; readonly data: string }
@@ -416,7 +412,7 @@ export const valueTags: {
    *   Success: (result) => `Success: ${result.data}`
    * })
    *
-   * console.log(message) // "Success: Hello"
+   * message // => "Success: Hello"
    * ```
    *
    * @category constructors
@@ -441,7 +437,7 @@ export const valueTags: {
  *
  * **Example** (Matching type tags)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * type Result =
@@ -456,11 +452,9 @@ export const valueTags: {
  *   Loading: () => "Loading..."
  * })
  *
- * console.log(formatResult({ _tag: "Success", data: "Hello World" }))
- * // Output: "Data: Hello World"
+ * formatResult({ _tag: "Success", data: "Hello World" }) // => "Data: Hello World"
  *
- * console.log(formatResult({ _tag: "Error", message: "Network failed" }))
- * // Output: "Error: Network failed"
+ * formatResult({ _tag: "Error", message: "Network failed" }) // => "Error: Network failed"
  *
  * // Create a matcher with inferred return type
  * const processResult = Match.typeTags<Result>()({
@@ -469,8 +463,7 @@ export const valueTags: {
  *   Loading: () => ({ type: "pending" })
  * })
  *
- * console.log(processResult({ _tag: "Loading" }))
- * // Output: { type: "pending" }
+ * processResult({ _tag: "Loading" }) // => { type: "pending" }
  * ```
  *
  * @category constructors
@@ -488,7 +481,7 @@ export const typeTags: {
    *
    * **Example** (Matching type tags)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Match } from "effect"
    *
    * type Result =
@@ -503,11 +496,9 @@ export const typeTags: {
    *   Loading: () => "Loading..."
    * })
    *
-   * console.log(formatResult({ _tag: "Success", data: "Hello World" }))
-   * // Output: "Data: Hello World"
+   * formatResult({ _tag: "Success", data: "Hello World" }) // => "Data: Hello World"
    *
-   * console.log(formatResult({ _tag: "Error", message: "Network failed" }))
-   * // Output: "Error: Network failed"
+   * formatResult({ _tag: "Error", message: "Network failed" }) // => "Error: Network failed"
    *
    * // Create a matcher with inferred return type
    * const processResult = Match.typeTags<Result>()({
@@ -516,8 +507,7 @@ export const typeTags: {
    *   Loading: () => ({ type: "pending" })
    * })
    *
-   * console.log(processResult({ _tag: "Loading" }))
-   * // Output: { type: "pending" }
+   * processResult({ _tag: "Loading" }) // => { type: "pending" }
    * ```
    *
    * @category constructors
@@ -543,7 +533,7 @@ export const typeTags: {
    *
    * **Example** (Matching type tags)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Match } from "effect"
    *
    * type Result =
@@ -558,11 +548,9 @@ export const typeTags: {
    *   Loading: () => "Loading..."
    * })
    *
-   * console.log(formatResult({ _tag: "Success", data: "Hello World" }))
-   * // Output: "Data: Hello World"
+   * formatResult({ _tag: "Success", data: "Hello World" }) // => "Data: Hello World"
    *
-   * console.log(formatResult({ _tag: "Error", message: "Network failed" }))
-   * // Output: "Error: Network failed"
+   * formatResult({ _tag: "Error", message: "Network failed" }) // => "Error: Network failed"
    *
    * // Create a matcher with inferred return type
    * const processResult = Match.typeTags<Result>()({
@@ -571,8 +559,7 @@ export const typeTags: {
    *   Loading: () => ({ type: "pending" })
    * })
    *
-   * console.log(processResult({ _tag: "Loading" }))
-   * // Output: { type: "pending" }
+   * processResult({ _tag: "Loading" }) // => { type: "pending" }
    * ```
    *
    * @category constructors
@@ -603,7 +590,7 @@ export const typeTags: {
  *
  * **Example** (Validating return type consistency)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const match = Match.type<{ a: number } | { b: string }>().pipe(
@@ -643,7 +630,7 @@ export const withReturnType: <Ret>() => <I, F, R, A, Pr, _>(
  *
  * **Example** (Matching with values and predicates)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * // Create a matcher for objects with an "age" property
@@ -659,14 +646,11 @@ export const withReturnType: <Ret>() => <I, F, R, A, Pr, _>(
  *   Match.orElse((user: { age: number }) => `${user.age} is too young`)
  * )
  *
- * console.log(match({ age: 20 }))
- * // Output: "Age: 20"
+ * match({ age: 20 }) // => "Age: 20"
  *
- * console.log(match({ age: 18 }))
- * // Output: "You can vote"
+ * match({ age: 18 }) // => "You can vote"
  *
- * console.log(match({ age: 4 }))
- * // Output: "4 is too young"
+ * match({ age: 4 }) // => "4 is too young"
  * ```
  *
  * @see {@link whenOr} for handling any one of several patterns with the same handler
@@ -674,7 +658,7 @@ export const withReturnType: <Ret>() => <I, F, R, A, Pr, _>(
  * @see {@link not} for handling inputs that do not match a pattern
  * @see {@link orElse} for providing a fallback when no pattern case matches
  *
- * @category Defining patterns
+ * @category defining patterns
  * @since 4.0.0
  */
 export const when: <
@@ -711,7 +695,7 @@ export const when: <
  *
  * **Example** (Matching one of several patterns)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * type ErrorType =
@@ -729,14 +713,12 @@ export const when: <
  *   Match.exhaustive
  * )
  *
- * console.log(handleError({ _tag: "NetworkError", message: "No connection" }))
- * // Output: "Retry the request"
+ * handleError({ _tag: "NetworkError", message: "No connection" }) // => "Retry the request"
  *
- * console.log(handleError({ _tag: "ValidationError", field: "email" }))
- * // Output: "Invalid field: email"
+ * handleError({ _tag: "ValidationError", field: "email" }) // => "Invalid field: email"
  * ```
  *
- * @category Defining patterns
+ * @category defining patterns
  * @since 4.0.0
  */
 export const whenOr: <
@@ -773,7 +755,7 @@ export const whenOr: <
  *
  * **Example** (Matching all provided patterns)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * type User = { readonly age: number; readonly role: "admin" | "user" }
@@ -787,14 +769,12 @@ export const whenOr: <
  *   Match.orElse(() => "Access denied")
  * )
  *
- * console.log(checkUser({ age: 20, role: "admin" }))
- * // Output: "Admin access granted"
+ * checkUser({ age: 20, role: "admin" }) // => "Admin access granted"
  *
- * console.log(checkUser({ age: 20, role: "user" }))
- * // Output: "Access denied"
+ * checkUser({ age: 20, role: "user" }) // => "Access denied"
  * ```
  *
- * @category Defining patterns
+ * @category defining patterns
  * @since 4.0.0
  */
 export const whenAnd: <
@@ -831,7 +811,7 @@ export const whenAnd: <
  *
  * **Example** (Matching on a discriminator field)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match, pipe } from "effect"
  *
  * const match = pipe(
@@ -845,12 +825,14 @@ export const whenAnd: <
  *   Match.discriminator("type")("C", (_) => `C(${_.c})`),
  *   Match.exhaustive
  * )
+ * match({ type: "A", a: "ok" }) // => "A or B: A"
+ * match({ type: "C", c: true }) // => "C(true)"
  * ```
  *
  * @see {@link discriminators} for defining several discriminator handlers at once
  * @see {@link discriminatorStartsWith} for matching string discriminator values by prefix
  *
- * @category Defining patterns
+ * @category defining patterns
  * @since 4.0.0
  */
 export const discriminator: <D extends string>(
@@ -884,7 +866,7 @@ export const discriminator: <D extends string>(
  *
  * **Example** (Matching discriminator prefixes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match, pipe } from "effect"
  *
  * const match = pipe(
@@ -894,14 +876,14 @@ export const discriminator: <D extends string>(
  *   Match.orElse((_) => 3 as const)
  * )
  *
- * console.log(match({ type: "A" })) // 1
- * console.log(match({ type: "B" })) // 2
- * console.log(match({ type: "A.A" })) // 1
+ * match({ type: "A" }) // => 1
+ * match({ type: "B" }) // => 2
+ * match({ type: "A.A" }) // => 1
  * ```
  *
  * @see {@link discriminator} for matching exact discriminator values
  *
- * @category Defining patterns
+ * @category defining patterns
  * @since 4.0.0
  */
 export const discriminatorStartsWith: <D extends string>(
@@ -940,7 +922,7 @@ export const discriminatorStartsWith: <D extends string>(
  *
  * **Example** (Mapping discriminator handlers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match, pipe } from "effect"
  *
  * const match = pipe(
@@ -957,12 +939,14 @@ export const discriminatorStartsWith: <D extends string>(
  *   }),
  *   Match.exhaustive
  * )
+ * match({ type: "A", a: "ok" }) // => "ok"
+ * match({ type: "B", b: 42 }) // => 42
  * ```
  *
  * @see {@link discriminator} for adding one discriminator case to a matcher pipeline
  * @see {@link discriminatorsExhaustive} for handling every discriminator value and finalizing the matcher
  *
- * @category Defining patterns
+ * @category defining patterns
  * @since 4.0.0
  */
 export const discriminators: <D extends string>(
@@ -1004,7 +988,7 @@ export const discriminators: <D extends string>(
  *
  * **Example** (Handling all discriminator cases)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match, pipe } from "effect"
  *
  * const match = pipe(
@@ -1020,11 +1004,12 @@ export const discriminators: <D extends string>(
  *     C: (c) => c.c
  *   })
  * )
+ * match({ type: "C", c: true }) // => true
  * ```
  *
  * @see {@link discriminators} for defining discriminator handlers without finalizing the matcher
  *
- * @category Defining patterns
+ * @category defining patterns
  * @since 4.0.0
  */
 export const discriminatorsExhaustive: <D extends string>(
@@ -1057,7 +1042,7 @@ export const discriminatorsExhaustive: <D extends string>(
  *
  * **Example** (Matching a discriminated union by tag)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * type Event =
@@ -1076,14 +1061,12 @@ export const discriminatorsExhaustive: <D extends string>(
  *   Match.exhaustive
  * )
  *
- * console.log(match({ _tag: "success", data: "Hello" }))
- * // Output: "Ok!"
+ * match({ _tag: "success", data: "Hello" }) // => "Ok!"
  *
- * console.log(match({ _tag: "error", error: new Error("Oops!") }))
- * // Output: "Error: Oops!"
+ * match({ _tag: "error", error: new Error("Oops!") }) // => "Error: Oops!"
  * ```
  *
- * @category Defining patterns
+ * @category defining patterns
  * @since 4.0.0
  */
 export const tag: <
@@ -1116,7 +1099,7 @@ export const tag: <
  *
  * **Example** (Matching tag prefixes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match, pipe } from "effect"
  *
  * const match = pipe(
@@ -1126,12 +1109,12 @@ export const tag: <
  *   Match.orElse((_) => 3 as const)
  * )
  *
- * console.log(match({ _tag: "A" })) // 1
- * console.log(match({ _tag: "B" })) // 2
- * console.log(match({ _tag: "A.A" })) // 1
+ * match({ _tag: "A" }) // => 1
+ * match({ _tag: "B" }) // => 2
+ * match({ _tag: "A.A" }) // => 1
  * ```
  *
- * @category Defining patterns
+ * @category defining patterns
  * @since 4.0.0
  */
 export const tagStartsWith: <
@@ -1166,7 +1149,7 @@ export const tagStartsWith: <
  *
  * **Example** (Mapping tag handlers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match, pipe } from "effect"
  *
  * const match = pipe(
@@ -1183,9 +1166,10 @@ export const tagStartsWith: <
  *   }),
  *   Match.exhaustive
  * )
+ * match({ _tag: "A", a: "ok" }) // => "ok"
  * ```
  *
- * @category Defining patterns
+ * @category defining patterns
  * @since 4.0.0
  */
 export const tags: <
@@ -1221,7 +1205,7 @@ export const tags: <
  *
  * **Example** (Handling all tag cases)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match, pipe } from "effect"
  *
  * const match = pipe(
@@ -1237,9 +1221,10 @@ export const tags: <
  *     C: (c) => c.c
  *   })
  * )
+ * match({ _tag: "B", b: 42 }) // => 42
  * ```
  *
- * @category Defining patterns
+ * @category defining patterns
  * @since 4.0.0
  */
 export const tagsExhaustive: <
@@ -1270,7 +1255,7 @@ export const tagsExhaustive: <
  *
  * **Example** (Ignoring a specific value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * // Create a matcher for string or number values
@@ -1281,16 +1266,14 @@ export const tagsExhaustive: <
  *   Match.orElse(() => "fallback")
  * )
  *
- * console.log(match("hello"))
- * // Output: "ok"
+ * match("hello") // => "ok"
  *
- * console.log(match("hi"))
- * // Output: "fallback"
+ * match("hi") // => "fallback"
  * ```
  *
  * @see {@link when} for adding a positive pattern case
  *
- * @category Defining patterns
+ * @category defining patterns
  * @since 4.0.0
  */
 export const not: <
@@ -1326,7 +1309,7 @@ export const not: <
  *
  * **Example** (Matching non-empty strings)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const processInput = Match.type<string>()
@@ -1335,19 +1318,16 @@ export const not: <
  *     Match.orElse(() => "Input cannot be empty")
  *   )
  *
- * console.log(processInput("hello"))
- * // Output: "Valid input: hello"
+ * processInput("hello") // => "Valid input: hello"
  *
- * console.log(processInput(""))
- * // Output: "Input cannot be empty"
+ * processInput("") // => "Input cannot be empty"
  *
- * console.log(processInput("   "))
- * // Output: "Valid input:    " (whitespace-only strings are considered non-empty)
+ * processInput("   ") // => "Valid input:    "
  * ```
  *
  * @see {@link string} for matching any string
  *
- * @category predicates
+ * @category guards
  * @since 4.0.0
  */
 export const nonEmptyString: SafeRefinement<string, never> = internal.nonEmptyString
@@ -1366,7 +1346,7 @@ export const nonEmptyString: SafeRefinement<string, never> = internal.nonEmptySt
  *
  * **Example** (Matching literal values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const handleStatus = Match.type<string | number>()
@@ -1377,23 +1357,18 @@ export const nonEmptyString: SafeRefinement<string, never> = internal.nonEmptySt
  *     Match.orElse((value) => `Unknown status: ${value}`)
  *   )
  *
- * console.log(handleStatus("success"))
- * // Output: "Operation successful"
+ * handleStatus("success") // => "Operation successful"
  *
- * console.log(handleStatus(200))
- * // Output: "Operation successful"
+ * handleStatus(200) // => "Operation successful"
  *
- * console.log(handleStatus("failed"))
- * // Output: "Operation failed"
+ * handleStatus("failed") // => "Operation failed"
  *
- * console.log(handleStatus(0))
- * // Output: "Falsy value"
+ * handleStatus(0) // => "Falsy value"
  *
- * console.log(handleStatus("pending"))
- * // Output: "Unknown status: pending"
+ * handleStatus("pending") // => "Unknown status: pending"
  * ```
  *
- * @category predicates
+ * @category guards
  * @since 4.0.0
  */
 export const is: <
@@ -1410,7 +1385,7 @@ export const is: <
  *
  * **Example** (Matching string values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const processValue = Match.type<string | number | boolean>().pipe(
@@ -1420,12 +1395,12 @@ export const is: <
  *   Match.exhaustive
  * )
  *
- * console.log(processValue("hello")) // "String: HELLO"
- * console.log(processValue(42)) // "Number: 84"
- * console.log(processValue(true)) // "Boolean: yes"
+ * processValue("hello") // => "String: HELLO"
+ * processValue(42) // => "Number: 84"
+ * processValue(true) // => "Boolean: yes"
  * ```
  *
- * @category predicates
+ * @category guards
  * @since 4.0.0
  */
 export const string: Predicate.Refinement<unknown, string> = Predicate.isString
@@ -1445,7 +1420,7 @@ export const string: Predicate.Refinement<unknown, string> = Predicate.isString
  *
  * **Example** (Matching number values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const categorizeNumber = Match.type<unknown>().pipe(
@@ -1458,15 +1433,15 @@ export const string: Predicate.Refinement<unknown, string> = Predicate.isString
  *   Match.orElse(() => "Not a number type")
  * )
  *
- * console.log(categorizeNumber(42)) // "Integer: 42"
- * console.log(categorizeNumber(3.14)) // "Float: 3.14"
- * console.log(categorizeNumber(NaN)) // "Not a number"
- * console.log(categorizeNumber("hello")) // "Not a number type"
+ * categorizeNumber(42) // => "Integer: 42"
+ * categorizeNumber(3.14) // => "Float: 3.14"
+ * categorizeNumber(NaN) // => "Not a number"
+ * categorizeNumber("hello") // => "Not a number type"
  * ```
  *
  * @see {@link bigint} for matching primitive bigint values
  *
- * @category predicates
+ * @category guards
  * @since 4.0.0
  */
 export const number: Predicate.Refinement<unknown, number> = Predicate.isNumber
@@ -1491,7 +1466,7 @@ export const number: Predicate.Refinement<unknown, number> = Predicate.isNumber
  *
  * **Example** (Matching any remaining value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const describeValue = Match.type<unknown>()
@@ -1503,23 +1478,19 @@ export const number: Predicate.Refinement<unknown, number> = Predicate.isNumber
  *     Match.exhaustive
  *   )
  *
- * console.log(describeValue("hello"))
- * // Output: "String: hello"
+ * describeValue("hello") // => "String: hello"
  *
- * console.log(describeValue(42))
- * // Output: "Number: 42"
+ * describeValue(42) // => "Number: 42"
  *
- * console.log(describeValue([1, 2, 3]))
- * // Output: "Other: object"
+ * describeValue([1, 2, 3]) // => "Other: object"
  *
- * console.log(describeValue(null))
- * // Output: "Other: object"
+ * describeValue(null) // => "Other: object"
  * ```
  *
  * @see {@link defined} for matching only non-nullish values
  * @see {@link orElse} for providing a fallback after earlier cases
  *
- * @category predicates
+ * @category guards
  * @since 4.0.0
  */
 export const any: SafeRefinement<unknown, any> = internal.any
@@ -1538,7 +1509,7 @@ export const any: SafeRefinement<unknown, any> = internal.any
  *
  * **Example** (Matching defined values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const processValue = Match.type<string | number | null | undefined>()
@@ -1547,28 +1518,22 @@ export const any: SafeRefinement<unknown, any> = internal.any
  *     Match.orElse(() => "Value is null or undefined")
  *   )
  *
- * console.log(processValue("hello"))
- * // Output: "Defined value: hello"
+ * processValue("hello") // => "Defined value: hello"
  *
- * console.log(processValue(42))
- * // Output: "Defined value: 42"
+ * processValue(42) // => "Defined value: 42"
  *
- * console.log(processValue(0))
- * // Output: "Defined value: 0"
+ * processValue(0) // => "Defined value: 0"
  *
- * console.log(processValue(""))
- * // Output: "Defined value: "
+ * processValue("") // => "Defined value: "
  *
- * console.log(processValue(null))
- * // Output: "Value is null or undefined"
+ * processValue(null) // => "Value is null or undefined"
  *
- * console.log(processValue(undefined))
- * // Output: "Value is null or undefined"
+ * processValue(undefined) // => "Value is null or undefined"
  * ```
  *
  * @see {@link any} for matching every value without excluding nullish inputs
  *
- * @category predicates
+ * @category guards
  * @since 4.0.0
  */
 export const defined: <A>(u: A) => u is A & {} = internal.defined
@@ -1587,7 +1552,7 @@ export const defined: <A>(u: A) => u is A & {} = internal.defined
  *
  * **Example** (Matching boolean values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const describeTruthiness = Match.type<unknown>().pipe(
@@ -1601,15 +1566,15 @@ export const defined: <A>(u: A) => u is A & {} = internal.defined
  *   Match.orElse(() => "Some other truthy value")
  * )
  *
- * console.log(describeTruthiness(true)) // "Definitely true"
- * console.log(describeTruthiness(false)) // "Definitely false"
- * console.log(describeTruthiness(0)) // "Falsy number"
- * console.log(describeTruthiness(1)) // "Some other truthy value"
+ * describeTruthiness(true) // => "Definitely true"
+ * describeTruthiness(false) // => "Definitely false"
+ * describeTruthiness(0) // => "Falsy number"
+ * describeTruthiness(1) // => "Some other truthy value"
  * ```
  *
  * @see {@link is} for matching specific literal boolean values
  *
- * @category predicates
+ * @category guards
  * @since 4.0.0
  */
 export const boolean: Predicate.Refinement<unknown, boolean> = Predicate.isBoolean
@@ -1631,7 +1596,7 @@ export {
    * @see {@link defined} for matching non-nullish values
    * @see {@link is} for matching literal values
    *
-   * @category predicates
+   * @category guards
    * @since 4.0.0
    */
   _undefined as undefined
@@ -1654,7 +1619,7 @@ export {
    * @see {@link defined} for matching non-nullish values
    * @see {@link is} for matching literal values
    *
-   * @category predicates
+   * @category guards
    * @since 4.0.0
    */
   _null as null
@@ -1674,7 +1639,7 @@ export {
  *
  * **Example** (Matching bigint values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const processLargeNumber = Match.type<unknown>().pipe(
@@ -1688,15 +1653,15 @@ export {
  *   Match.orElse(() => "Not a numeric type")
  * )
  *
- * console.log(processLargeNumber(123n)) // "BigInt: 123"
- * console.log(processLargeNumber(9007199254740992n)) // "Large integer: 9007199254740992"
- * console.log(processLargeNumber(123)) // "Regular number: 123"
- * console.log(processLargeNumber("123")) // "Not a numeric type"
+ * processLargeNumber(123n) // => "BigInt: 123"
+ * processLargeNumber(9007199254740992n) // => "Large integer: 9007199254740992"
+ * processLargeNumber(123) // => "Regular number: 123"
+ * processLargeNumber("123") // => "Not a numeric type"
  * ```
  *
  * @see {@link number} for matching primitive number values
  *
- * @category predicates
+ * @category guards
  * @since 4.0.0
  */
 export const bigint: Predicate.Refinement<unknown, bigint> = Predicate.isBigInt
@@ -1712,7 +1677,7 @@ export const bigint: Predicate.Refinement<unknown, bigint> = Predicate.isBigInt
  *
  * **Example** (Matching symbol values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const mySymbol = Symbol("my-symbol")
@@ -1729,12 +1694,12 @@ export const bigint: Predicate.Refinement<unknown, bigint> = Predicate.isBigInt
  *   Match.orElse(() => "Not a symbol")
  * )
  *
- * console.log(handleSymbol(mySymbol)) // "Symbol with description: my-symbol"
- * console.log(handleSymbol(Symbol())) // "Symbol without description"
- * console.log(handleSymbol("string")) // "Not a symbol"
+ * handleSymbol(mySymbol) // => "Symbol with description: my-symbol"
+ * handleSymbol(Symbol()) // => "Symbol without description"
+ * handleSymbol("string") // => "Not a symbol"
  * ```
  *
- * @category predicates
+ * @category guards
  * @since 4.0.0
  */
 export const symbol: Predicate.Refinement<unknown, symbol> = Predicate.isSymbol
@@ -1754,7 +1719,7 @@ export const symbol: Predicate.Refinement<unknown, symbol> = Predicate.isSymbol
  *
  * **Example** (Matching Date instances)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const processDateValue = Match.type<unknown>().pipe(
@@ -1768,15 +1733,15 @@ export const symbol: Predicate.Refinement<unknown, symbol> = Predicate.isSymbol
  *   Match.orElse(() => "Not a date-related value")
  * )
  *
- * console.log(processDateValue(new Date("2024-01-01"))) // "Date: 2024-01-01"
- * console.log(processDateValue(new Date("invalid"))) // "Invalid date"
- * console.log(processDateValue("2024-01-01")) // "Date string: 2024-01-01"
- * console.log(processDateValue(1704067200000)) // "Not a date-related value"
+ * processDateValue(new Date("2024-01-01")) // => "Date: 2024-01-01"
+ * processDateValue(new Date("invalid")) // => "Invalid date"
+ * processDateValue("2024-01-01") // => "Date string: 2024-01-01"
+ * processDateValue(1704067200000) // => "Not a date-related value"
  * ```
  *
  * @see {@link instanceOf} for matching instances of any constructor
  *
- * @category predicates
+ * @category guards
  * @since 4.0.0
  */
 export const date: Predicate.Refinement<unknown, Date> = Predicate.isDate
@@ -1797,7 +1762,7 @@ export const date: Predicate.Refinement<unknown, Date> = Predicate.isDate
  *
  * **Example** (Matching record objects)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const analyzeValue = Match.type<unknown>().pipe(
@@ -1813,15 +1778,15 @@ export const date: Predicate.Refinement<unknown, Date> = Predicate.isDate
  *   Match.orElse(() => "Not an object")
  * )
  *
- * console.log(analyzeValue({ name: "Alice", age: 30 })) // "Object with 2 properties: [name, age]"
- * console.log(analyzeValue([1, 2, 3])) // "Array with 3 items"
- * console.log(analyzeValue(null)) // "Not an object"
- * console.log(analyzeValue("hello")) // "Not an object"
+ * analyzeValue({ name: "Alice", age: 30 }) // => "Object with 2 properties: [name, age]"
+ * analyzeValue([1, 2, 3]) // => "Array with 3 items"
+ * analyzeValue(null) // => "Not an object"
+ * analyzeValue("hello") // => "Not an object"
  * ```
  *
  * @see {@link instanceOf} for matching a specific constructor
  *
- * @category predicates
+ * @category guards
  * @since 4.0.0
  */
 export const record: Predicate.Refinement<unknown, { [x: PropertyKey]: unknown }> = Predicate.isObject
@@ -1841,7 +1806,7 @@ export const record: Predicate.Refinement<unknown, { [x: PropertyKey]: unknown }
  *
  * **Example** (Matching class instances)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * class CustomError extends Error {
@@ -1871,16 +1836,16 @@ export const record: Predicate.Refinement<unknown, { [x: PropertyKey]: unknown }
  *     Match.orElse((value) => `Other: ${typeof value}`)
  *   )
  *
- * console.log(handleValue(new CustomError("Failed", 404))) // "Custom error: Failed (code: 404)"
- * console.log(handleValue(new Error("Generic error"))) // "Standard error: Generic error"
- * console.log(handleValue([1, 2, 3])) // "Array with 3 items"
- * console.log(handleValue(new Map([["count", 1]]))) // "Map with 1 entries"
+ * handleValue(new CustomError("Failed", 404)) // => "Custom error: Failed (code: 404)"
+ * handleValue(new Error("Generic error")) // => "Standard error: Generic error"
+ * handleValue([1, 2, 3]) // => "Array with 3 items"
+ * handleValue(new Map([["count", 1]])) // => "Map with 1 entries"
  * ```
  *
  * @see {@link instanceOfUnsafe} for constructor matching without the same type-safety guarantee
  * @see {@link record} for matching broad non-null, non-array objects
  *
- * @category predicates
+ * @category guards
  * @since 4.0.0
  */
 export const instanceOf: <A extends abstract new(...args: any) => any>(
@@ -1902,7 +1867,7 @@ export const instanceOf: <A extends abstract new(...args: any) => any>(
  *
  * **Example** (Matching class instances unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * class CustomError extends Error {
@@ -1920,11 +1885,12 @@ export const instanceOf: <A extends abstract new(...args: any) => any>(
  *   }),
  *   Match.orElse(() => "Not a CustomError")
  * )
+ * handleError(new CustomError("failed", 500)) // => "Custom error 500: failed"
  * ```
  *
  * @see {@link instanceOf} for type-safe constructor matching
  *
- * @category predicates
+ * @category guards
  * @since 4.0.0
  */
 export const instanceOfUnsafe: <A extends abstract new(...args: any) => any>(
@@ -1947,7 +1913,7 @@ export const instanceOfUnsafe: <A extends abstract new(...args: any) => any>(
  *
  * **Example** (Providing a default value when no patterns match)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * // Create a matcher for string or number values
@@ -1958,11 +1924,9 @@ export const instanceOfUnsafe: <A extends abstract new(...args: any) => any>(
  *   Match.orElse(() => "fallback")
  * )
  *
- * console.log(match("a"))
- * // Output: "ok"
+ * match("a") // => "ok"
  *
- * console.log(match("b"))
- * // Output: "fallback"
+ * match("b") // => "fallback"
  * ```
  *
  * @see {@link option} for finalizing unmatched input as `Option.none`
@@ -1999,7 +1963,7 @@ export const orElse: <RA, Ret, F extends (_: RA) => Ret>(
  *
  * **Example** (Throwing on unmatched input)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const strictMatcher = Match.type<"a" | "b">().pipe(
@@ -2009,8 +1973,8 @@ export const orElse: <RA, Ret, F extends (_: RA) => Ret>(
  *   Match.orElseAbsurd
  * )
  *
- * console.log(strictMatcher("a")) // "Found A"
- * console.log(strictMatcher("b")) // "Found B"
+ * strictMatcher("a") // => "Found A"
+ * strictMatcher("b") // => "Found B"
  *
  * // This would throw an error at runtime:
  * // strictMatcher("c" as any) // throws
@@ -2043,7 +2007,7 @@ export const orElseAbsurd: <I, R, RA, A, Pr, Ret>(
  *
  * **Example** (Extracting a user role with `Match.result`)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * type User = { readonly role: "admin" | "editor" | "viewer" }
@@ -2055,11 +2019,9 @@ export const orElseAbsurd: <I, R, RA, A, Pr, Ret>(
  *   Match.result // Wrap the result in an Result
  * )
  *
- * console.log(getRole({ role: "admin" }))
- * // Output: { _id: 'Result', _tag: 'Ok', ok: 'Has full access' }
+ * getRole({ role: "admin" })._tag // => "Success"
  *
- * console.log(getRole({ role: "viewer" }))
- * // Output: { _id: 'Result', _tag: 'Err', err: { role: 'viewer' } }
+ * getRole({ role: "viewer" })._tag // => "Failure"
  * ```
  *
  * @category completion
@@ -2089,7 +2051,7 @@ export const result: <I, F, R, A, Pr, Ret>(
  *
  * **Example** (Extracting a user role with `Match.option`)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * type User = { readonly role: "admin" | "editor" | "viewer" }
@@ -2101,11 +2063,9 @@ export const result: <I, F, R, A, Pr, Ret>(
  *   Match.option // Wrap the result in an Option
  * )
  *
- * console.log(getRole({ role: "admin" }))
- * // Output: { _id: 'Option', _tag: 'Some', value: 'Has full access' }
+ * getRole({ role: "admin" })._tag // => "Some"
  *
- * console.log(getRole({ role: "viewer" }))
- * // Output: { _id: 'Option', _tag: 'None' }
+ * getRole({ role: "viewer" })._tag // => "None"
  * ```
  *
  * @see {@link result} for preserving unmatched input as a `Result` failure
@@ -2133,7 +2093,7 @@ export const option: <I, F, R, A, Pr, Ret>(
  *
  * **Example** (Ensuring all cases are covered)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * // Create a matcher for string or number values
@@ -2167,7 +2127,7 @@ const SafeRefinementId = "~effect/match/Match/SafeRefinement"
  *
  * **Example** (Using safe refinements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * // Built-in safe refinements
@@ -2178,10 +2138,10 @@ const SafeRefinementId = "~effect/match/Match/SafeRefinement"
  *   Match.orElse(() => "Undefined or null")
  * )
  *
- * console.log(processValue("hello")) // "HELLO"
- * console.log(processValue(21)) // 42
- * console.log(processValue(true)) // "Defined: true"
- * console.log(processValue(null)) // "Undefined or null"
+ * processValue("hello") // => "HELLO"
+ * processValue(21) // => 42
+ * processValue(true) // => "Defined: true"
+ * processValue(null) // => "Undefined or null"
  * ```
  *
  * @category models
@@ -2218,7 +2178,7 @@ export declare namespace Types {
    *
    * **Example** (Computing matched types)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import type { Match } from "effect"
    *
    * // WhenMatch computes the narrowed type after pattern matching
@@ -2235,7 +2195,7 @@ export declare namespace Types {
    * // Result: { type: "user"; name: string }
    * ```
    *
-   * @category types
+   * @category utility types
    * @since 4.0.0
    */
   export type WhenMatch<R, P> =
@@ -2263,7 +2223,7 @@ export declare namespace Types {
    *
    * **Example** (Computing unmatched types)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import type { Match } from "effect"
    *
    * // NotMatch computes what remains after exclusion
@@ -2277,7 +2237,7 @@ export declare namespace Types {
    * // Result: "b" | "c"
    * ```
    *
-   * @category types
+   * @category utility types
    * @since 4.0.0
    */
   export type NotMatch<R, P> = Exclude<R, ExtractMatch<R, PForNotMatch<P>>>
@@ -2296,7 +2256,7 @@ export declare namespace Types {
    *
    * **Example** (Resolving match patterns)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import type { Match } from "effect"
    *
    * // PForMatch resolves patterns to their matched types
@@ -2307,7 +2267,7 @@ export declare namespace Types {
    * // Result: { name: string }
    * ```
    *
-   * @category types
+   * @category utility types
    * @since 4.0.0
    */
   export type PForMatch<P> = [ResolvePred<P>] extends [infer X] ? X
@@ -2324,7 +2284,7 @@ export declare namespace Types {
    *
    * **Example** (Computing excluded patterns)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import type { Match } from "effect"
    *
    * // PForExclude computes what to exclude from type operations
@@ -2335,7 +2295,7 @@ export declare namespace Types {
    * // Used internally to filter out admin objects
    * ```
    *
-   * @category types
+   * @category utility types
    * @since 4.0.0
    */
   export type PForExclude<P> = [SafeRefinementR<ToSafeRefinement<P>>] extends [infer X] ? X
@@ -2389,7 +2349,7 @@ export declare namespace Types {
    *
    * **Example** (Describing complex object patterns)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Match } from "effect"
    *
    * // PatternBase enables complex object patterns
@@ -2401,7 +2361,7 @@ export declare namespace Types {
    * // Allows: { name?: string | Predicate, age?: number | Predicate, ... }
    *
    * // Example usage:
-   * Match.value({ name: "Alice", age: 30, role: "admin" as const }).pipe(
+   * const result = Match.value({ name: "Alice", age: 30, role: "admin" as const }).pipe(
    *   Match.when(
    *     { age: (n: number) => n >= 18, role: "admin" },
    *     (user: { name: string; age: number; role: "admin" }) =>
@@ -2409,9 +2369,10 @@ export declare namespace Types {
    *   ),
    *   Match.orElse(() => "Not an adult admin")
    * )
+   * result // => "Admin: Alice"
    * ```
    *
-   * @category types
+   * @category utility types
    * @since 4.0.0
    */
   export type PatternBase<A> = A extends ReadonlyArray<infer _T> ? ReadonlyArray<any> | PatternPrimitive<A>
@@ -2429,7 +2390,7 @@ export declare namespace Types {
    * literal values, and safe refinements. These are the atomic patterns that
    * can be composed into more complex matching logic.
    *
-   * @category types
+   * @category utility types
    * @since 4.0.0
    */
   export type PatternPrimitive<A> = PredicateA<A> | A | SafeRefinement<any>
@@ -2445,18 +2406,19 @@ export declare namespace Types {
    *
    * **Example** (Tracking excluded types)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Match } from "effect"
    *
    * // Without is used internally when you write:
-   * Match.type<string | number | boolean>().pipe(
+   * const match = Match.type<string | number | boolean>().pipe(
    *   Match.not(Match.string, (value) => `not string: ${value}`),
    *   // At this point, type system uses Without<string> to track exclusion
    *   Match.orElse(() => "was a string")
    * )
+   * match(42) // => "not string: 42"
    * ```
    *
-   * @category types
+   * @category utility types
    * @since 4.0.0
    */
   export interface Without<out X> {
@@ -2475,18 +2437,19 @@ export declare namespace Types {
    *
    * **Example** (Tracking included types)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Match } from "effect"
    *
    * // Only is used internally when you write:
-   * Match.type<string | number | boolean>().pipe(
+   * const match = Match.type<string | number | boolean>().pipe(
    *   Match.when(Match.string, (s) => `string: ${s}`),
    *   // At this point, type system uses Only<string> for the match
    *   Match.orElse((value) => `not string: ${value}`)
    * )
+   * match("ok") // => "string: ok"
    * ```
    *
-   * @category types
+   * @category utility types
    * @since 4.0.0
    */
   export interface Only<out X> {
@@ -2505,19 +2468,20 @@ export declare namespace Types {
    *
    * **Example** (Accumulating excluded types)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Match } from "effect"
    *
    * // AddWithout is used when combining multiple exclusions:
-   * Match.type<string | number | boolean | null>().pipe(
+   * const match = Match.type<string | number | boolean | null>().pipe(
    *   Match.not(Match.string, () => "not string"),
    *   Match.not(Match.number, () => "not number"),
    *   // Type system uses AddWithout to combine exclusions
    *   Match.orElse(() => "was string or number")
    * )
+   * match(true) // => "not string"
    * ```
    *
-   * @category types
+   * @category utility types
    * @since 4.0.0
    */
   export type AddWithout<A, X> = [A] extends [Without<infer WX>] ? Without<X | WX>
@@ -2535,18 +2499,19 @@ export declare namespace Types {
    *
    * **Example** (Refining included types)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Match } from "effect"
    *
    * // AddOnly is used when refining positive matches:
-   * Match.type<{ type: "user" | "admin"; name: string }>().pipe(
+   * const match = Match.type<{ type: "user" | "admin"; name: string }>().pipe(
    *   Match.when({ type: "admin" }, (admin) => admin.name),
    *   // Type system uses AddOnly to refine the constraint
    *   Match.orElse(() => "not admin")
    * )
+   * match({ type: "admin", name: "Alice" }) // => "Alice"
    * ```
    *
-   * @category types
+   * @category utility types
    * @since 4.0.0
    */
   export type AddOnly<A, X> = [A] extends [Without<infer WX>] ? [X] extends [WX] ? never
@@ -2566,7 +2531,7 @@ export declare namespace Types {
    *
    * **Example** (Applying accumulated filters)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import type { Match } from "effect"
    *
    * // ApplyFilters computes the final narrowed type:
@@ -2583,7 +2548,7 @@ export declare namespace Types {
    * // Result: number | boolean
    * ```
    *
-   * @category types
+   * @category utility types
    * @since 4.0.0
    */
   export type ApplyFilters<I, A> = A extends Only<infer X> ? X
@@ -2601,7 +2566,7 @@ export declare namespace Types {
    *
    * **Example** (Extracting discriminator tags)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import type { Match } from "effect"
    *
    * type Events =
@@ -2620,7 +2585,7 @@ export declare namespace Types {
    * // Result: "user" | "admin"
    * ```
    *
-   * @category types
+   * @category utility types
    * @since 4.0.0
    */
   export type Tags<D extends string, P> = P extends Record<D, infer X> ? X : never
@@ -2636,7 +2601,7 @@ export declare namespace Types {
    *
    * **Example** (Converting arrays to intersections)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import type { Match } from "effect"
    *
    * type Combined = Match.Types.ArrayToIntersection<[
@@ -2652,7 +2617,7 @@ export declare namespace Types {
    * // for advanced pattern matching scenarios
    * ```
    *
-   * @category types
+   * @category utility types
    * @since 4.0.0
    */
   export type ArrayToIntersection<A extends ReadonlyArray<any>> = T.UnionToIntersection<
@@ -2670,7 +2635,7 @@ export declare namespace Types {
    *
    * **Example** (Extracting matched types)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Match } from "effect"
    *
    * type StringExtract = Match.Types.ExtractMatch<
@@ -2690,7 +2655,7 @@ export declare namespace Types {
    * //                      ^^^ s is correctly typed as string
    * ```
    *
-   * @category types
+   * @category utility types
    * @since 4.0.0
    */
   export type ExtractMatch<I, P> = [ExtractAndNarrow<I, P>] extends [infer EI] ? EI