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

package/dist/Result.js

@@ -27,13 +27,10 @@ const TypeId = "~effect/data/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
@@ -56,13 +53,10 @@ export const succeed = 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
@@ -89,13 +83,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
@@ -120,13 +111,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
@@ -152,14 +140,12 @@ export const failVoid = /*#__PURE__*/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
@@ -185,16 +171,12 @@ export const fromNullishOr = /*#__PURE__*/dual(2, (self, onNullish) => self == n
  *
  * **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
@@ -233,19 +215,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
@@ -269,14 +248,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
@@ -299,14 +276,13 @@ export const isResult = result.isResult;
  *
  * **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"
  * }
  * ```
  *
@@ -331,14 +307,13 @@ export const isFailure = result.isFailure;
  *
  * **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
  * }
  * ```
  *
@@ -364,14 +339,12 @@ export const isSuccess = result.isSuccess;
  *
  * **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
@@ -396,14 +369,12 @@ export const getSuccess = result.getSuccess;
  *
  * **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
@@ -424,7 +395,7 @@ export const getFailure = result.getFailure;
  *
  * **Example** (Comparing Results for equality)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence, Result } from "effect"
  *
  * const eq = Result.makeEquivalence(
@@ -432,11 +403,9 @@ export const getFailure = result.getFailure;
  *   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
@@ -458,18 +427,16 @@ export const makeEquivalence = (success, failure) => Equivalence.make((x, y) =>
  *
  * **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
@@ -497,15 +464,13 @@ export const mapBoth = /*#__PURE__*/dual(2, (self, {
  *
  * **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
@@ -514,7 +479,7 @@ export const mapBoth = /*#__PURE__*/dual(2, (self, {
  * @category mapping
  * @since 4.0.0
  */
-export const mapError = /*#__PURE__*/dual(2, (self, f) => isFailure(self) ? fail(f(self.failure)) : succeed(self.success));
+export const mapError = /*#__PURE__*/dual(2, (self, f) => isFailure(self) ? fail(f(self.failure)) : self);
 /**
  * Transforms the success channel of a `Result`, leaving the failure channel unchanged.
  *
@@ -531,15 +496,13 @@ export const mapError = /*#__PURE__*/dual(2, (self, f) => isFailure(self) ? fail
  *
  * **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
@@ -549,7 +512,7 @@ export const mapError = /*#__PURE__*/dual(2, (self, f) => isFailure(self) ? fail
  * @category mapping
  * @since 2.0.0
  */
-export const map = /*#__PURE__*/dual(2, (self, f) => isSuccess(self) ? succeed(f(self.success)) : fail(self.failure));
+export const map = /*#__PURE__*/dual(2, (self, f) => isSuccess(self) ? succeed(f(self.success)) : self);
 /**
  * Folds a `Result` into a single value by applying one of two functions.
  *
@@ -566,7 +529,7 @@ export const map = /*#__PURE__*/dual(2, (self, f) => isSuccess(self) ? succeed(f
  *
  * **Example** (Folding to a string)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Result } from "effect"
  *
  * const format = Result.match({
@@ -574,11 +537,9 @@ export const map = /*#__PURE__*/dual(2, (self, f) => isSuccess(self) ? succeed(f
  *   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
@@ -608,18 +569,16 @@ export const match = /*#__PURE__*/dual(2, (self, {
  *
  * **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`
@@ -648,18 +607,16 @@ export const liftPredicate = /*#__PURE__*/dual(3, (a, predicate, orFailWith) =>
  *
  * **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
@@ -681,14 +638,12 @@ export const filterOrFail = /*#__PURE__*/dual(3, (self, predicate, orFailWith) =
  *
  * **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
@@ -717,14 +672,12 @@ export const merge = /*#__PURE__*/match({
  *
  * **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
@@ -751,14 +704,12 @@ export const getOrElse = /*#__PURE__*/dual(2, (self, onFailure) => isFailure(sel
  *
  * **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
@@ -783,14 +734,12 @@ export const getOrNull = /*#__PURE__*/getOrElse(constNull);
  *
  * **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
@@ -815,19 +764,19 @@ export const getOrUndefined = /*#__PURE__*/getOrElse(constUndefined);
  *
  * **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
@@ -857,14 +806,13 @@ export const getOrThrowWith = /*#__PURE__*/dual(2, (self, onFailure) => {
  *
  * **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
@@ -890,15 +838,13 @@ export const getOrThrow = /*#__PURE__*/getOrThrowWith(identity);
  *
  * **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)
@@ -925,17 +871,15 @@ export const orElse = /*#__PURE__*/dual(2, (self, that) => isFailure(self) ? tha
  *
  * **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
@@ -965,25 +909,23 @@ export const flatMap = /*#__PURE__*/dual(2, (self, f) => isFailure(self) ? fail(
  *
  * **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)
@@ -1015,18 +957,14 @@ export const andThen = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a => {
  *
  * **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
@@ -1074,14 +1012,12 @@ export const all = input => {
  *
  * **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
@@ -1107,17 +1043,14 @@ export const flip = self => isFailure(self) ? succeed(self.failure) : fail(self.
  *
  * **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
@@ -1159,17 +1092,15 @@ export const gen = (...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
@@ -1177,7 +1108,7 @@ export const gen = (...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 = /*#__PURE__*/succeed({});
@@ -1199,23 +1130,21 @@ export const Do = /*#__PURE__*/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 = /*#__PURE__*/doNotation.bind(map, flatMap);
@@ -1235,21 +1164,19 @@ export const bind = /*#__PURE__*/doNotation.bind(map, flatMap);
  *
  * **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 = /*#__PURE__*/doNotation.bindTo(map);
@@ -1271,23 +1198,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 };
@@ -1307,21 +1232,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 const transposeOption = self => {
@@ -1344,7 +1265,7 @@ export const transposeOption = self => {
  *
  * **Example** (Mapping and transposing in one step)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Option, Result } from "effect"
  *
  * const parse = (s: string) =>
@@ -1352,16 +1273,14 @@ export const transposeOption = self => {
  *     ? 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 = /*#__PURE__*/dual(2, (self, f) => option_.isNone(self) ? succeedNone : map(f(self.value), option_.some));
@@ -1380,11 +1299,10 @@ export const transposeMapOption = /*#__PURE__*/dual(2, (self, f) => option_.isNo
  *
  * **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
@@ -1405,12 +1323,10 @@ export const succeedNone = /*#__PURE__*/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
@@ -1431,17 +1347,17 @@ export const succeedSome = a => succeed(option_.some(a));
  *
  * **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