effect 4.0.0-beta.99 → 4.0.0-rc.108

package/dist/Match.d.ts

@@ -15,7 +15,7 @@ declare const TypeId = "~effect/match/Match/Matcher";
  *
  * **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
@@ -32,8 +32,7 @@ declare const TypeId = "~effect/match/Match/Matcher";
  *   Match.exhaustive
  * )
  *
- * console.log(result)
- * // Output: "string: some input"
+ * result // => "string: some input"
  * ```
  *
  * @category models
@@ -52,7 +51,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
@@ -62,8 +61,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
@@ -92,7 +91,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 }
@@ -104,7 +103,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
@@ -154,7 +153,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
@@ -164,8 +163,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
@@ -187,7 +186,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
@@ -197,8 +196,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
@@ -225,7 +224,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
@@ -241,11 +240,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.
@@ -273,7 +270,7 @@ export declare const type: <I>() => Matcher<I, Types.Without<never>, I, never, n
  *
  * **Example** (Matching an Object by Property)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const input = { name: "John", age: 30 }
@@ -289,8 +286,7 @@ export declare const type: <I>() => Matcher<I, Types.Without<never>, I, never, n
  *   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.
@@ -310,7 +306,7 @@ export declare const value: <const I>(i: I) => Matcher<I, Types.Without<never>,
  *
  * **Example** (Matching value tags)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * type Status = { readonly _tag: "Success"; readonly data: string }
@@ -322,7 +318,7 @@ export declare const value: <const I>(i: I) => Matcher<I, Types.Without<never>,
  *   Success: (result) => `Success: ${result.data}`
  * })
  *
- * console.log(message) // "Success: Hello"
+ * message // => "Success: Hello"
  * ```
  *
  * @category constructors
@@ -340,7 +336,7 @@ export declare const valueTags: {
      *
      * **Example** (Matching value tags)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Match } from "effect"
      *
      * type Status = { readonly _tag: "Success"; readonly data: string }
@@ -352,7 +348,7 @@ export declare const valueTags: {
      *   Success: (result) => `Success: ${result.data}`
      * })
      *
-     * console.log(message) // "Success: Hello"
+     * message // => "Success: Hello"
      * ```
      *
      * @category constructors
@@ -376,7 +372,7 @@ export declare const valueTags: {
      *
      * **Example** (Matching value tags)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Match } from "effect"
      *
      * type Status = { readonly _tag: "Success"; readonly data: string }
@@ -388,7 +384,7 @@ export declare const valueTags: {
      *   Success: (result) => `Success: ${result.data}`
      * })
      *
-     * console.log(message) // "Success: Hello"
+     * message // => "Success: Hello"
      * ```
      *
      * @category constructors
@@ -413,7 +409,7 @@ export declare const valueTags: {
  *
  * **Example** (Matching type tags)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * type Result =
@@ -428,11 +424,9 @@ export declare 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>()({
@@ -441,8 +435,7 @@ export declare const valueTags: {
  *   Loading: () => ({ type: "pending" })
  * })
  *
- * console.log(processResult({ _tag: "Loading" }))
- * // Output: { type: "pending" }
+ * processResult({ _tag: "Loading" }) // => { type: "pending" }
  * ```
  *
  * @category constructors
@@ -460,7 +453,7 @@ export declare const typeTags: {
      *
      * **Example** (Matching type tags)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Match } from "effect"
      *
      * type Result =
@@ -475,11 +468,9 @@ export declare 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>()({
@@ -488,8 +479,7 @@ export declare const typeTags: {
      *   Loading: () => ({ type: "pending" })
      * })
      *
-     * console.log(processResult({ _tag: "Loading" }))
-     * // Output: { type: "pending" }
+     * processResult({ _tag: "Loading" }) // => { type: "pending" }
      * ```
      *
      * @category constructors
@@ -513,7 +503,7 @@ export declare const typeTags: {
      *
      * **Example** (Matching type tags)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Match } from "effect"
      *
      * type Result =
@@ -528,11 +518,9 @@ export declare 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>()({
@@ -541,8 +529,7 @@ export declare const typeTags: {
      *   Loading: () => ({ type: "pending" })
      * })
      *
-     * console.log(processResult({ _tag: "Loading" }))
-     * // Output: { type: "pending" }
+     * processResult({ _tag: "Loading" }) // => { type: "pending" }
      * ```
      *
      * @category constructors
@@ -570,7 +557,7 @@ export declare 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(
@@ -606,7 +593,7 @@ export declare const withReturnType: <Ret>() => <I, F, R, A, Pr, _>(self: Matche
  *
  * **Example** (Matching with values and predicates)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * // Create a matcher for objects with an "age" property
@@ -622,14 +609,11 @@ export declare const withReturnType: <Ret>() => <I, F, R, A, Pr, _>(self: Matche
  *   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
@@ -637,7 +621,7 @@ export declare const withReturnType: <Ret>() => <I, F, R, A, Pr, _>(self: Matche
  * @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 declare const when: <R, const P extends Types.PatternPrimitive<R> | Types.PatternBase<R>, Ret, Fn extends (_: Types.WhenMatch<R, P>) => Ret>(pattern: P, f: Fn) => <I, F, A, Pr>(self: Matcher<I, F, R, A, Pr, Ret>) => Matcher<I, Types.AddWithout<F, Types.PForExclude<P>>, Types.ApplyFilters<I, Types.AddWithout<F, Types.PForExclude<P>>>, A | ReturnType<Fn>, Pr, Ret>;
@@ -656,7 +640,7 @@ export declare const when: <R, const P extends Types.PatternPrimitive<R> | Types
  *
  * **Example** (Matching one of several patterns)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * type ErrorType =
@@ -674,14 +658,12 @@ export declare const when: <R, const P extends Types.PatternPrimitive<R> | Types
  *   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 declare const whenOr: <R, const P extends ReadonlyArray<Types.PatternPrimitive<R> | Types.PatternBase<R>>, Ret, Fn extends (_: Types.WhenMatch<R, P[number]>) => Ret>(...args: [...patterns: P, f: Fn]) => <I, F, A, Pr>(self: Matcher<I, F, R, A, Pr, Ret>) => Matcher<I, Types.AddWithout<F, Types.PForExclude<P[number]>>, Types.ApplyFilters<I, Types.AddWithout<F, Types.PForExclude<P[number]>>>, A | ReturnType<Fn>, Pr, Ret>;
@@ -701,7 +683,7 @@ export declare const whenOr: <R, const P extends ReadonlyArray<Types.PatternPrim
  *
  * **Example** (Matching all provided patterns)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * type User = { readonly age: number; readonly role: "admin" | "user" }
@@ -715,14 +697,12 @@ export declare const whenOr: <R, const P extends ReadonlyArray<Types.PatternPrim
  *   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 declare const whenAnd: <R, const P extends ReadonlyArray<Types.PatternPrimitive<R> | Types.PatternBase<R>>, Ret, Fn extends (_: Types.WhenMatch<R, T.UnionToIntersection<P[number]>>) => Ret>(...args: [...patterns: P, f: Fn]) => <I, F, A, Pr>(self: Matcher<I, F, R, A, Pr, Ret>) => Matcher<I, Types.AddWithout<F, Types.PForExclude<T.UnionToIntersection<P[number]>>>, Types.ApplyFilters<I, Types.AddWithout<F, Types.PForExclude<T.UnionToIntersection<P[number]>>>>, A | ReturnType<Fn>, Pr>;
@@ -743,7 +723,7 @@ export declare const whenAnd: <R, const P extends ReadonlyArray<Types.PatternPri
  *
  * **Example** (Matching on a discriminator field)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match, pipe } from "effect"
  *
  * const match = pipe(
@@ -757,12 +737,14 @@ export declare const whenAnd: <R, const P extends ReadonlyArray<Types.PatternPri
  *   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 declare const discriminator: <D extends string>(field: D) => <R, P extends Types.Tags<D, R> & string, Ret, Fn extends (_: Extract<R, Record<D, P>>) => Ret>(...pattern: [first: P, ...values: Array<P>, f: Fn]) => <I, F, A, Pr>(self: Matcher<I, F, R, A, Pr, Ret>) => Matcher<I, Types.AddWithout<F, Extract<R, Record<D, P>>>, Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<D, P>>>>, A | ReturnType<Fn>, Pr, Ret>;
@@ -782,7 +764,7 @@ export declare const discriminator: <D extends string>(field: D) => <R, P extend
  *
  * **Example** (Matching discriminator prefixes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match, pipe } from "effect"
  *
  * const match = pipe(
@@ -792,14 +774,14 @@ export declare const discriminator: <D extends string>(field: D) => <R, P extend
  *   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 declare const discriminatorStartsWith: <D extends string>(field: D) => <R, P extends string, Ret, Fn extends (_: Extract<R, Record<D, `${P}${string}`>>) => Ret>(pattern: P, f: Fn) => <I, F, A, Pr>(self: Matcher<I, F, R, A, Pr, Ret>) => Matcher<I, Types.AddWithout<F, Extract<R, Record<D, `${P}${string}`>>>, Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<D, `${P}${string}`>>>>, A | ReturnType<Fn>, Pr, Ret>;
@@ -823,7 +805,7 @@ export declare const discriminatorStartsWith: <D extends string>(field: D) => <R
  *
  * **Example** (Mapping discriminator handlers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match, pipe } from "effect"
  *
  * const match = pipe(
@@ -840,12 +822,14 @@ export declare const discriminatorStartsWith: <D extends string>(field: D) => <R
  *   }),
  *   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 declare const discriminators: <D extends string>(field: D) => <R, Ret, P extends {
@@ -871,7 +855,7 @@ export declare const discriminators: <D extends string>(field: D) => <R, Ret, P
  *
  * **Example** (Handling all discriminator cases)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match, pipe } from "effect"
  *
  * const match = pipe(
@@ -887,11 +871,12 @@ export declare const discriminators: <D extends string>(field: D) => <R, Ret, P
  *     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 declare const discriminatorsExhaustive: <D extends string>(field: D) => <R, Ret, P extends {
@@ -914,7 +899,7 @@ export declare const discriminatorsExhaustive: <D extends string>(field: D) => <
  *
  * **Example** (Matching a discriminated union by tag)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * type Event =
@@ -933,14 +918,12 @@ export declare const discriminatorsExhaustive: <D extends string>(field: D) => <
  *   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 declare const tag: <R, P extends Types.Tags<"_tag", R> & string, Ret, Fn extends (_: Extract<R, Record<"_tag", P>>) => Ret>(...pattern: [first: P, ...values: Array<P>, f: Fn]) => <I, F, A, Pr>(self: Matcher<I, F, R, A, Pr, Ret>) => Matcher<I, Types.AddWithout<F, Extract<R, Record<"_tag", P>>>, Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<"_tag", P>>>>, ReturnType<Fn> | A, Pr, Ret>;
@@ -956,7 +939,7 @@ export declare const tag: <R, P extends Types.Tags<"_tag", R> & string, Ret, Fn
  *
  * **Example** (Matching tag prefixes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match, pipe } from "effect"
  *
  * const match = pipe(
@@ -966,12 +949,12 @@ export declare const tag: <R, P extends Types.Tags<"_tag", R> & string, Ret, Fn
  *   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 declare const tagStartsWith: <R, P extends string, Ret, Fn extends (_: Extract<R, Record<"_tag", `${P}${string}`>>) => Ret>(pattern: P, f: Fn) => <I, F, A, Pr>(self: Matcher<I, F, R, A, Pr, Ret>) => Matcher<I, Types.AddWithout<F, Extract<R, Record<"_tag", `${P}${string}`>>>, Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<"_tag", `${P}${string}`>>>>, ReturnType<Fn> | A, Pr, Ret>;
@@ -988,7 +971,7 @@ export declare const tagStartsWith: <R, P extends string, Ret, Fn extends (_: Ex
  *
  * **Example** (Mapping tag handlers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match, pipe } from "effect"
  *
  * const match = pipe(
@@ -1005,9 +988,10 @@ export declare const tagStartsWith: <R, P extends string, Ret, Fn extends (_: Ex
  *   }),
  *   Match.exhaustive
  * )
+ * match({ _tag: "A", a: "ok" }) // => "ok"
  * ```
  *
- * @category Defining patterns
+ * @category defining patterns
  * @since 4.0.0
  */
 export declare const tags: <R, Ret, P extends {
@@ -1029,7 +1013,7 @@ export declare const tags: <R, Ret, P extends {
  *
  * **Example** (Handling all tag cases)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match, pipe } from "effect"
  *
  * const match = pipe(
@@ -1045,9 +1029,10 @@ export declare const tags: <R, Ret, P extends {
  *     C: (c) => c.c
  *   })
  * )
+ * match({ _tag: "B", b: 42 }) // => 42
  * ```
  *
- * @category Defining patterns
+ * @category defining patterns
  * @since 4.0.0
  */
 export declare const tagsExhaustive: <R, Ret, P extends {
@@ -1070,7 +1055,7 @@ export declare const tagsExhaustive: <R, Ret, P extends {
  *
  * **Example** (Ignoring a specific value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * // Create a matcher for string or number values
@@ -1081,16 +1066,14 @@ export declare const tagsExhaustive: <R, Ret, P extends {
  *   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 declare const not: <R, const P extends Types.PatternPrimitive<R> | Types.PatternBase<R>, Ret, Fn extends (_: Types.NotMatch<R, P>) => Ret>(pattern: P, f: Fn) => <I, F, A, Pr>(self: Matcher<I, F, R, A, Pr, Ret>) => Matcher<I, Types.AddOnly<F, Types.WhenMatch<R, P>>, Types.ApplyFilters<I, Types.AddOnly<F, Types.WhenMatch<R, P>>>, A | ReturnType<Fn>, Pr, Ret>;
@@ -1108,7 +1091,7 @@ export declare const not: <R, const P extends Types.PatternPrimitive<R> | Types.
  *
  * **Example** (Matching non-empty strings)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const processInput = Match.type<string>()
@@ -1117,19 +1100,16 @@ export declare const not: <R, const P extends Types.PatternPrimitive<R> | Types.
  *     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 declare const nonEmptyString: SafeRefinement<string, never>;
@@ -1147,7 +1127,7 @@ export declare const nonEmptyString: SafeRefinement<string, never>;
  *
  * **Example** (Matching literal values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const handleStatus = Match.type<string | number>()
@@ -1158,23 +1138,18 @@ export declare const nonEmptyString: SafeRefinement<string, never>;
  *     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 declare const is: <Literals extends ReadonlyArray<string | number | bigint | boolean | null>>(...literals: Literals) => SafeRefinement<Literals[number]>;
@@ -1188,7 +1163,7 @@ export declare const is: <Literals extends ReadonlyArray<string | number | bigin
  *
  * **Example** (Matching string values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const processValue = Match.type<string | number | boolean>().pipe(
@@ -1198,12 +1173,12 @@ export declare const is: <Literals extends ReadonlyArray<string | number | bigin
  *   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 declare const string: Predicate.Refinement<unknown, string>;
@@ -1222,7 +1197,7 @@ export declare const string: Predicate.Refinement<unknown, string>;
  *
  * **Example** (Matching number values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const categorizeNumber = Match.type<unknown>().pipe(
@@ -1235,15 +1210,15 @@ export declare const string: Predicate.Refinement<unknown, string>;
  *   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 declare const number: Predicate.Refinement<unknown, number>;
@@ -1267,7 +1242,7 @@ export declare const number: Predicate.Refinement<unknown, number>;
  *
  * **Example** (Matching any remaining value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const describeValue = Match.type<unknown>()
@@ -1279,23 +1254,19 @@ export declare const number: Predicate.Refinement<unknown, number>;
  *     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 declare const any: SafeRefinement<unknown, any>;
@@ -1313,7 +1284,7 @@ export declare const any: SafeRefinement<unknown, any>;
  *
  * **Example** (Matching defined values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const processValue = Match.type<string | number | null | undefined>()
@@ -1322,28 +1293,22 @@ export declare const any: SafeRefinement<unknown, 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 declare const defined: <A>(u: A) => u is A & {};
@@ -1361,7 +1326,7 @@ export declare const defined: <A>(u: A) => u is A & {};
  *
  * **Example** (Matching boolean values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const describeTruthiness = Match.type<unknown>().pipe(
@@ -1375,15 +1340,15 @@ export declare const defined: <A>(u: A) => u is A & {};
  *   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 declare const boolean: Predicate.Refinement<unknown, boolean>;
@@ -1404,7 +1369,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 };
@@ -1425,7 +1390,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 };
@@ -1443,7 +1408,7 @@ _null as null };
  *
  * **Example** (Matching bigint values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const processLargeNumber = Match.type<unknown>().pipe(
@@ -1457,15 +1422,15 @@ _null as null };
  *   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 declare const bigint: Predicate.Refinement<unknown, bigint>;
@@ -1480,7 +1445,7 @@ export declare const bigint: Predicate.Refinement<unknown, bigint>;
  *
  * **Example** (Matching symbol values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const mySymbol = Symbol("my-symbol")
@@ -1497,12 +1462,12 @@ export declare const bigint: Predicate.Refinement<unknown, bigint>;
  *   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 declare const symbol: Predicate.Refinement<unknown, symbol>;
@@ -1521,7 +1486,7 @@ export declare const symbol: Predicate.Refinement<unknown, symbol>;
  *
  * **Example** (Matching Date instances)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const processDateValue = Match.type<unknown>().pipe(
@@ -1535,15 +1500,15 @@ export declare const symbol: Predicate.Refinement<unknown, symbol>;
  *   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 declare const date: Predicate.Refinement<unknown, Date>;
@@ -1563,7 +1528,7 @@ export declare const date: Predicate.Refinement<unknown, Date>;
  *
  * **Example** (Matching record objects)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const analyzeValue = Match.type<unknown>().pipe(
@@ -1579,15 +1544,15 @@ export declare const date: Predicate.Refinement<unknown, Date>;
  *   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 declare const record: Predicate.Refinement<unknown, {
@@ -1608,7 +1573,7 @@ export declare const record: Predicate.Refinement<unknown, {
  *
  * **Example** (Matching class instances)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * class CustomError extends Error {
@@ -1638,16 +1603,16 @@ export declare const record: Predicate.Refinement<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 declare const instanceOf: <A extends abstract new (...args: any) => any>(constructor: A) => SafeRefinement<InstanceType<A>, never>;
@@ -1666,7 +1631,7 @@ export declare 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 {
@@ -1684,11 +1649,12 @@ export declare 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 declare const instanceOfUnsafe: <A extends abstract new (...args: any) => any>(constructor: A) => SafeRefinement<InstanceType<A>, InstanceType<A>>;
@@ -1708,7 +1674,7 @@ export declare const instanceOfUnsafe: <A extends abstract new (...args: 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
@@ -1719,11 +1685,9 @@ export declare const instanceOfUnsafe: <A extends abstract new (...args: 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`
@@ -1754,7 +1718,7 @@ export declare const orElse: <RA, Ret, F extends (_: RA) => Ret>(f: F) => <I, R,
  *
  * **Example** (Throwing on unmatched input)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * const strictMatcher = Match.type<"a" | "b">().pipe(
@@ -1764,8 +1728,8 @@ export declare const orElse: <RA, Ret, F extends (_: RA) => Ret>(f: F) => <I, R,
  *   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
@@ -1795,7 +1759,7 @@ export declare const orElseAbsurd: <I, R, RA, A, Pr, Ret>(self: Matcher<I, R, RA
  *
  * **Example** (Extracting a user role with `Match.result`)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * type User = { readonly role: "admin" | "editor" | "viewer" }
@@ -1807,11 +1771,9 @@ export declare const orElseAbsurd: <I, R, RA, A, Pr, Ret>(self: Matcher<I, R, RA
  *   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
@@ -1838,7 +1800,7 @@ export declare const result: <I, F, R, A, Pr, Ret>(self: Matcher<I, F, R, A, Pr,
  *
  * **Example** (Extracting a user role with `Match.option`)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * type User = { readonly role: "admin" | "editor" | "viewer" }
@@ -1850,11 +1812,9 @@ export declare const result: <I, F, R, A, Pr, Ret>(self: Matcher<I, F, R, A, Pr,
  *   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
@@ -1879,7 +1839,7 @@ export declare const option: <I, F, R, A, Pr, Ret>(self: Matcher<I, F, R, A, Pr,
  *
  * **Example** (Ensuring all cases are covered)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * // Create a matcher for string or number values
@@ -1909,7 +1869,7 @@ declare const SafeRefinementId = "~effect/match/Match/SafeRefinement";
  *
  * **Example** (Using safe refinements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
  * // Built-in safe refinements
@@ -1920,10 +1880,10 @@ declare 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
@@ -1958,7 +1918,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
@@ -1975,7 +1935,7 @@ export declare namespace Types {
      * // Result: { type: "user"; name: string }
      * ```
      *
-     * @category types
+     * @category utility types
      * @since 4.0.0
      */
     type WhenMatch<R, P> = [
@@ -1992,7 +1952,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
@@ -2006,7 +1966,7 @@ export declare namespace Types {
      * // Result: "b" | "c"
      * ```
      *
-     * @category types
+     * @category utility types
      * @since 4.0.0
      */
     type NotMatch<R, P> = Exclude<R, ExtractMatch<R, PForNotMatch<P>>>;
@@ -2022,7 +1982,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
@@ -2033,7 +1993,7 @@ export declare namespace Types {
      * // Result: { name: string }
      * ```
      *
-     * @category types
+     * @category utility types
      * @since 4.0.0
      */
     type PForMatch<P> = [ResolvePred<P>] extends [infer X] ? X : never;
@@ -2048,7 +2008,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
@@ -2059,7 +2019,7 @@ export declare namespace Types {
      * // Used internally to filter out admin objects
      * ```
      *
-     * @category types
+     * @category utility types
      * @since 4.0.0
      */
     type PForExclude<P> = [SafeRefinementR<ToSafeRefinement<P>>] extends [infer X] ? X : never;
@@ -2088,7 +2048,7 @@ export declare namespace Types {
      *
      * **Example** (Describing complex object patterns)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Match } from "effect"
      *
      * // PatternBase enables complex object patterns
@@ -2100,7 +2060,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" }) =>
@@ -2108,9 +2068,10 @@ export declare namespace Types {
      *   ),
      *   Match.orElse(() => "Not an adult admin")
      * )
+     * result // => "Admin: Alice"
      * ```
      *
-     * @category types
+     * @category utility types
      * @since 4.0.0
      */
     type PatternBase<A> = A extends ReadonlyArray<infer _T> ? ReadonlyArray<any> | PatternPrimitive<A> : A extends Record<string, any> ? Partial<{
@@ -2125,7 +2086,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
      */
     type PatternPrimitive<A> = PredicateA<A> | A | SafeRefinement<any>;
@@ -2140,18 +2101,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
      */
     interface Without<out X> {
@@ -2169,18 +2131,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
      */
     interface Only<out X> {
@@ -2198,19 +2161,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
      */
     type AddWithout<A, X> = [A] extends [Without<infer WX>] ? Without<X | WX> : [A] extends [Only<infer OX>] ? Only<Exclude<OX, X>> : never;
@@ -2225,18 +2189,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
      */
     type AddOnly<A, X> = [A] extends [Without<infer WX>] ? [X] extends [WX] ? never : Only<X> : [A] extends [Only<infer OX>] ? [X] extends [OX] ? Only<X> : never : never;
@@ -2251,7 +2216,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:
@@ -2268,7 +2233,7 @@ export declare namespace Types {
      * // Result: number | boolean
      * ```
      *
-     * @category types
+     * @category utility types
      * @since 4.0.0
      */
     type ApplyFilters<I, A> = A extends Only<infer X> ? X : A extends Without<infer X> ? Exclude<I, X> : never;
@@ -2283,7 +2248,7 @@ export declare namespace Types {
      *
      * **Example** (Extracting discriminator tags)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import type { Match } from "effect"
      *
      * type Events =
@@ -2302,7 +2267,7 @@ export declare namespace Types {
      * // Result: "user" | "admin"
      * ```
      *
-     * @category types
+     * @category utility types
      * @since 4.0.0
      */
     type Tags<D extends string, P> = P extends Record<D, infer X> ? X : never;
@@ -2317,7 +2282,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<[
@@ -2333,7 +2298,7 @@ export declare namespace Types {
      * // for advanced pattern matching scenarios
      * ```
      *
-     * @category types
+     * @category utility types
      * @since 4.0.0
      */
     type ArrayToIntersection<A extends ReadonlyArray<any>> = T.UnionToIntersection<A[number]>;
@@ -2348,7 +2313,7 @@ export declare namespace Types {
      *
      * **Example** (Extracting matched types)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Match } from "effect"
      *
      * type StringExtract = Match.Types.ExtractMatch<
@@ -2368,7 +2333,7 @@ export declare namespace Types {
      * //                      ^^^ s is correctly typed as string
      * ```
      *
-     * @category types
+     * @category utility types
      * @since 4.0.0
      */
     type ExtractMatch<I, P> = [ExtractAndNarrow<I, P>] extends [infer EI] ? EI : never;