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

package/src/Result.ts

@@ -17,6 +17,7 @@ import type { TypeLambda } from "./HKT.ts"
 import type { Inspectable } from "./Inspectable.ts"
 import * as doNotation from "./internal/doNotation.ts"
 import * as option_ from "./internal/option.ts"
+import * as InternalRecord from "./internal/record.ts"
 import * as result from "./internal/result.ts"
 import type { Option } from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
@@ -46,18 +47,13 @@ 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
@@ -80,14 +76,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"
  * }
  * ```
  *
@@ -143,14 +138,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
  * }
  * ```
  *
@@ -212,7 +206,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 {
@@ -225,8 +219,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>
  *
@@ -235,6 +229,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
@@ -243,14 +240,14 @@ export declare namespace Result {
   /**
    * Extracts the failure type `E` from `Result<A, E>`.
    *
-   * @category Type Level
+   * @category utility types
    * @since 4.0.0
    */
   export 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
    */
   export type Success<T extends Result<any, any>> = [T] extends [Result<infer _A, infer _E>] ? _A : never
@@ -266,13 +263,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
@@ -296,13 +290,10 @@ export const succeed: <A>(right: A) => Result<A> = result.succeed
  *
  * **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
@@ -330,13 +321,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
@@ -363,13 +351,10 @@ export {
  *
  * **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
@@ -396,14 +381,12 @@ export const failVoid: Result<never, void> = fail(void 0)
  *
  * **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
@@ -430,14 +413,12 @@ export 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
@@ -464,14 +445,12 @@ export 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
@@ -503,16 +482,12 @@ export 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
@@ -539,16 +514,12 @@ export 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
@@ -575,16 +546,12 @@ export 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
@@ -639,19 +606,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
@@ -677,14 +641,12 @@ export {
  *
  * **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
@@ -708,14 +670,13 @@ export const isResult: (input: unknown) => input is Result<unknown, unknown> = r
  *
  * **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"
  * }
  * ```
  *
@@ -741,14 +702,13 @@ export const isFailure: <A, E>(self: Result<A, E>) => self is Failure<A, E> = re
  *
  * **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
  * }
  * ```
  *
@@ -775,14 +735,12 @@ export const isSuccess: <A, E>(self: Result<A, E>) => self is Success<A, E> = re
  *
  * **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
@@ -808,14 +766,12 @@ export const getSuccess: <A, E>(self: Result<A, E>) => Option<A> = result.getSuc
  *
  * **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
@@ -837,7 +793,7 @@ export const getFailure: <A, E>(self: Result<A, E>) => Option<E> = result.getFai
  *
  * **Example** (Comparing Results for equality)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence, Result } from "effect"
  *
  * const eq = Result.makeEquivalence(
@@ -845,11 +801,9 @@ export const getFailure: <A, E>(self: Result<A, E>) => Option<E> = result.getFai
  *   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
@@ -880,18 +834,16 @@ export const makeEquivalence = <A, E>(
  *
  * **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
@@ -917,18 +869,16 @@ export 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
@@ -959,18 +909,16 @@ export 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
@@ -1009,15 +957,13 @@ export 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
@@ -1041,15 +987,13 @@ export 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
@@ -1073,15 +1017,13 @@ export 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
@@ -1094,7 +1036,7 @@ export const mapError: {
 } = dual(
   2,
   <A, E, E2>(self: Result<A, E>, f: (err: E) => E2): Result<A, E2> =>
-    isFailure(self) ? fail(f(self.failure)) : succeed(self.success)
+    isFailure(self) ? fail(f(self.failure)) : self as unknown as Result<A, E2>
 )
 
 /**
@@ -1113,15 +1055,13 @@ export 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
@@ -1148,15 +1088,13 @@ export 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
@@ -1183,15 +1121,13 @@ export 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
@@ -1205,7 +1141,7 @@ export const map: {
 } = dual(
   2,
   <A, E, A2>(self: Result<A, E>, f: (ok: A) => A2): Result<A2, E> =>
-    isSuccess(self) ? succeed(f(self.success)) : fail(self.failure)
+    isSuccess(self) ? succeed(f(self.success)) : self as unknown as Result<A2, E>
 )
 
 /**
@@ -1224,7 +1160,7 @@ export const map: {
  *
  * **Example** (Folding to a string)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Result } from "effect"
  *
  * const format = Result.match({
@@ -1232,11 +1168,9 @@ export 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
@@ -1262,7 +1196,7 @@ export const match: {
    *
    * **Example** (Folding to a string)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { pipe, Result } from "effect"
    *
    * const format = Result.match({
@@ -1270,11 +1204,9 @@ export 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
@@ -1305,7 +1237,7 @@ export const match: {
    *
    * **Example** (Folding to a string)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { pipe, Result } from "effect"
    *
    * const format = Result.match({
@@ -1313,11 +1245,9 @@ export 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
@@ -1358,18 +1288,16 @@ export 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`
@@ -1396,18 +1324,16 @@ export 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`
@@ -1434,18 +1360,16 @@ export 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`
@@ -1472,18 +1396,16 @@ export 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`
@@ -1510,18 +1432,16 @@ export 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`
@@ -1556,18 +1476,16 @@ export 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
@@ -1596,18 +1514,16 @@ export 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
@@ -1639,18 +1555,16 @@ export 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
@@ -1679,18 +1593,16 @@ export 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
@@ -1723,18 +1635,16 @@ export 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
@@ -1762,14 +1672,12 @@ export 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
@@ -1796,14 +1704,12 @@ export const merge: <A, E>(self: Result<A, E>) => E | A = match({ onFailure: ide
  *
  * **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
@@ -1831,14 +1737,12 @@ export 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
@@ -1866,14 +1770,12 @@ export 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
@@ -1906,14 +1808,12 @@ export 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
@@ -1939,14 +1839,12 @@ export const getOrNull: <A, E>(self: Result<A, E>) => A | null = getOrElse(const
  *
  * **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
@@ -1972,19 +1870,19 @@ export const getOrUndefined: <A, E>(self: Result<A, E>) => A | undefined = getOr
  *
  * **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
@@ -2009,19 +1907,19 @@ export 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
@@ -2046,19 +1944,19 @@ export 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
@@ -2090,14 +1988,13 @@ export 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
@@ -2124,15 +2021,13 @@ export const getOrThrow: <A, E>(self: Result<A, E>) => A = getOrThrowWith(identi
  *
  * **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)
@@ -2158,15 +2053,13 @@ export 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)
@@ -2192,15 +2085,13 @@ export 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)
@@ -2233,17 +2124,15 @@ export 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
@@ -2270,17 +2159,15 @@ export 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
@@ -2307,17 +2194,15 @@ export 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
@@ -2353,25 +2238,23 @@ export 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)
@@ -2401,25 +2284,23 @@ export 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)
@@ -2449,25 +2330,23 @@ export 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)
@@ -2497,25 +2376,23 @@ export 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)
@@ -2545,25 +2422,23 @@ export 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)
@@ -2593,25 +2468,23 @@ export 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)
@@ -2641,25 +2514,23 @@ export 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)
@@ -2689,25 +2560,23 @@ export 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)
@@ -2737,25 +2606,23 @@ export 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)
@@ -2796,18 +2663,14 @@ export 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
@@ -2847,7 +2710,7 @@ export const all: <const I extends Iterable<Result<any, any>> | Record<string, R
       if (isFailure(e)) {
         return e
       }
-      out[key] = e.success
+      InternalRecord.assignProperty(out, key, e.success)
     }
     return succeed(out)
   }
@@ -2869,14 +2732,12 @@ export const all: <const I extends Iterable<Result<any, any>> | Record<string, R
  *
  * **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
@@ -2904,17 +2765,14 @@ export 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
@@ -2958,17 +2816,15 @@ export const gen: Gen.Gen<ResultTypeLambda> = (...args) => {
  *
  * **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
@@ -2976,7 +2832,7 @@ export const gen: Gen.Gen<ResultTypeLambda> = (...args) => {
  * @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 const Do: Result<{}> = succeed({})
@@ -2999,23 +2855,21 @@ export const Do: Result<{}> = succeed({})
  *
  * **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 const bind: {
@@ -3037,23 +2891,21 @@ export 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<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, L1 | L2>
@@ -3075,23 +2927,21 @@ export 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>(
@@ -3117,21 +2967,19 @@ export 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 const bindTo: {
@@ -3151,21 +2999,19 @@ export 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>
@@ -3185,21 +3031,19 @@ export 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>
@@ -3234,23 +3078,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
@@ -3272,21 +3114,17 @@ export {
  *
  * **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 const transposeOption = <A = never, E = never>(
@@ -3312,7 +3150,7 @@ export const transposeOption = <A = never, E = never>(
  *
  * **Example** (Mapping and transposing in one step)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Option, Result } from "effect"
  *
  * const parse = (s: string) =>
@@ -3320,16 +3158,14 @@ export const transposeOption = <A = never, E = never>(
  *     ? 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 const transposeMapOption = dual<
@@ -3350,7 +3186,7 @@ export const transposeMapOption = dual<
    *
    * **Example** (Mapping and transposing in one step)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Option, Result } from "effect"
    *
    * const parse = (s: string) =>
@@ -3358,16 +3194,14 @@ export const transposeMapOption = dual<
    *     ? 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
    */
   <A, B, E = never>(f: (self: A) => Result<B, E>) => (self: Option<A>) => Result<Option<B>, E>,
@@ -3388,7 +3222,7 @@ export const transposeMapOption = dual<
    *
    * **Example** (Mapping and transposing in one step)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Option, Result } from "effect"
    *
    * const parse = (s: string) =>
@@ -3396,16 +3230,14 @@ export const transposeMapOption = dual<
    *     ? 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
    */
   <A, B, E = never>(self: Option<A>, f: (self: A) => Result<B, E>) => Result<Option<B>, E>
@@ -3426,11 +3258,10 @@ export const transposeMapOption = dual<
  *
  * **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
@@ -3452,12 +3283,10 @@ export const succeedNone = succeed(option_.none)
  *
  * **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
@@ -3479,17 +3308,17 @@ export const succeedSome = <A, E = never>(a: A): Result<Option<A>, E> => succeed
  *
  * **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
@@ -3510,17 +3339,17 @@ export 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
@@ -3541,17 +3370,17 @@ export 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