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

package/dist/Optic.js

@@ -11,12 +11,13 @@
  *
  * @since 4.0.0
  */
-import { format } from "./Formatter.js";
-import { identity, memoize } from "./Function.js";
+import { identity } from "./Function.js";
+import * as InternalRecord from "./internal/record.js";
 import * as Option from "./Option.js";
 import * as Predicate from "./Predicate.js";
 import * as Result from "./Result.js";
 import * as SchemaAST from "./SchemaAST.js";
+import * as SchemaIssue from "./SchemaIssue.js";
 import * as Struct from "./Struct.js";
 /**
  * Creates an {@link Iso} from a pair of conversion functions.
@@ -32,7 +33,7 @@ import * as Struct from "./Struct.js";
  *
  * **Example** (Wrapping and unwrapping a branded type)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Optic } from "effect"
  *
  * type Meters = { readonly value: number }
@@ -41,11 +42,9 @@ import * as Struct from "./Struct.js";
  *   (n) => ({ value: n })
  * )
  *
- * console.log(meters.get({ value: 100 }))
- * // Output: 100
+ * meters.get({ value: 100 }) // => 100
  *
- * console.log(meters.set(42))
- * // Output: { value: 42 }
+ * meters.set(42) // => { value: 42 }
  * ```
  *
  * @see {@link Iso} — the type this function returns
@@ -55,7 +54,7 @@ import * as Struct from "./Struct.js";
  * @since 4.0.0
  */
 export function makeIso(get, set) {
-  return make(new IsoNode(get, set));
+  return make(primitiveNode("Iso", get, set));
 }
 /**
  * Creates a {@link Lens} from a getter and a replacer.
@@ -72,7 +71,7 @@ export function makeIso(get, set) {
  *
  * **Example** (Focusing on the first element of a pair)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Optic } from "effect"
  *
  * const _first = Optic.makeLens<readonly [string, number], string>(
@@ -80,11 +79,9 @@ export function makeIso(get, set) {
  *   (s, pair) => [s, pair[1]]
  * )
  *
- * console.log(_first.get(["hello", 42]))
- * // Output: "hello"
+ * _first.get(["hello", 42]) // => "hello"
  *
- * console.log(_first.replace("world", ["hello", 42]))
- * // Output: ["world", 42]
+ * _first.replace("world", ["hello", 42]) // => ["world", 42]
  * ```
  *
  * @see {@link Lens} — the type this function returns
@@ -94,7 +91,7 @@ export function makeIso(get, set) {
  * @since 4.0.0
  */
 export function makeLens(get, replace) {
-  return make(new LensNode(get, replace));
+  return make(primitiveNode("Lens", get, replace));
 }
 /**
  * Creates a {@link Prism} from a fallible getter and an infallible setter.
@@ -106,26 +103,27 @@ export function makeLens(get, replace) {
  *
  * **Details**
  *
- * - `getResult` should return `Result.fail(message)` on mismatch.
+ * - `getResult` should return `Result.fail(issue)` on mismatch.
+ * - Issues are not formatted automatically; callers choose how to render them.
  *
  * **Example** (Parsing a string to a number)
  *
- * ```ts
- * import { Optic, Result } from "effect"
+ * ```ts import.meta.vitest
+ * import { Optic, Result, SchemaIssue } from "effect"
  *
  * const numeric = Optic.makePrism<string, number>(
  *   (s) => {
  *     const n = Number(s)
- *     return Number.isNaN(n) ? Result.fail("not a number") : Result.succeed(n)
+ *     return Number.isNaN(n)
+ *       ? Result.fail(new SchemaIssue.InvalidValue({ message: "not a number" }))
+ *       : Result.succeed(n)
  *   },
  *   String
  * )
  *
- * console.log(Result.isSuccess(numeric.getResult("42")))
- * // Output: true
+ * numeric.getResult("42") // => Result.succeed(42)
  *
- * console.log(numeric.set(42))
- * // Output: "42"
+ * numeric.set(42) // => "42"
  * ```
  *
  * @see {@link Prism} — the type this function returns
@@ -135,7 +133,7 @@ export function makeLens(get, replace) {
  * @since 4.0.0
  */
 export function makePrism(getResult, set) {
-  return make(new PrismNode(getResult, set));
+  return make(primitiveNode("Prism", getResult, set));
 }
 /**
  * Creates a {@link Prism} from one or more `Schema` validation checks.
@@ -148,13 +146,13 @@ export function makePrism(getResult, set) {
  *
  * **Details**
  *
- * - `getResult` runs all checks; fails with a combined error message when
+ * - `getResult` runs all checks and preserves their structured issues when
  *   any check fails.
  * - `set` is identity — the value passes through unchanged.
  *
  * **Example** (Creating a positive integer prism)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Optic, Result, Schema } from "effect"
  *
  * const posInt = Optic.fromChecks<number>(
@@ -162,11 +160,9 @@ export function makePrism(getResult, set) {
  *   Schema.isInt()
  * )
  *
- * console.log(Result.isSuccess(posInt.getResult(3)))
- * // Output: true
+ * posInt.getResult(3) // => Result.succeed(3)
  *
- * console.log(Result.isFailure(posInt.getResult(-1)))
- * // Output: true
+ * Result.isFailure(posInt.getResult(-1)) // => true
  * ```
  *
  * @see {@link makePrism} — constructor with custom getter/setter
@@ -176,109 +172,77 @@ export function makePrism(getResult, set) {
  * @since 4.0.0
  */
 export function fromChecks(...checks) {
-  return make(new CheckNode(checks));
-}
-class IdentityNode {
-  _tag = "IdentityNode";
-}
-const identityNode = /*#__PURE__*/new IdentityNode();
-class CompositionNode {
-  _tag = "CompositionNode";
-  nodes;
-  constructor(nodes) {
-    this.nodes = nodes;
-  }
-}
-class IsoNode {
-  _tag = "IsoNode";
-  get;
-  set;
-  constructor(get, set) {
-    this.get = get;
-    this.set = set;
-  }
-}
-class LensNode {
-  _tag = "LensNode";
-  get;
-  set;
-  constructor(get, set) {
-    this.get = get;
-    this.set = set;
-  }
-}
-class PrismNode {
-  _tag = "PrismNode";
-  get;
-  set;
-  constructor(get, set) {
-    this.get = get;
-    this.set = set;
-  }
-}
-class OptionalNode {
-  _tag = "OptionalNode";
-  get;
-  set;
-  constructor(get, set) {
-    this.get = get;
-    this.set = set;
-  }
-}
+  return make([new CheckNode(checks)]);
+}
+function primitiveNode(kind, get, set) {
+  return [{
+    _tag: "PrimitiveNode",
+    kind,
+    get,
+    set
+  }];
+}
+const identityOperation = {
+  kind: "Iso",
+  get: identity,
+  set: identity
+};
 class PathNode {
   _tag = "PathNode";
+  kind = "Lens";
   path;
+  get;
+  set;
   constructor(path) {
     this.path = path;
+    this.get = s => {
+      let out = s;
+      for (let i = 0; i < path.length; i++) {
+        out = out[path[i]];
+      }
+      return out;
+    };
+    this.set = (a, s) => {
+      const out = cloneShallow(s);
+      let current = out;
+      let i = 0;
+      for (; i < path.length - 1; i++) {
+        const key = path[i];
+        InternalRecord.assignProperty(current, key, cloneShallow(current[key]));
+        current = current[key];
+      }
+      InternalRecord.assignProperty(current, path[i], a);
+      return out;
+    };
   }
 }
 class CheckNode {
   _tag = "CheckNode";
+  kind = "Prism";
   checks;
+  get;
+  set = identity;
   constructor(checks) {
     this.checks = checks;
+    this.get = s => SchemaAST.runChecks(checks, s);
   }
 }
-// Fuse with tail when possible, else push.
-function pushNormalized(acc, node) {
-  const last = acc[acc.length - 1];
-  if (last) {
+function compose(a, b) {
+  if (a.length === 0) return b;
+  if (b.length === 0) return a;
+  const nodes = a.slice();
+  for (let i = 0; i < b.length; i++) {
+    const node = b[i];
+    const last = nodes[nodes.length - 1];
     if (last._tag === "PathNode" && node._tag === "PathNode") {
-      // fuse Path
-      acc[acc.length - 1] = new PathNode([...last.path, ...node.path]);
-      return;
+      nodes[nodes.length - 1] = new PathNode([...last.path, ...node.path]);
+    } else if (last._tag === "CheckNode" && node._tag === "CheckNode") {
+      nodes[nodes.length - 1] = new CheckNode([...last.checks, ...node.checks]);
+    } else {
+      nodes.push(node);
     }
-    if (last._tag === "CheckNode" && node._tag === "CheckNode") {
-      // fuse Checks
-      acc[acc.length - 1] = new CheckNode([...last.checks, ...node.checks]);
-      return;
-    }
-  }
-  acc.push(node);
-}
-// Collect nodes from a node into `acc`, flattening & normalizing on the fly.
-function collect(node, acc) {
-  if (node._tag === "IdentityNode") return;
-  if (node._tag === "CompositionNode") {
-    // flatten without extra arrays
-    for (let i = 0; i < node.nodes.length; i++) collect(node.nodes[i], acc);
-    return;
-  }
-  // primitive node
-  pushNormalized(acc, node);
-}
-function compose(a, b) {
-  const nodes = [];
-  collect(a, nodes);
-  collect(b, nodes);
-  switch (nodes.length) {
-    case 0:
-      return identityNode;
-    case 1:
-      return nodes[0];
-    default:
-      return new CompositionNode(nodes);
   }
+  return nodes;
 }
 /**
  * Creates an {@link Optional} from a fallible getter and a fallible setter.
@@ -290,29 +254,31 @@ function compose(a, b) {
  *
  * **Details**
  *
- * - `getResult` should return `Result.fail(message)` on mismatch.
- * - `set` should return `Result.fail(message)` when the update cannot be
+ * - `getResult` should return `Result.fail(issue)` on mismatch.
+ * - `set` should return `Result.fail(issue)` when the update cannot be
  *   applied.
+ * - Issues are not formatted automatically; callers choose how to render them.
  *
  * **Example** (Accessing record keys safely)
  *
- * ```ts
- * import { Optic, Result } from "effect"
+ * ```ts import.meta.vitest
+ * import { Optic, Result, SchemaIssue } from "effect"
  *
- * const atKey = (key: string) =>
- *   Optic.makeOptional<Record<string, number>, number>(
+ * const atKey = (key: string) => {
+ *   const issue = new SchemaIssue.Pointer([key], new SchemaIssue.MissingKey(undefined))
+ *   return Optic.makeOptional<Record<string, number>, number>(
  *     (s) =>
  *       Object.hasOwn(s, key)
  *         ? Result.succeed(s[key])
- *         : Result.fail(`Key "${key}" not found`),
+ *         : Result.fail(issue),
  *     (a, s) =>
  *       Object.hasOwn(s, key)
  *         ? Result.succeed({ ...s, [key]: a })
- *         : Result.fail(`Key "${key}" not found`)
+ *         : Result.fail(issue)
  *   )
+ * }
  *
- * console.log(Result.isSuccess(atKey("x").getResult({ x: 1 })))
- * // Output: true
+ * atKey("x").getResult({ x: 1 }) // => Result.succeed(1)
  * ```
  *
  * @see {@link Optional} — the type this function returns
@@ -323,9 +289,10 @@ function compose(a, b) {
  * @since 4.0.0
  */
 export function makeOptional(getResult, set) {
-  return make(new OptionalNode(getResult, set));
+  return make(primitiveNode("Optional", getResult, set));
 }
 class OptionalImpl {
+  /** @internal */
   node;
   getResult;
   replaceResult;
@@ -344,10 +311,10 @@ class OptionalImpl {
     return make(compose(this.node, that.node));
   }
   key(key) {
-    return make(compose(this.node, new PathNode([key])));
+    return make(compose(this.node, [new PathNode([key])]));
   }
   optionalKey(key) {
-    return make(compose(this.node, new LensNode(s => s[key], (a, s) => {
+    return make(compose(this.node, primitiveNode("Lens", s => s[key], (a, s) => {
       const copy = cloneShallow(s);
       if (a === undefined) {
         if (Array.isArray(copy) && typeof key === "number") {
@@ -356,26 +323,29 @@ class OptionalImpl {
           delete copy[key];
         }
       } else {
-        copy[key] = a;
+        InternalRecord.assignProperty(copy, key, a);
       }
       return copy;
     })));
   }
   check(...checks) {
-    return make(compose(this.node, new CheckNode(checks)));
+    return make(compose(this.node, [new CheckNode(checks)]));
   }
   refine(refinement, annotations) {
-    return make(compose(this.node, new CheckNode([SchemaAST.makeFilterByGuard(refinement, annotations)])));
+    return make(compose(this.node, [new CheckNode([SchemaAST.makeFilterByGuard(refinement, annotations)])]));
   }
   tag(tag) {
-    return make(compose(this.node, new PrismNode(s => s._tag === tag ? Result.succeed(s) : Result.fail(`Expected ${format(tag)} tag, got ${format(s._tag)}`), identity)));
+    const err = Result.fail(new SchemaIssue.InvalidValue({
+      expected: `${JSON.stringify(tag)} tag`
+    }));
+    return make(compose(this.node, primitiveNode("Prism", s => s._tag === tag ? Result.succeed(s) : err, identity)));
   }
   at(key, ..._rest) {
-    const err = Result.fail(`Key ${format(key)} not found`);
-    return make(compose(this.node, new OptionalNode(s => Object.hasOwn(s, key) ? Result.succeed(s[key]) : err, (a, s) => {
+    const err = Result.fail(new SchemaIssue.Pointer([key], new SchemaIssue.MissingKey(undefined)));
+    return make(compose(this.node, primitiveNode("Optional", s => Object.hasOwn(s, key) ? Result.succeed(s[key]) : err, (a, s) => {
       if (Object.hasOwn(s, key)) {
         const copy = cloneShallow(s);
-        copy[key] = a;
+        InternalRecord.assignProperty(copy, key, a);
         return Result.succeed(copy);
       } else {
         return err;
@@ -420,7 +390,9 @@ class OptionalImpl {
       }
       // 2) arity check
       if (bs.length !== idxs.length) {
-        return Result.fail(`each: replacement length mismatch: ${bs.length} !== ${idxs.length}`);
+        return Result.fail(new SchemaIssue.InvalidValue({
+          message: `each: replacement length mismatch: ${bs.length} !== ${idxs.length}`
+        }));
       }
       // 3) update those indices
       const out = as.slice();
@@ -428,7 +400,7 @@ class OptionalImpl {
         const i = idxs[k];
         const r = inner.replaceResult(bs[k], as[i]);
         if (Result.isFailure(r)) {
-          return Result.fail(`each: could not set element ${i}`);
+          return Result.fail(new SchemaIssue.Pointer([i], r.failure));
         }
         out[i] = r.success;
       }
@@ -479,15 +451,23 @@ class PrismImpl extends OptionalImpl {
   }
 }
 function make(node) {
-  const op = recur(node);
-  switch (op._tag) {
-    case "IsoNode":
+  let op = node[0] ?? identityOperation;
+  if (node.length > 1) {
+    const kind = node.reduce((kind, step) => composeKind(kind, step.kind), "Iso");
+    op = {
+      kind,
+      get: compileGet(node, kind),
+      set: compileSet(node, kind)
+    };
+  }
+  switch (op.kind) {
+    case "Iso":
       return new IsoImpl(node, op.get, op.set);
-    case "LensNode":
+    case "Lens":
       return new LensImpl(node, op.get, op.set);
-    case "PrismNode":
+    case "Prism":
       return new PrismImpl(node, op.get, op.set);
-    case "OptionalNode":
+    case "Optional":
       return new OptionalImpl(node, op.get, op.set);
   }
 }
@@ -504,133 +484,75 @@ function cloneShallow(pojo) {
   }
   return pojo;
 }
-const recur = /*#__PURE__*/memoize(node => {
-  switch (node._tag) {
-    case "IdentityNode":
-      return {
-        _tag: "IsoNode",
-        get: identity,
-        set: identity
-      };
-    case "IsoNode":
-    case "LensNode":
-    case "PrismNode":
-    case "OptionalNode":
-      return {
-        _tag: node._tag,
-        get: node.get,
-        set: node.set
-      };
-    case "PathNode":
-      {
-        return {
-          _tag: "LensNode",
-          get: s => {
-            const path = node.path;
-            let out = s;
-            for (let i = 0, n = path.length; i < n; i++) {
-              out = out[path[i]];
-            }
-            return out;
-          },
-          set: (a, s) => {
-            const path = node.path;
-            const out = cloneShallow(s);
-            let current = out;
-            let i = 0;
-            for (; i < path.length - 1; i++) {
-              const key = path[i];
-              current[key] = cloneShallow(current[key]);
-              current = current[key];
-            }
-            const finalKey = path[i];
-            current[finalKey] = a;
-            return out;
-          }
-        };
+function compileGet(nodes, kind) {
+  return s => {
+    for (let i = 0; i < nodes.length; i++) {
+      const op = nodes[i];
+      const result = op.get(s);
+      if (hasFailingGet(op.kind)) {
+        if (Result.isFailure(result)) {
+          return result;
+        }
+        s = result.success;
+      } else {
+        s = result;
       }
-    case "CheckNode":
-      return {
-        _tag: "PrismNode",
-        get: s => Result.mapError(SchemaAST.runChecks(node.checks, s), String),
-        set: identity
-      };
-    case "CompositionNode":
-      {
-        const ops = node.nodes.map(recur);
-        const _tag = ops.reduce((tag, op) => getCompositionTag(tag, op._tag), "IsoNode");
-        return {
-          _tag,
-          get: s => {
-            for (let i = 0; i < ops.length; i++) {
-              const op = ops[i];
-              const result = op.get(s);
-              if (hasFailingGet(op._tag)) {
-                if (Result.isFailure(result)) {
-                  return result;
-                }
-                s = result.success;
-              } else {
-                s = result;
-              }
-            }
-            return hasFailingGet(_tag) ? Result.succeed(s) : s;
-          },
-          set: (a, s) => {
-            const source = s;
-            const len = ops.length;
-            const ss = new Array(len + 1);
-            ss[0] = s;
-            for (let i = 0; i < len; i++) {
-              const op = ops[i];
-              if (hasFailingGet(op._tag)) {
-                const result = op.get(s);
-                if (Result.isFailure(result)) {
-                  return _tag === "OptionalNode" ? result : source;
-                }
-                s = result.success;
-              } else {
-                s = op.get(s);
-              }
-              ss[i + 1] = s;
-            }
-            for (let i = len - 1; i >= 0; i--) {
-              const op = ops[i];
-              if (hasSet(op._tag)) {
-                a = op.set(a);
-              } else if (op._tag === "LensNode") {
-                a = op.set(a, ss[i]);
-              } else {
-                const result = op.set(a, ss[i]);
-                if (Result.isFailure(result)) {
-                  return result;
-                }
-                a = result.success;
-              }
-            }
-            return _tag === "OptionalNode" ? Result.succeed(a) : a;
-          }
-        };
+    }
+    return hasFailingGet(kind) ? Result.succeed(s) : s;
+  };
+}
+function compileSet(nodes, kind) {
+  if (hasSourceFreeSet(kind)) {
+    return a => {
+      for (let i = nodes.length - 1; i >= 0; i--) {
+        a = nodes[i].set(a);
       }
+      return a;
+    };
   }
-});
-function hasFailingGet(tag) {
-  return tag === "PrismNode" || tag === "OptionalNode";
+  return (a, s) => {
+    const len = nodes.length;
+    const sources = new Array(len);
+    for (let i = 0; i < len; i++) {
+      sources[i] = s;
+      const op = nodes[i];
+      if (hasFailingGet(op.kind)) {
+        const result = op.get(s);
+        if (Result.isFailure(result)) {
+          return result;
+        }
+        s = result.success;
+      } else {
+        s = op.get(s);
+      }
+    }
+    for (let i = len - 1; i >= 0; i--) {
+      const op = nodes[i];
+      if (hasSourceFreeSet(op.kind)) {
+        a = op.set(a);
+      } else if (op.kind === "Lens") {
+        a = op.set(a, sources[i]);
+      } else {
+        const result = op.set(a, sources[i]);
+        if (Result.isFailure(result)) {
+          return result;
+        }
+        a = result.success;
+      }
+    }
+    return kind === "Optional" ? Result.succeed(a) : a;
+  };
 }
-function hasSet(tag) {
-  return tag === "IsoNode" || tag === "PrismNode";
+function hasFailingGet(kind) {
+  return kind === "Prism" || kind === "Optional";
 }
-function getCompositionTag(a, b) {
-  switch (a) {
-    case "IsoNode":
-      return b;
-    case "LensNode":
-      return hasFailingGet(b) ? "OptionalNode" : "LensNode";
-    case "PrismNode":
-      return hasSet(b) ? "PrismNode" : "OptionalNode";
-    case "OptionalNode":
-      return "OptionalNode";
-  }
+function hasSourceFreeSet(kind) {
+  return kind === "Iso" || kind === "Prism";
+}
+function composeKind(a, b) {
+  if (a === "Iso") return b;
+  if (b === "Iso" || a === b) return a;
+  return "Optional";
 }
 // ---------------------------------------------
 // Derived APIs
@@ -651,7 +573,7 @@ function getCompositionTag(a, b) {
  *
  * **Example** (Collecting positive numbers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Optic, Schema } from "effect"
  *
  * type S = { readonly values: ReadonlyArray<number> }
@@ -662,16 +584,14 @@ function getCompositionTag(a, b) {
  *
  * const getPositive = Optic.getAll(_pos)
  *
- * console.log(getPositive({ values: [3, -1, 5] }))
- * // Output: [3, 5]
+ * getPositive({ values: [3, -1, 5] }) // => [3, 5]
  *
- * console.log(getPositive({ values: [-1, -2] }))
- * // Output: []
+ * getPositive({ values: [-1, -2] }) // => []
  * ```
  *
  * @see {@link Traversal} — the optic type this operates on
  *
- * @category Traversal
+ * @category getters
  * @since 4.0.0
  */
 export function getAll(traversal) {
@@ -683,7 +603,7 @@ export function getAll(traversal) {
 // ---------------------------------------------
 // Built-in Optics
 // ---------------------------------------------
-const identityIso = /*#__PURE__*/make(identityNode);
+const identityIso = /*#__PURE__*/make([]);
 /**
  * Iso that focuses on the whole value unchanged.
  *
@@ -699,20 +619,19 @@ const identityIso = /*#__PURE__*/make(identityNode);
  *
  * **Example** (Starting an optic chain)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Optic } from "effect"
  *
  * type S = { readonly x: number }
  *
  * const _x = Optic.id<S>().key("x")
  *
- * console.log(_x.get({ x: 42 }))
- * // Output: 42
+ * _x.get({ x: 42 }) // => 42
  * ```
  *
  * @see {@link Iso} — the type this function returns
  *
- * @category Iso
+ * @category constructors
  * @since 4.0.0
  */
 export function id() {
@@ -735,7 +654,7 @@ export function id() {
  *
  * **Example** (Traversing record values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Optic, Schema } from "effect"
  *
  * const _positiveValues = Optic.entries<number>()
@@ -743,18 +662,17 @@ export function id() {
  *
  * const inc = _positiveValues.modifyAll((n) => n + 1)
  *
- * console.log(inc({ a: 0, b: 3, c: -1 }))
- * // Output: { a: 0, b: 4, c: -1 }
+ * inc({ a: 0, b: 3, c: -1 }) // => { a: 0, b: 4, c: -1 }
  * ```
  *
  * @see {@link Iso} — the type this function returns
  * @see {@link id} — identity iso
  *
- * @category Iso
+ * @category constructors
  * @since 4.0.0
  */
 export function entries() {
-  return make(new IsoNode(Object.entries, Object.fromEntries));
+  return make(primitiveNode("Iso", Object.entries, Object.fromEntries));
 }
 /**
  * Prism that focuses on the value inside `Option.Some`.
@@ -766,40 +684,34 @@ export function entries() {
  *
  * **Details**
  *
- * - `getResult` fails with an error message when the option is `None`.
+ * - `getResult` fails with a structured issue when the option is `None`.
  * - `set(a)` wraps `a` in `Option.some(a)`.
  *
  * **Example** (Accessing Some value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Optic, Option, Result } from "effect"
  *
  * const _some = Optic.id<Option.Option<number>>().compose(Optic.some())
  *
- * console.log(Result.isSuccess(_some.getResult(Option.some(42))))
- * // Output: true
+ * _some.getResult(Option.some(42)) // => Result.succeed(42)
  *
- * console.log(Result.isFailure(_some.getResult(Option.none())))
- * // Output: true
+ * Result.isFailure(_some.getResult(Option.none())) // => true
  *
- * console.log(_some.set(10))
- * // Output: { _tag: "Some", value: 10 }
+ * _some.set(10) // => Option.some(10)
  * ```
  *
  * @see {@link none} — focuses on `None` instead
  * @see {@link Prism} — the type this function returns
  *
- * @category Prism
+ * @category constructors
  * @since 4.0.0
  */
 export function some() {
   const run = runRefinement(Option.isSome, {
     expected: "a Some value"
   });
-  return makePrism(s => Result.mapBoth(run(s), {
-    onFailure: String,
-    onSuccess: s => s.value
-  }), Option.some);
+  return makePrism(s => Result.map(run(s), s => s.value), Option.some);
 }
 /**
  * Prism that focuses on `Option.None`, exposing `undefined`.
@@ -816,32 +728,27 @@ export function some() {
  *
  * **Example** (Matching None)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Optic, Option, Result } from "effect"
  *
  * const _none = Optic.id<Option.Option<number>>().compose(Optic.none())
  *
- * console.log(Result.isSuccess(_none.getResult(Option.none())))
- * // Output: true
+ * _none.getResult(Option.none()) // => Result.succeed(undefined)
  *
- * console.log(Result.isFailure(_none.getResult(Option.some(1))))
- * // Output: true
+ * Result.isFailure(_none.getResult(Option.some(1))) // => true
  * ```
  *
  * @see {@link some} — focuses on `Some` instead
  * @see {@link Prism} — the type this function returns
  *
- * @category Prism
+ * @category constructors
  * @since 4.0.0
  */
 export function none() {
   const run = runRefinement(Option.isNone, {
     expected: "a None value"
   });
-  return makePrism(s => Result.mapBoth(run(s), {
-    onFailure: String,
-    onSuccess: () => undefined
-  }), () => Option.none());
+  return makePrism(s => Result.map(run(s), () => undefined), () => Option.none());
 }
 /**
  * Prism that focuses on the success value of a `Result`.
@@ -858,32 +765,27 @@ export function none() {
  *
  * **Example** (Accessing success)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Optic, Result } from "effect"
  *
  * const _ok = Optic.id<Result.Result<number, string>>().compose(Optic.success())
  *
- * console.log(Result.isSuccess(_ok.getResult(Result.succeed(42))))
- * // Output: true
+ * _ok.getResult(Result.succeed(42)) // => Result.succeed(42)
  *
- * console.log(Result.isFailure(_ok.getResult(Result.fail("err"))))
- * // Output: true
+ * Result.isFailure(_ok.getResult(Result.fail("err"))) // => true
  * ```
  *
  * @see {@link failure} — focuses on the failure side
  * @see {@link Prism} — the type this function returns
  *
- * @category Prism
+ * @category constructors
  * @since 4.0.0
  */
 export function success() {
   const run = runRefinement(Result.isSuccess, {
     expected: "a Result.Success value"
   });
-  return makePrism(s => Result.mapBoth(run(s), {
-    onFailure: String,
-    onSuccess: s => s.success
-  }), Result.succeed);
+  return makePrism(s => Result.map(run(s), s => s.success), Result.succeed);
 }
 /**
  * Prism that focuses on the failure value of a `Result`.
@@ -900,32 +802,27 @@ export function success() {
  *
  * **Example** (Accessing failure)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Optic, Result } from "effect"
  *
  * const _err = Optic.id<Result.Result<number, string>>().compose(Optic.failure())
  *
- * console.log(Result.isSuccess(_err.getResult(Result.fail("oops"))))
- * // Output: true
+ * _err.getResult(Result.fail("oops")) // => Result.succeed("oops")
  *
- * console.log(Result.isFailure(_err.getResult(Result.succeed(42))))
- * // Output: true
+ * Result.isFailure(_err.getResult(Result.succeed(42))) // => true
  * ```
  *
  * @see {@link success} — focuses on the success side
  * @see {@link Prism} — the type this function returns
  *
- * @category Prism
+ * @category constructors
  * @since 4.0.0
  */
 export function failure() {
   const run = runRefinement(Result.isFailure, {
     expected: "a Result.Failure value"
   });
-  return makePrism(s => Result.mapBoth(run(s), {
-    onFailure: String,
-    onSuccess: s => s.failure
-  }), Result.fail);
+  return makePrism(s => Result.map(run(s), s => s.failure), Result.fail);
 }
 function runRefinement(refinement, annotations) {
   return e => SchemaAST.runChecks([SchemaAST.makeFilterByGuard(refinement, annotations)], e);