effect 4.0.0-beta.102 → 4.0.0-beta.103

package/dist/Result.d.ts

@@ -38,18 +38,13 @@ declare const TypeId = "~effect/data/Result";
  *
  * **Example** (Creating and matching a Result)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
- * const success = Result.succeed(42)
- * const failure = Result.fail("something went wrong")
- *
- * const message = Result.match(success, {
+ * Result.match(Result.succeed(42), {
  *   onSuccess: (value) => `Success: ${value}`,
  *   onFailure: (error) => `Error: ${error}`
- * })
- * console.log(message)
- * // Output: "Success: 42"
+ * }) // => "Success: 42"
  * ```
  *
  * @see {@link succeed} / {@link fail} to create values
@@ -71,14 +66,13 @@ export type Result<A, E = never> = Success<A, E> | Failure<A, E>;
  *
  * **Example** (Accessing the failure value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
  * const failure = Result.fail("Network error")
  *
  * if (Result.isFailure(failure)) {
- *   console.log(failure.failure)
- *   // Output: "Network error"
+ *   failure.failure // => "Network error"
  * }
  * ```
  *
@@ -130,14 +124,13 @@ export interface ResultIterator<T extends Result<any, any>> {
  *
  * **Example** (Accessing the success value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
  * const success = Result.succeed(42)
  *
  * if (Result.isSuccess(success)) {
- *   console.log(success.success)
- *   // Output: 42
+ *   success.success // => 42
  * }
  * ```
  *
@@ -199,7 +192,7 @@ export interface ResultUnifyIgnore {
  * (e.g., `map`, `flatMap` abstractions). You typically do not need to
  * reference this directly.
  *
- * @category type lambdas
+ * @category utility types
  * @since 4.0.0
  */
 export interface ResultTypeLambda extends TypeLambda {
@@ -211,8 +204,8 @@ export interface ResultTypeLambda extends TypeLambda {
  *
  * **Example** (Extracting inner types)
  *
- * ```ts
- * import type { Result } from "effect"
+ * ```ts import.meta.vitest
+ * import { Result } from "effect"
  *
  * type R = Result.Result<number, string>
  *
@@ -221,6 +214,9 @@ export interface ResultTypeLambda extends TypeLambda {
  *
  * // string
  * type E = Result.Result.Failure<R>
+ *
+ * const success: A = 42
+ * const failure: E = "error"
  * ```
  *
  * @since 4.0.0
@@ -229,14 +225,14 @@ export declare namespace Result {
     /**
      * Extracts the failure type `E` from `Result<A, E>`.
      *
-     * @category Type Level
+     * @category utility types
      * @since 4.0.0
      */
     type Failure<T extends Result<any, any>> = [T] extends [Result<infer _A, infer _E>] ? _E : never;
     /**
      * Extracts the success type `A` from `Result<A, E>`.
      *
-     * @category Type Level
+     * @category utility types
      * @since 4.0.0
      */
     type Success<T extends Result<any, any>> = [T] extends [Result<infer _A, infer _E>] ? _A : never;
@@ -251,13 +247,10 @@ export declare namespace Result {
  *
  * **Example** (Wrapping a value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
- * const result = Result.succeed(42)
- *
- * console.log(Result.isSuccess(result))
- * // Output: true
+ * Result.succeed(42) // => Result.succeed(42)
  * ```
  *
  * @see {@link fail} to create a Failure
@@ -280,13 +273,10 @@ export declare const succeed: <A>(right: A) => Result<A>;
  *
  * **Example** (Creating a failure)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
- * const result = Result.fail("Something went wrong")
- *
- * console.log(Result.isFailure(result))
- * // Output: true
+ * Result.fail("Something went wrong") // => Result.fail("Something went wrong")
  * ```
  *
  * @see {@link succeed} to create a Success
@@ -313,13 +303,10 @@ export {
  *
  * **Example** (Referencing void results)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
- * const result: Result.Result<void> = Result.void
- *
- * console.log(Result.isSuccess(result))
- * // Output: true
+ * const result: Result.Result<void> = Result.void // => Result.succeed(undefined)
  * ```
  *
  * @see {@link succeed} to create a Success with a specific value
@@ -344,13 +331,10 @@ void_ as void };
  *
  * **Example** (Failing without a payload)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
- * const result = Result.failVoid
- *
- * console.log(Result.isFailure(result))
- * // Output: true
+ * Result.failVoid // => Result.fail(undefined)
  * ```
  *
  * @see {@link fail} to create a Failure with a specific value
@@ -376,14 +360,12 @@ export declare const failVoid: Result<never, void>;
  *
  * **Example** (Handling nullable values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
- * console.log(Result.fromNullishOr(1, () => "fallback"))
- * // Output: { _tag: "Success", success: 1, ... }
+ * Result.fromNullishOr(1, () => "fallback") // => Result.succeed(1)
  *
- * console.log(Result.fromNullishOr(null, () => "fallback"))
- * // Output: { _tag: "Failure", failure: "fallback", ... }
+ * Result.fromNullishOr(null, () => "fallback") // => Result.fail("fallback")
  * ```
  *
  * @see {@link fromOption} to convert from an Option
@@ -410,14 +392,12 @@ export declare const fromNullishOr: {
      *
      * **Example** (Handling nullable values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Result } from "effect"
      *
-     * console.log(Result.fromNullishOr(1, () => "fallback"))
-     * // Output: { _tag: "Success", success: 1, ... }
+     * Result.fromNullishOr(1, () => "fallback") // => Result.succeed(1)
      *
-     * console.log(Result.fromNullishOr(null, () => "fallback"))
-     * // Output: { _tag: "Failure", failure: "fallback", ... }
+     * Result.fromNullishOr(null, () => "fallback") // => Result.fail("fallback")
      * ```
      *
      * @see {@link fromOption} to convert from an Option
@@ -444,14 +424,12 @@ export declare const fromNullishOr: {
      *
      * **Example** (Handling nullable values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Result } from "effect"
      *
-     * console.log(Result.fromNullishOr(1, () => "fallback"))
-     * // Output: { _tag: "Success", success: 1, ... }
+     * Result.fromNullishOr(1, () => "fallback") // => Result.succeed(1)
      *
-     * console.log(Result.fromNullishOr(null, () => "fallback"))
-     * // Output: { _tag: "Failure", failure: "fallback", ... }
+     * Result.fromNullishOr(null, () => "fallback") // => Result.fail("fallback")
      * ```
      *
      * @see {@link fromOption} to convert from an Option
@@ -478,16 +456,12 @@ export declare const fromNullishOr: {
  *
  * **Example** (Converting an Option to a Result)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Option, Result } from "effect"
  *
- * const some = Result.fromOption(Option.some(1), () => "missing")
- * console.log(some)
- * // Output: { _tag: "Success", success: 1, ... }
+ * Result.fromOption(Option.some(1), () => "missing") // => Result.succeed(1)
  *
- * const none = Result.fromOption(Option.none(), () => "missing")
- * console.log(none)
- * // Output: { _tag: "Failure", failure: "missing", ... }
+ * Result.fromOption(Option.none(), () => "missing") // => Result.fail("missing")
  * ```
  *
  * @see {@link getSuccess} to extract the success value as an Option
@@ -514,16 +488,12 @@ export declare const fromOption: {
      *
      * **Example** (Converting an Option to a Result)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Option, Result } from "effect"
      *
-     * const some = Result.fromOption(Option.some(1), () => "missing")
-     * console.log(some)
-     * // Output: { _tag: "Success", success: 1, ... }
+     * Result.fromOption(Option.some(1), () => "missing") // => Result.succeed(1)
      *
-     * const none = Result.fromOption(Option.none(), () => "missing")
-     * console.log(none)
-     * // Output: { _tag: "Failure", failure: "missing", ... }
+     * Result.fromOption(Option.none(), () => "missing") // => Result.fail("missing")
      * ```
      *
      * @see {@link getSuccess} to extract the success value as an Option
@@ -550,16 +520,12 @@ export declare const fromOption: {
      *
      * **Example** (Converting an Option to a Result)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Option, Result } from "effect"
      *
-     * const some = Result.fromOption(Option.some(1), () => "missing")
-     * console.log(some)
-     * // Output: { _tag: "Success", success: 1, ... }
+     * Result.fromOption(Option.some(1), () => "missing") // => Result.succeed(1)
      *
-     * const none = Result.fromOption(Option.none(), () => "missing")
-     * console.log(none)
-     * // Output: { _tag: "Failure", failure: "missing", ... }
+     * Result.fromOption(Option.none(), () => "missing") // => Result.fail("missing")
      * ```
      *
      * @see {@link getSuccess} to extract the success value as an Option
@@ -591,19 +557,16 @@ export {
  *
  * **Example** (Catching JSON parse errors)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
- * const ok = Result.try(() => JSON.parse('{"name": "Alice"}'))
- * console.log(ok)
- * // Output: { _tag: "Success", success: { name: "Alice" }, ... }
+ * Result.try(() => JSON.parse('{"name": "Alice"}')) // => Result.succeed({ name: "Alice" })
  *
  * const err = Result.try({
  *   try: () => JSON.parse("not json"),
  *   catch: (e) => `Parse failed: ${e}`
  * })
- * console.log(Result.isFailure(err))
- * // Output: true
+ * Result.isFailure(err) // => true
  * ```
  *
  * @see {@link succeed} / {@link fail} for direct construction
@@ -627,14 +590,12 @@ try_ as try };
  *
  * **Example** (Checking if a value is a Result)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
- * console.log(Result.isResult(Result.succeed(1)))
- * // Output: true
+ * Result.isResult(Result.succeed(1)) // => true
  *
- * console.log(Result.isResult({ value: 1 }))
- * // Output: false
+ * Result.isResult({ value: 1 }) // => false
  * ```
  *
  * @see {@link isSuccess} / {@link isFailure} to narrow to a specific variant
@@ -657,14 +618,13 @@ export declare const isResult: (input: unknown) => input is Result<unknown, unkn
  *
  * **Example** (Narrowing to failure)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
  * const result = Result.fail("oops")
  *
  * if (Result.isFailure(result)) {
- *   console.log(result.failure)
- *   // Output: "oops"
+ *   result.failure // => "oops"
  * }
  * ```
  *
@@ -689,14 +649,13 @@ export declare const isFailure: <A, E>(self: Result<A, E>) => self is Failure<A,
  *
  * **Example** (Narrowing to success)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
  * const result = Result.succeed(42)
  *
  * if (Result.isSuccess(result)) {
- *   console.log(result.success)
- *   // Output: 42
+ *   result.success // => 42
  * }
  * ```
  *
@@ -722,14 +681,12 @@ export declare const isSuccess: <A, E>(self: Result<A, E>) => self is Success<A,
  *
  * **Example** (Extracting the success as an Option)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Option, Result } from "effect"
  *
- * console.log(Result.getSuccess(Result.succeed("ok")))
- * // Output: { _tag: "Some", value: "ok" }
+ * Result.getSuccess(Result.succeed("ok")) // => Option.some("ok")
  *
- * console.log(Result.getSuccess(Result.fail("err")))
- * // Output: { _tag: "None" }
+ * Result.getSuccess(Result.fail("err")) // => Option.none()
  * ```
  *
  * @see {@link getFailure} to extract the error instead
@@ -754,14 +711,12 @@ export declare const getSuccess: <A, E>(self: Result<A, E>) => Option<A>;
  *
  * **Example** (Extracting the failure as an Option)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Option, Result } from "effect"
  *
- * console.log(Result.getFailure(Result.succeed("ok")))
- * // Output: { _tag: "None" }
+ * Result.getFailure(Result.succeed("ok")) // => Option.none()
  *
- * console.log(Result.getFailure(Result.fail("err")))
- * // Output: { _tag: "Some", value: "err" }
+ * Result.getFailure(Result.fail("err")) // => Option.some("err")
  * ```
  *
  * @see {@link getSuccess} to extract the success instead
@@ -782,7 +737,7 @@ export declare const getFailure: <A, E>(self: Result<A, E>) => Option<E>;
  *
  * **Example** (Comparing Results for equality)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence, Result } from "effect"
  *
  * const eq = Result.makeEquivalence(
@@ -790,11 +745,9 @@ export declare const getFailure: <A, E>(self: Result<A, E>) => Option<E>;
  *   Equivalence.strictEqual<string>()
  * )
  *
- * console.log(eq(Result.succeed(1), Result.succeed(1)))
- * // Output: true
+ * eq(Result.succeed(1), Result.succeed(1)) // => true
  *
- * console.log(eq(Result.succeed(1), Result.fail("x")))
- * // Output: false
+ * eq(Result.succeed(1), Result.fail("x")) // => false
  * ```
  *
  * @category instances
@@ -816,18 +769,16 @@ export declare const makeEquivalence: <A, E>(success: Equivalence.Equivalence<A>
  *
  * **Example** (Mapping both channels)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Result } from "effect"
  *
- * const result = pipe(
+ * pipe(
  *   Result.succeed(1),
  *   Result.mapBoth({
  *     onSuccess: (n) => n + 1,
  *     onFailure: (e) => `Error: ${e}`
  *   })
- * )
- * console.log(result)
- * // Output: { _tag: "Success", success: 2, ... }
+ * ) // => Result.succeed(2)
  * ```
  *
  * @see {@link map} to transform only the success value
@@ -853,18 +804,16 @@ export declare const mapBoth: {
      *
      * **Example** (Mapping both channels)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const result = pipe(
+     * pipe(
      *   Result.succeed(1),
      *   Result.mapBoth({
      *     onSuccess: (n) => n + 1,
      *     onFailure: (e) => `Error: ${e}`
      *   })
-     * )
-     * console.log(result)
-     * // Output: { _tag: "Success", success: 2, ... }
+     * ) // => Result.succeed(2)
      * ```
      *
      * @see {@link map} to transform only the success value
@@ -893,18 +842,16 @@ export declare const mapBoth: {
      *
      * **Example** (Mapping both channels)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const result = pipe(
+     * pipe(
      *   Result.succeed(1),
      *   Result.mapBoth({
      *     onSuccess: (n) => n + 1,
      *     onFailure: (e) => `Error: ${e}`
      *   })
-     * )
-     * console.log(result)
-     * // Output: { _tag: "Success", success: 2, ... }
+     * ) // => Result.succeed(2)
      * ```
      *
      * @see {@link map} to transform only the success value
@@ -933,15 +880,13 @@ export declare const mapBoth: {
  *
  * **Example** (Adding context to an error)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Result } from "effect"
  *
- * const result = pipe(
+ * pipe(
  *   Result.fail("not found"),
  *   Result.mapError((e) => `Error: ${e}`)
- * )
- * console.log(result)
- * // Output: { _tag: "Failure", failure: "Error: not found", ... }
+ * ) // => Result.fail("Error: not found")
  * ```
  *
  * @see {@link map} to transform only the success value
@@ -965,15 +910,13 @@ export declare const mapError: {
      *
      * **Example** (Adding context to an error)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const result = pipe(
+     * pipe(
      *   Result.fail("not found"),
      *   Result.mapError((e) => `Error: ${e}`)
-     * )
-     * console.log(result)
-     * // Output: { _tag: "Failure", failure: "Error: not found", ... }
+     * ) // => Result.fail("Error: not found")
      * ```
      *
      * @see {@link map} to transform only the success value
@@ -997,15 +940,13 @@ export declare const mapError: {
      *
      * **Example** (Adding context to an error)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const result = pipe(
+     * pipe(
      *   Result.fail("not found"),
      *   Result.mapError((e) => `Error: ${e}`)
-     * )
-     * console.log(result)
-     * // Output: { _tag: "Failure", failure: "Error: not found", ... }
+     * ) // => Result.fail("Error: not found")
      * ```
      *
      * @see {@link map} to transform only the success value
@@ -1032,15 +973,13 @@ export declare const mapError: {
  *
  * **Example** (Doubling the success value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Result } from "effect"
  *
- * const result = pipe(
+ * pipe(
  *   Result.succeed(3),
  *   Result.map((n) => n * 2)
- * )
- * console.log(result)
- * // Output: { _tag: "Success", success: 6, ... }
+ * ) // => Result.succeed(6)
  * ```
  *
  * @see {@link mapError} to transform only the error value
@@ -1067,15 +1006,13 @@ export declare const map: {
      *
      * **Example** (Doubling the success value)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const result = pipe(
+     * pipe(
      *   Result.succeed(3),
      *   Result.map((n) => n * 2)
-     * )
-     * console.log(result)
-     * // Output: { _tag: "Success", success: 6, ... }
+     * ) // => Result.succeed(6)
      * ```
      *
      * @see {@link mapError} to transform only the error value
@@ -1102,15 +1039,13 @@ export declare const map: {
      *
      * **Example** (Doubling the success value)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const result = pipe(
+     * pipe(
      *   Result.succeed(3),
      *   Result.map((n) => n * 2)
-     * )
-     * console.log(result)
-     * // Output: { _tag: "Success", success: 6, ... }
+     * ) // => Result.succeed(6)
      * ```
      *
      * @see {@link mapError} to transform only the error value
@@ -1138,7 +1073,7 @@ export declare const map: {
  *
  * **Example** (Folding to a string)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Result } from "effect"
  *
  * const format = Result.match({
@@ -1146,11 +1081,9 @@ export declare const map: {
  *   onFailure: (e: string) => `Err: ${e}`
  * })
  *
- * console.log(format(Result.succeed(42)))
- * // Output: "Got 42"
+ * format(Result.succeed(42)) // => "Got 42"
  *
- * console.log(format(Result.fail("timeout")))
- * // Output: "Err: timeout"
+ * format(Result.fail("timeout")) // => "Err: timeout"
  * ```
  *
  * @see {@link merge} to extract `A | E` without mapping
@@ -1176,7 +1109,7 @@ export declare const match: {
      *
      * **Example** (Folding to a string)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
      * const format = Result.match({
@@ -1184,11 +1117,9 @@ export declare const match: {
      *   onFailure: (e: string) => `Err: ${e}`
      * })
      *
-     * console.log(format(Result.succeed(42)))
-     * // Output: "Got 42"
+     * format(Result.succeed(42)) // => "Got 42"
      *
-     * console.log(format(Result.fail("timeout")))
-     * // Output: "Err: timeout"
+     * format(Result.fail("timeout")) // => "Err: timeout"
      * ```
      *
      * @see {@link merge} to extract `A | E` without mapping
@@ -1217,7 +1148,7 @@ export declare const match: {
      *
      * **Example** (Folding to a string)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
      * const format = Result.match({
@@ -1225,11 +1156,9 @@ export declare const match: {
      *   onFailure: (e: string) => `Err: ${e}`
      * })
      *
-     * console.log(format(Result.succeed(42)))
-     * // Output: "Got 42"
+     * format(Result.succeed(42)) // => "Got 42"
      *
-     * console.log(format(Result.fail("timeout")))
-     * // Output: "Err: timeout"
+     * format(Result.fail("timeout")) // => "Err: timeout"
      * ```
      *
      * @see {@link merge} to extract `A | E` without mapping
@@ -1260,18 +1189,16 @@ export declare const match: {
  *
  * **Example** (Validating a number)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Result } from "effect"
  *
- * const ensurePositive = pipe(
+ * pipe(
  *   5,
  *   Result.liftPredicate(
  *     (n: number) => n > 0,
  *     (n) => `${n} is not positive`
  *   )
- * )
- * console.log(ensurePositive)
- * // Output: { _tag: "Success", success: 5, ... }
+ * ) // => Result.succeed(5)
  * ```
  *
  * @see {@link filterOrFail} to validate a value that is already in a `Result`
@@ -1298,18 +1225,16 @@ export declare const liftPredicate: {
      *
      * **Example** (Validating a number)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const ensurePositive = pipe(
+     * pipe(
      *   5,
      *   Result.liftPredicate(
      *     (n: number) => n > 0,
      *     (n) => `${n} is not positive`
      *   )
-     * )
-     * console.log(ensurePositive)
-     * // Output: { _tag: "Success", success: 5, ... }
+     * ) // => Result.succeed(5)
      * ```
      *
      * @see {@link filterOrFail} to validate a value that is already in a `Result`
@@ -1336,18 +1261,16 @@ export declare const liftPredicate: {
      *
      * **Example** (Validating a number)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const ensurePositive = pipe(
+     * pipe(
      *   5,
      *   Result.liftPredicate(
      *     (n: number) => n > 0,
      *     (n) => `${n} is not positive`
      *   )
-     * )
-     * console.log(ensurePositive)
-     * // Output: { _tag: "Success", success: 5, ... }
+     * ) // => Result.succeed(5)
      * ```
      *
      * @see {@link filterOrFail} to validate a value that is already in a `Result`
@@ -1374,18 +1297,16 @@ export declare const liftPredicate: {
      *
      * **Example** (Validating a number)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const ensurePositive = pipe(
+     * pipe(
      *   5,
      *   Result.liftPredicate(
      *     (n: number) => n > 0,
      *     (n) => `${n} is not positive`
      *   )
-     * )
-     * console.log(ensurePositive)
-     * // Output: { _tag: "Success", success: 5, ... }
+     * ) // => Result.succeed(5)
      * ```
      *
      * @see {@link filterOrFail} to validate a value that is already in a `Result`
@@ -1412,18 +1333,16 @@ export declare const liftPredicate: {
      *
      * **Example** (Validating a number)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const ensurePositive = pipe(
+     * pipe(
      *   5,
      *   Result.liftPredicate(
      *     (n: number) => n > 0,
      *     (n) => `${n} is not positive`
      *   )
-     * )
-     * console.log(ensurePositive)
-     * // Output: { _tag: "Success", success: 5, ... }
+     * ) // => Result.succeed(5)
      * ```
      *
      * @see {@link filterOrFail} to validate a value that is already in a `Result`
@@ -1453,18 +1372,16 @@ export declare const liftPredicate: {
  *
  * **Example** (Filtering a success value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Result } from "effect"
  *
- * const result = pipe(
+ * pipe(
  *   Result.succeed(0),
  *   Result.filterOrFail(
  *     (n) => n > 0,
  *     (n) => `${n} is not positive`
  *   )
- * )
- * console.log(result)
- * // Output: { _tag: "Failure", failure: "0 is not positive", ... }
+ * ) // => Result.fail("0 is not positive")
  * ```
  *
  * @see {@link liftPredicate} to create a `Result` from a raw value with a predicate
@@ -1493,18 +1410,16 @@ export declare const filterOrFail: {
      *
      * **Example** (Filtering a success value)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const result = pipe(
+     * pipe(
      *   Result.succeed(0),
      *   Result.filterOrFail(
      *     (n) => n > 0,
      *     (n) => `${n} is not positive`
      *   )
-     * )
-     * console.log(result)
-     * // Output: { _tag: "Failure", failure: "0 is not positive", ... }
+     * ) // => Result.fail("0 is not positive")
      * ```
      *
      * @see {@link liftPredicate} to create a `Result` from a raw value with a predicate
@@ -1533,18 +1448,16 @@ export declare const filterOrFail: {
      *
      * **Example** (Filtering a success value)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const result = pipe(
+     * pipe(
      *   Result.succeed(0),
      *   Result.filterOrFail(
      *     (n) => n > 0,
      *     (n) => `${n} is not positive`
      *   )
-     * )
-     * console.log(result)
-     * // Output: { _tag: "Failure", failure: "0 is not positive", ... }
+     * ) // => Result.fail("0 is not positive")
      * ```
      *
      * @see {@link liftPredicate} to create a `Result` from a raw value with a predicate
@@ -1573,18 +1486,16 @@ export declare const filterOrFail: {
      *
      * **Example** (Filtering a success value)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const result = pipe(
+     * pipe(
      *   Result.succeed(0),
      *   Result.filterOrFail(
      *     (n) => n > 0,
      *     (n) => `${n} is not positive`
      *   )
-     * )
-     * console.log(result)
-     * // Output: { _tag: "Failure", failure: "0 is not positive", ... }
+     * ) // => Result.fail("0 is not positive")
      * ```
      *
      * @see {@link liftPredicate} to create a `Result` from a raw value with a predicate
@@ -1613,18 +1524,16 @@ export declare const filterOrFail: {
      *
      * **Example** (Filtering a success value)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const result = pipe(
+     * pipe(
      *   Result.succeed(0),
      *   Result.filterOrFail(
      *     (n) => n > 0,
      *     (n) => `${n} is not positive`
      *   )
-     * )
-     * console.log(result)
-     * // Output: { _tag: "Failure", failure: "0 is not positive", ... }
+     * ) // => Result.fail("0 is not positive")
      * ```
      *
      * @see {@link liftPredicate} to create a `Result` from a raw value with a predicate
@@ -1647,14 +1556,12 @@ export declare const filterOrFail: {
  *
  * **Example** (Extracting the inner value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
- * console.log(Result.merge(Result.succeed(42)))
- * // Output: 42
+ * Result.merge(Result.succeed(42)) // => 42
  *
- * console.log(Result.merge(Result.fail("error")))
- * // Output: "error"
+ * Result.merge(Result.fail("error")) // => "error"
  * ```
  *
  * @see {@link match} to map each branch to a common type
@@ -1680,14 +1587,12 @@ export declare const merge: <A, E>(self: Result<A, E>) => E | A;
  *
  * **Example** (Providing a fallback)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
- * console.log(Result.getOrElse(Result.succeed(1), () => 0))
- * // Output: 1
+ * Result.getOrElse(Result.succeed(1), () => 0) // => 1
  *
- * console.log(Result.getOrElse(Result.fail("err"), () => 0))
- * // Output: 0
+ * Result.getOrElse(Result.fail("err"), () => 0) // => 0
  * ```
  *
  * @see {@link getOrNull} / {@link getOrUndefined} for simpler fallbacks
@@ -1715,14 +1620,12 @@ export declare const getOrElse: {
      *
      * **Example** (Providing a fallback)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Result } from "effect"
      *
-     * console.log(Result.getOrElse(Result.succeed(1), () => 0))
-     * // Output: 1
+     * Result.getOrElse(Result.succeed(1), () => 0) // => 1
      *
-     * console.log(Result.getOrElse(Result.fail("err"), () => 0))
-     * // Output: 0
+     * Result.getOrElse(Result.fail("err"), () => 0) // => 0
      * ```
      *
      * @see {@link getOrNull} / {@link getOrUndefined} for simpler fallbacks
@@ -1750,14 +1653,12 @@ export declare const getOrElse: {
      *
      * **Example** (Providing a fallback)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Result } from "effect"
      *
-     * console.log(Result.getOrElse(Result.succeed(1), () => 0))
-     * // Output: 1
+     * Result.getOrElse(Result.succeed(1), () => 0) // => 1
      *
-     * console.log(Result.getOrElse(Result.fail("err"), () => 0))
-     * // Output: 0
+     * Result.getOrElse(Result.fail("err"), () => 0) // => 0
      * ```
      *
      * @see {@link getOrNull} / {@link getOrUndefined} for simpler fallbacks
@@ -1785,14 +1686,12 @@ export declare const getOrElse: {
  *
  * **Example** (Unwrapping to nullable)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
- * console.log(Result.getOrNull(Result.succeed(1)))
- * // Output: 1
+ * Result.getOrNull(Result.succeed(1)) // => 1
  *
- * console.log(Result.getOrNull(Result.fail("err")))
- * // Output: null
+ * Result.getOrNull(Result.fail("err")) // => null
  * ```
  *
  * @see {@link getOrUndefined} to return `undefined` instead
@@ -1817,14 +1716,12 @@ export declare const getOrNull: <A, E>(self: Result<A, E>) => A | null;
  *
  * **Example** (Unwrapping to optional)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
- * console.log(Result.getOrUndefined(Result.succeed(1)))
- * // Output: 1
+ * Result.getOrUndefined(Result.succeed(1)) // => 1
  *
- * console.log(Result.getOrUndefined(Result.fail("err")))
- * // Output: undefined
+ * Result.getOrUndefined(Result.fail("err")) // => undefined
  * ```
  *
  * @see {@link getOrNull} to return `null` instead
@@ -1849,19 +1746,19 @@ export declare const getOrUndefined: <A, E>(self: Result<A, E>) => A | undefined
  *
  * **Example** (Throwing a custom error)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
- * console.log(
- *   Result.getOrThrowWith(Result.succeed(1), () => new Error("fail"))
- * )
- * // Output: 1
+ * Result.getOrThrowWith(Result.succeed(1), () => new Error("fail")) // => 1
  *
- * // This would throw: new Error("Unexpected: oops")
- * // Result.getOrThrowWith(
- * //   Result.fail("oops"),
- * //   (err) => new Error(`Unexpected: ${err}`)
- * // )
+ * const failure = Result.try({
+ *   try: () => Result.getOrThrowWith(
+ *     Result.fail("oops"),
+ *     (error) => new Error(`Unexpected: ${error}`)
+ *   ),
+ *   catch: (error) => (error as Error).message
+ * })
+ * Result.merge(failure) // => "Unexpected: oops"
  * ```
  *
  * @see {@link getOrThrow} to throw the raw failure value
@@ -1886,19 +1783,19 @@ export declare const getOrThrowWith: {
      *
      * **Example** (Throwing a custom error)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Result } from "effect"
      *
-     * console.log(
-     *   Result.getOrThrowWith(Result.succeed(1), () => new Error("fail"))
-     * )
-     * // Output: 1
+     * Result.getOrThrowWith(Result.succeed(1), () => new Error("fail")) // => 1
      *
-     * // This would throw: new Error("Unexpected: oops")
-     * // Result.getOrThrowWith(
-     * //   Result.fail("oops"),
-     * //   (err) => new Error(`Unexpected: ${err}`)
-     * // )
+     * const failure = Result.try({
+     *   try: () => Result.getOrThrowWith(
+     *     Result.fail("oops"),
+     *     (error) => new Error(`Unexpected: ${error}`)
+     *   ),
+     *   catch: (error) => (error as Error).message
+     * })
+     * Result.merge(failure) // => "Unexpected: oops"
      * ```
      *
      * @see {@link getOrThrow} to throw the raw failure value
@@ -1923,19 +1820,19 @@ export declare const getOrThrowWith: {
      *
      * **Example** (Throwing a custom error)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Result } from "effect"
      *
-     * console.log(
-     *   Result.getOrThrowWith(Result.succeed(1), () => new Error("fail"))
-     * )
-     * // Output: 1
+     * Result.getOrThrowWith(Result.succeed(1), () => new Error("fail")) // => 1
      *
-     * // This would throw: new Error("Unexpected: oops")
-     * // Result.getOrThrowWith(
-     * //   Result.fail("oops"),
-     * //   (err) => new Error(`Unexpected: ${err}`)
-     * // )
+     * const failure = Result.try({
+     *   try: () => Result.getOrThrowWith(
+     *     Result.fail("oops"),
+     *     (error) => new Error(`Unexpected: ${error}`)
+     *   ),
+     *   catch: (error) => (error as Error).message
+     * })
+     * Result.merge(failure) // => "Unexpected: oops"
      * ```
      *
      * @see {@link getOrThrow} to throw the raw failure value
@@ -1961,14 +1858,13 @@ export declare const getOrThrowWith: {
  *
  * **Example** (Unwrapping or throwing)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
- * console.log(Result.getOrThrow(Result.succeed(1)))
- * // Output: 1
+ * Result.getOrThrow(Result.succeed(1)) // => 1
  *
- * // This would throw the string "error":
- * // Result.getOrThrow(Result.fail("error"))
+ * const failure = Result.try(() => Result.getOrThrow(Result.fail("error")))
+ * Result.merge(failure) // => "error"
  * ```
  *
  * @see {@link getOrThrowWith} for custom error mapping
@@ -1994,15 +1890,13 @@ export declare const getOrThrow: <A, E>(self: Result<A, E>) => A;
  *
  * **Example** (Recovering from a failure)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Result } from "effect"
  *
- * const result = pipe(
+ * pipe(
  *   Result.fail("primary failed"),
  *   Result.orElse(() => Result.succeed(99))
- * )
- * console.log(result)
- * // Output: { _tag: "Success", success: 99, ... }
+ * ) // => Result.succeed(99)
  * ```
  *
  * @see {@link getOrElse} to unwrap with a fallback value (not a Result)
@@ -2028,15 +1922,13 @@ export declare const orElse: {
      *
      * **Example** (Recovering from a failure)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const result = pipe(
+     * pipe(
      *   Result.fail("primary failed"),
      *   Result.orElse(() => Result.succeed(99))
-     * )
-     * console.log(result)
-     * // Output: { _tag: "Success", success: 99, ... }
+     * ) // => Result.succeed(99)
      * ```
      *
      * @see {@link getOrElse} to unwrap with a fallback value (not a Result)
@@ -2062,15 +1954,13 @@ export declare const orElse: {
      *
      * **Example** (Recovering from a failure)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const result = pipe(
+     * pipe(
      *   Result.fail("primary failed"),
      *   Result.orElse(() => Result.succeed(99))
-     * )
-     * console.log(result)
-     * // Output: { _tag: "Success", success: 99, ... }
+     * ) // => Result.succeed(99)
      * ```
      *
      * @see {@link getOrElse} to unwrap with a fallback value (not a Result)
@@ -2098,17 +1988,15 @@ export declare const orElse: {
  *
  * **Example** (Validating sequentially)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Result } from "effect"
  *
- * const result = pipe(
+ * pipe(
  *   Result.succeed(5),
  *   Result.flatMap((n) =>
  *     n > 0 ? Result.succeed(n * 2) : Result.fail("not positive")
  *   )
- * )
- * console.log(result)
- * // Output: { _tag: "Success", success: 10, ... }
+ * ) // => Result.succeed(10)
  * ```
  *
  * @see {@link andThen} for a more flexible variant that also accepts plain values
@@ -2135,17 +2023,15 @@ export declare const flatMap: {
      *
      * **Example** (Validating sequentially)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const result = pipe(
+     * pipe(
      *   Result.succeed(5),
      *   Result.flatMap((n) =>
      *     n > 0 ? Result.succeed(n * 2) : Result.fail("not positive")
      *   )
-     * )
-     * console.log(result)
-     * // Output: { _tag: "Success", success: 10, ... }
+     * ) // => Result.succeed(10)
      * ```
      *
      * @see {@link andThen} for a more flexible variant that also accepts plain values
@@ -2172,17 +2058,15 @@ export declare const flatMap: {
      *
      * **Example** (Validating sequentially)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const result = pipe(
+     * pipe(
      *   Result.succeed(5),
      *   Result.flatMap((n) =>
      *     n > 0 ? Result.succeed(n * 2) : Result.fail("not positive")
      *   )
-     * )
-     * console.log(result)
-     * // Output: { _tag: "Success", success: 10, ... }
+     * ) // => Result.succeed(10)
      * ```
      *
      * @see {@link andThen} for a more flexible variant that also accepts plain values
@@ -2213,25 +2097,23 @@ export declare const flatMap: {
  *
  * **Example** (Chaining Result values with different argument types)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Result } from "effect"
  *
  * // With a function returning a Result
  * const a = pipe(
  *   Result.succeed(1),
  *   Result.andThen((n) => Result.succeed(n + 1))
- * )
+ * ) // => Result.succeed(2)
  *
  * // With a plain mapping function
  * const b = pipe(
  *   Result.succeed(1),
  *   Result.andThen((n) => n + 1)
- * )
+ * ) // => Result.succeed(2)
  *
  * // With a constant value
- * const c = pipe(Result.succeed(1), Result.andThen("done"))
- *
- * console.log(a, b, c)
+ * const c = pipe(Result.succeed(1), Result.andThen("done")) // => Result.succeed("done")
  * ```
  *
  * @see {@link flatMap} for the stricter variant (function returning Result only)
@@ -2261,25 +2143,23 @@ export declare const andThen: {
      *
      * **Example** (Chaining Result values with different argument types)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
      * // With a function returning a Result
      * const a = pipe(
      *   Result.succeed(1),
      *   Result.andThen((n) => Result.succeed(n + 1))
-     * )
+     * ) // => Result.succeed(2)
      *
      * // With a plain mapping function
      * const b = pipe(
      *   Result.succeed(1),
      *   Result.andThen((n) => n + 1)
-     * )
+     * ) // => Result.succeed(2)
      *
      * // With a constant value
-     * const c = pipe(Result.succeed(1), Result.andThen("done"))
-     *
-     * console.log(a, b, c)
+     * const c = pipe(Result.succeed(1), Result.andThen("done")) // => Result.succeed("done")
      * ```
      *
      * @see {@link flatMap} for the stricter variant (function returning Result only)
@@ -2309,25 +2189,23 @@ export declare const andThen: {
      *
      * **Example** (Chaining Result values with different argument types)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
      * // With a function returning a Result
      * const a = pipe(
      *   Result.succeed(1),
      *   Result.andThen((n) => Result.succeed(n + 1))
-     * )
+     * ) // => Result.succeed(2)
      *
      * // With a plain mapping function
      * const b = pipe(
      *   Result.succeed(1),
      *   Result.andThen((n) => n + 1)
-     * )
+     * ) // => Result.succeed(2)
      *
      * // With a constant value
-     * const c = pipe(Result.succeed(1), Result.andThen("done"))
-     *
-     * console.log(a, b, c)
+     * const c = pipe(Result.succeed(1), Result.andThen("done")) // => Result.succeed("done")
      * ```
      *
      * @see {@link flatMap} for the stricter variant (function returning Result only)
@@ -2357,25 +2235,23 @@ export declare const andThen: {
      *
      * **Example** (Chaining Result values with different argument types)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
      * // With a function returning a Result
      * const a = pipe(
      *   Result.succeed(1),
      *   Result.andThen((n) => Result.succeed(n + 1))
-     * )
+     * ) // => Result.succeed(2)
      *
      * // With a plain mapping function
      * const b = pipe(
      *   Result.succeed(1),
      *   Result.andThen((n) => n + 1)
-     * )
+     * ) // => Result.succeed(2)
      *
      * // With a constant value
-     * const c = pipe(Result.succeed(1), Result.andThen("done"))
-     *
-     * console.log(a, b, c)
+     * const c = pipe(Result.succeed(1), Result.andThen("done")) // => Result.succeed("done")
      * ```
      *
      * @see {@link flatMap} for the stricter variant (function returning Result only)
@@ -2405,25 +2281,23 @@ export declare const andThen: {
      *
      * **Example** (Chaining Result values with different argument types)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
      * // With a function returning a Result
      * const a = pipe(
      *   Result.succeed(1),
      *   Result.andThen((n) => Result.succeed(n + 1))
-     * )
+     * ) // => Result.succeed(2)
      *
      * // With a plain mapping function
      * const b = pipe(
      *   Result.succeed(1),
      *   Result.andThen((n) => n + 1)
-     * )
+     * ) // => Result.succeed(2)
      *
      * // With a constant value
-     * const c = pipe(Result.succeed(1), Result.andThen("done"))
-     *
-     * console.log(a, b, c)
+     * const c = pipe(Result.succeed(1), Result.andThen("done")) // => Result.succeed("done")
      * ```
      *
      * @see {@link flatMap} for the stricter variant (function returning Result only)
@@ -2453,25 +2327,23 @@ export declare const andThen: {
      *
      * **Example** (Chaining Result values with different argument types)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
      * // With a function returning a Result
      * const a = pipe(
      *   Result.succeed(1),
      *   Result.andThen((n) => Result.succeed(n + 1))
-     * )
+     * ) // => Result.succeed(2)
      *
      * // With a plain mapping function
      * const b = pipe(
      *   Result.succeed(1),
      *   Result.andThen((n) => n + 1)
-     * )
+     * ) // => Result.succeed(2)
      *
      * // With a constant value
-     * const c = pipe(Result.succeed(1), Result.andThen("done"))
-     *
-     * console.log(a, b, c)
+     * const c = pipe(Result.succeed(1), Result.andThen("done")) // => Result.succeed("done")
      * ```
      *
      * @see {@link flatMap} for the stricter variant (function returning Result only)
@@ -2501,25 +2373,23 @@ export declare const andThen: {
      *
      * **Example** (Chaining Result values with different argument types)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
      * // With a function returning a Result
      * const a = pipe(
      *   Result.succeed(1),
      *   Result.andThen((n) => Result.succeed(n + 1))
-     * )
+     * ) // => Result.succeed(2)
      *
      * // With a plain mapping function
      * const b = pipe(
      *   Result.succeed(1),
      *   Result.andThen((n) => n + 1)
-     * )
+     * ) // => Result.succeed(2)
      *
      * // With a constant value
-     * const c = pipe(Result.succeed(1), Result.andThen("done"))
-     *
-     * console.log(a, b, c)
+     * const c = pipe(Result.succeed(1), Result.andThen("done")) // => Result.succeed("done")
      * ```
      *
      * @see {@link flatMap} for the stricter variant (function returning Result only)
@@ -2549,25 +2419,23 @@ export declare const andThen: {
      *
      * **Example** (Chaining Result values with different argument types)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
      * // With a function returning a Result
      * const a = pipe(
      *   Result.succeed(1),
      *   Result.andThen((n) => Result.succeed(n + 1))
-     * )
+     * ) // => Result.succeed(2)
      *
      * // With a plain mapping function
      * const b = pipe(
      *   Result.succeed(1),
      *   Result.andThen((n) => n + 1)
-     * )
+     * ) // => Result.succeed(2)
      *
      * // With a constant value
-     * const c = pipe(Result.succeed(1), Result.andThen("done"))
-     *
-     * console.log(a, b, c)
+     * const c = pipe(Result.succeed(1), Result.andThen("done")) // => Result.succeed("done")
      * ```
      *
      * @see {@link flatMap} for the stricter variant (function returning Result only)
@@ -2597,25 +2465,23 @@ export declare const andThen: {
      *
      * **Example** (Chaining Result values with different argument types)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
      * // With a function returning a Result
      * const a = pipe(
      *   Result.succeed(1),
      *   Result.andThen((n) => Result.succeed(n + 1))
-     * )
+     * ) // => Result.succeed(2)
      *
      * // With a plain mapping function
      * const b = pipe(
      *   Result.succeed(1),
      *   Result.andThen((n) => n + 1)
-     * )
+     * ) // => Result.succeed(2)
      *
      * // With a constant value
-     * const c = pipe(Result.succeed(1), Result.andThen("done"))
-     *
-     * console.log(a, b, c)
+     * const c = pipe(Result.succeed(1), Result.andThen("done")) // => Result.succeed("done")
      * ```
      *
      * @see {@link flatMap} for the stricter variant (function returning Result only)
@@ -2645,18 +2511,14 @@ export declare const andThen: {
  *
  * **Example** (Collecting a tuple and a struct)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
  * // Tuple
- * const tuple = Result.all([Result.succeed(1), Result.succeed("two")])
- * console.log(tuple)
- * // Output: { _tag: "Success", success: [1, "two"], ... }
+ * Result.all([Result.succeed(1), Result.succeed("two")]) // => Result.succeed([1, "two"])
  *
  * // Struct
- * const struct = Result.all({ x: Result.succeed(1), y: Result.fail("err") })
- * console.log(struct)
- * // Output: { _tag: "Failure", failure: "err", ... }
+ * Result.all({ x: Result.succeed(1), y: Result.fail("err") }) // => Result.fail("err")
  * ```
  *
  * @see {@link flatMap} for chaining two Results sequentially
@@ -2687,14 +2549,12 @@ export declare const all: <const I extends Iterable<Result<any, any>> | Record<s
  *
  * **Example** (Swapping channels)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
- * console.log(Result.flip(Result.succeed(42)))
- * // Output: { _tag: "Failure", failure: 42, ... }
+ * Result.flip(Result.succeed(42)) // => Result.fail(42)
  *
- * console.log(Result.flip(Result.fail("error")))
- * // Output: { _tag: "Success", success: "error", ... }
+ * Result.flip(Result.fail("error")) // => Result.succeed("error")
  * ```
  *
  * @see {@link mapError} to transform the error without swapping
@@ -2720,17 +2580,14 @@ export declare const flip: <A, E>(self: Result<A, E>) => Result<E, A>;
  *
  * **Example** (Composing multiple Results)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Result } from "effect"
  *
- * const result = Result.gen(function*() {
+ * Result.gen(function*() {
  *   const a = yield* Result.succeed(1)
  *   const b = yield* Result.succeed(2)
  *   return a + b
- * })
- *
- * console.log(result)
- * // Output: { _tag: "Success", success: 3, ... }
+ * }) // => Result.succeed(3)
  * ```
  *
  * @see {@link flatMap} for point-free sequential composition
@@ -2757,17 +2614,15 @@ export declare const gen: Gen.Gen<ResultTypeLambda>;
  *
  * **Example** (Building an object step by step)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Result } from "effect"
  *
- * const result = pipe(
+ * pipe(
  *   Result.Do,
  *   Result.bind("x", () => Result.succeed(2)),
  *   Result.bind("y", () => Result.succeed(3)),
  *   Result.let("sum", ({ x, y }) => x + y)
- * )
- * console.log(result)
- * // Output: { _tag: "Success", success: { x: 2, y: 3, sum: 5 }, ... }
+ * ) // => Result.succeed({ x: 2, y: 3, sum: 5 })
  * ```
  *
  * @see {@link bind} to add Result-producing fields
@@ -2775,7 +2630,7 @@ export declare const gen: Gen.Gen<ResultTypeLambda>;
  * @see {@link gen} for an alternative generator-based syntax
  * @see {@link bindTo} for starting a do-notation chain from an existing Result
  *
- * @category do notation
+ * @category constructors
  * @since 2.0.0
  */
 export declare const Do: Result<{}>;
@@ -2797,23 +2652,21 @@ export declare const Do: Result<{}>;
  *
  * **Example** (Binding Result values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Result } from "effect"
  *
- * const result = pipe(
+ * pipe(
  *   Result.Do,
  *   Result.bind("x", () => Result.succeed(2)),
  *   Result.bind("y", ({ x }) => Result.succeed(x + 3))
- * )
- * console.log(result)
- * // Output: { _tag: "Success", success: { x: 2, y: 5 }, ... }
+ * ) // => Result.succeed({ x: 2, y: 5 })
  * ```
  *
  * @see {@link Do} to start the do-notation chain
  * @see {@link let_ let} for pure computed fields
  * @see {@link bindTo} to wrap an initial Result into a named field
  *
- * @category do notation
+ * @category sequencing
  * @since 2.0.0
  */
 export declare const bind: {
@@ -2835,23 +2688,21 @@ export declare const bind: {
      *
      * **Example** (Binding Result values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const result = pipe(
+     * pipe(
      *   Result.Do,
      *   Result.bind("x", () => Result.succeed(2)),
      *   Result.bind("y", ({ x }) => Result.succeed(x + 3))
-     * )
-     * console.log(result)
-     * // Output: { _tag: "Success", success: { x: 2, y: 5 }, ... }
+     * ) // => Result.succeed({ x: 2, y: 5 })
      * ```
      *
      * @see {@link Do} to start the do-notation chain
      * @see {@link let_ let} for pure computed fields
      * @see {@link bindTo} to wrap an initial Result into a named field
      *
-     * @category do notation
+     * @category sequencing
      * @since 2.0.0
      */
     <N extends string, A extends object, B, L2>(name: Exclude<N, keyof A>, f: (a: NoInfer<A>) => Result<B, L2>): <L1>(self: Result<A, L1>) => Result<{
@@ -2875,23 +2726,21 @@ export declare const bind: {
      *
      * **Example** (Binding Result values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const result = pipe(
+     * pipe(
      *   Result.Do,
      *   Result.bind("x", () => Result.succeed(2)),
      *   Result.bind("y", ({ x }) => Result.succeed(x + 3))
-     * )
-     * console.log(result)
-     * // Output: { _tag: "Success", success: { x: 2, y: 5 }, ... }
+     * ) // => Result.succeed({ x: 2, y: 5 })
      * ```
      *
      * @see {@link Do} to start the do-notation chain
      * @see {@link let_ let} for pure computed fields
      * @see {@link bindTo} to wrap an initial Result into a named field
      *
-     * @category do notation
+     * @category sequencing
      * @since 2.0.0
      */
     <A extends object, L1, N extends string, B, L2>(self: Result<A, L1>, name: Exclude<N, keyof A>, f: (a: NoInfer<A>) => Result<B, L2>): Result<{
@@ -2914,21 +2763,19 @@ export declare const bind: {
  *
  * **Example** (Wrapping a value into a named field)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Result } from "effect"
  *
- * const result = pipe(
+ * pipe(
  *   Result.succeed(42),
  *   Result.bindTo("answer")
- * )
- * console.log(result)
- * // Output: { _tag: "Success", success: { answer: 42 }, ... }
+ * ) // => Result.succeed({ answer: 42 })
  * ```
  *
  * @see {@link Do} to start from an empty object
  * @see {@link bind} to add more fields
  *
- * @category do notation
+ * @category mapping
  * @since 2.0.0
  */
 export declare const bindTo: {
@@ -2948,21 +2795,19 @@ export declare const bindTo: {
      *
      * **Example** (Wrapping a value into a named field)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const result = pipe(
+     * pipe(
      *   Result.succeed(42),
      *   Result.bindTo("answer")
-     * )
-     * console.log(result)
-     * // Output: { _tag: "Success", success: { answer: 42 }, ... }
+     * ) // => Result.succeed({ answer: 42 })
      * ```
      *
      * @see {@link Do} to start from an empty object
      * @see {@link bind} to add more fields
      *
-     * @category do notation
+     * @category mapping
      * @since 2.0.0
      */
     <N extends string>(name: N): <R, L>(self: Result<R, L>) => Result<Record<N, R>, L>;
@@ -2982,21 +2827,19 @@ export declare const bindTo: {
      *
      * **Example** (Wrapping a value into a named field)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
-     * const result = pipe(
+     * pipe(
      *   Result.succeed(42),
      *   Result.bindTo("answer")
-     * )
-     * console.log(result)
-     * // Output: { _tag: "Success", success: { answer: 42 }, ... }
+     * ) // => Result.succeed({ answer: 42 })
      * ```
      *
      * @see {@link Do} to start from an empty object
      * @see {@link bind} to add more fields
      *
-     * @category do notation
+     * @category mapping
      * @since 2.0.0
      */
     <R, L, N extends string>(self: Result<R, L>, name: N): Result<Record<N, R>, L>;
@@ -3026,23 +2869,21 @@ export {
  *
  * **Example** (Adding a computed field)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Result } from "effect"
  *
- * const result = pipe(
+ * pipe(
  *   Result.Do,
  *   Result.bind("x", () => Result.succeed(2)),
  *   Result.bind("y", () => Result.succeed(3)),
  *   Result.let("sum", ({ x, y }) => x + y)
- * )
- * console.log(result)
- * // Output: { _tag: "Success", success: { x: 2, y: 3, sum: 5 }, ... }
+ * ) // => Result.succeed({ x: 2, y: 3, sum: 5 })
  * ```
  *
  * @see {@link Do} to start the do-notation chain
  * @see {@link bind} for Result-producing fields
  *
- * @category do notation
+ * @category mapping
  * @since 2.0.0
  */
 let_ as let };
@@ -3062,21 +2903,17 @@ let_ as let };
  *
  * **Example** (Transposing an Option of a Result)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Option, Result } from "effect"
  *
- * const some = Option.some(Result.succeed(42))
- * console.log(Result.transposeOption(some))
- * // Output: { _tag: "Success", success: { _tag: "Some", value: 42 }, ... }
+ * Result.transposeOption(Option.some(Result.succeed(42))) // => Result.succeed(Option.some(42))
  *
- * const none = Option.none<Result.Result<number, string>>()
- * console.log(Result.transposeOption(none))
- * // Output: { _tag: "Success", success: { _tag: "None" }, ... }
+ * Result.transposeOption(Option.none<Result.Result<number, string>>()) // => Result.succeed(Option.none())
  * ```
  *
  * @see {@link transposeMapOption} to map and transpose in one step
  *
- * @category Transposing
+ * @category transposing
  * @since 3.14.0
  */
 export declare const transposeOption: <A = never, E = never>(self: Option<Result<A, E>>) => Result<Option<A>, E>;
@@ -3097,7 +2934,7 @@ export declare const transposeOption: <A = never, E = never>(self: Option<Result
  *
  * **Example** (Mapping and transposing in one step)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Option, Result } from "effect"
  *
  * const parse = (s: string) =>
@@ -3105,16 +2942,14 @@ export declare const transposeOption: <A = never, E = never>(self: Option<Result
  *     ? Result.fail("not a number" as const)
  *     : Result.succeed(Number(s))
  *
- * console.log(Result.transposeMapOption(Option.some("42"), parse))
- * // Output: { _tag: "Success", success: { _tag: "Some", value: 42 }, ... }
+ * Result.transposeMapOption(Option.some("42"), parse) // => Result.succeed(Option.some(42))
  *
- * console.log(Result.transposeMapOption(Option.none(), parse))
- * // Output: { _tag: "Success", success: { _tag: "None" }, ... }
+ * Result.transposeMapOption(Option.none(), parse) // => Result.succeed(Option.none())
  * ```
  *
  * @see {@link transposeOption} when the Option already contains a Result
  *
- * @category Transposing
+ * @category transposing
  * @since 3.15.0
  */
 export declare const transposeMapOption: (<A, B, E = never>(f: (self: A) => Result<B, E>) => (self: Option<A>) => Result<Option<B>, E>) & (<A, B, E = never>(self: Option<A>, f: (self: A) => Result<B, E>) => Result<Option<B>, E>);
@@ -3133,11 +2968,10 @@ export declare const transposeMapOption: (<A, B, E = never>(f: (self: A) => Resu
  *
  * **Example** (Succeeding with None)
  *
- * ```ts
- * import { Result } from "effect"
+ * ```ts import.meta.vitest
+ * import { Option, Result } from "effect"
  *
- * console.log(Result.isSuccess(Result.succeedNone))
- * // Output: true
+ * Result.succeedNone // => Result.succeed(Option.none())
  * ```
  *
  * @see {@link succeedSome} for the `Some` counterpart
@@ -3158,12 +2992,10 @@ export declare const succeedNone: Result<Option<never>, never>;
  *
  * **Example** (Wrapping a value in Some inside a Result)
  *
- * ```ts
- * import { Result } from "effect"
+ * ```ts import.meta.vitest
+ * import { Option, Result } from "effect"
  *
- * const result = Result.succeedSome(42)
- * console.log(result)
- * // Output: { _tag: "Success", success: { _tag: "Some", value: 42 }, ... }
+ * Result.succeedSome(42) // => Result.succeed(Option.some(42))
  * ```
  *
  * @see {@link succeedNone} for the `None` counterpart
@@ -3184,17 +3016,17 @@ export declare const succeedSome: <A, E = never>(a: A) => Result<Option<A>, E>;
  *
  * **Example** (Logging a success value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Result } from "effect"
  *
+ * const values: Array<number> = []
  * const result = pipe(
  *   Result.succeed(42),
- *   Result.tap((n) => console.log("Got:", n))
+ *   Result.tap((n) => values.push(n))
  * )
- * // Output: "Got: 42"
  *
- * console.log(Result.isSuccess(result))
- * // Output: true
+ * values // => [42]
+ * result // => Result.succeed(42)
  * ```
  *
  * @see {@link map} to transform the success value
@@ -3215,17 +3047,17 @@ export declare const tap: {
      *
      * **Example** (Logging a success value)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
+     * const values: Array<number> = []
      * const result = pipe(
      *   Result.succeed(42),
-     *   Result.tap((n) => console.log("Got:", n))
+     *   Result.tap((n) => values.push(n))
      * )
-     * // Output: "Got: 42"
      *
-     * console.log(Result.isSuccess(result))
-     * // Output: true
+     * values // => [42]
+     * result // => Result.succeed(42)
      * ```
      *
      * @see {@link map} to transform the success value
@@ -3246,17 +3078,17 @@ export declare const tap: {
      *
      * **Example** (Logging a success value)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { pipe, Result } from "effect"
      *
+     * const values: Array<number> = []
      * const result = pipe(
      *   Result.succeed(42),
-     *   Result.tap((n) => console.log("Got:", n))
+     *   Result.tap((n) => values.push(n))
      * )
-     * // Output: "Got: 42"
      *
-     * console.log(Result.isSuccess(result))
-     * // Output: true
+     * values // => [42]
+     * result // => Result.succeed(42)
      * ```
      *
      * @see {@link map} to transform the success value