ts-data-forge 14.4.0 → 14.5.0

package/dist/functional/result/impl/result-safe-unwrap.mjs

@@ -0,0 +1,14 @@
+import { isErr } from './result-is-err.mjs';
+
+function* safeUnwrap(result) {
+  if (isErr(result)) {
+    yield result;
+    throw new Error(
+      "`safeUnwrap()` generator was resumed after yielding an `Err`; it must only be used via `yield*` inside `safeTry()`"
+    );
+  }
+  return result.value;
+}
+
+export { safeUnwrap };
+//# sourceMappingURL=result-safe-unwrap.mjs.map

package/dist/functional/result/impl/result-safe-unwrap.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-safe-unwrap.mjs","sources":["../../../../src/functional/result/impl/result-safe-unwrap.mts"],"sourcesContent":["import { type UnknownResult } from '../result.mjs';\nimport { isErr } from './result-is-err.mjs';\nimport { type NarrowToErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Unwraps a `Result` inside a {@link Result.safeTry} generator body via\n * `yield*`, emulating Rust's `?` operator.\n *\n * If the `Result` is `Ok`, the `yield*` expression evaluates to the contained\n * value and execution continues. If it is `Err`, the error is yielded to\n * {@link Result.safeTry}, which returns it immediately — the rest of the\n * generator body never runs.\n *\n * This generator must only be delegated to (`yield*`) inside a\n * {@link Result.safeTry} body; resuming it after it has yielded an `Err`\n * throws.\n *\n * @example\n *\n * ```ts\n * const result = Result.safeTry(function* () {\n *   const x = yield* Result.safeUnwrap(Result.ok(2));\n *\n *   const y = yield* Result.safeUnwrap(Result.ok(3));\n *\n *   return Result.ok(x + y);\n * });\n *\n * assert.deepStrictEqual(result, Result.ok(5));\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @param result The `Result` to unwrap.\n * @returns A generator that yields the `Err` (if any) and returns the `Ok`\n *   value.\n */\nexport function* safeUnwrap<R extends UnknownResult>(\n  result: R,\n): Generator<NarrowToErr<R>, UnwrapOk<R>, unknown> {\n  if (isErr(result)) {\n    yield result;\n\n    throw new Error(\n      '`safeUnwrap()` generator was resumed after yielding an `Err`; it must only be used via `yield*` inside `safeTry()`',\n    );\n  }\n\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  return result.value as UnwrapOk<R>;\n}\n"],"names":[],"mappings":";;AAoCO,UAAU,WACf,MAAA,EACiD;AACjD,EAAA,IAAI,KAAA,CAAM,MAAM,CAAA,EAAG;AACjB,IAAA,MAAM,MAAA;AAEN,IAAA,MAAM,IAAI,KAAA;AAAA,MACR;AAAA,KACF;AAAA,EACF;AAGA,EAAA,OAAO,MAAA,CAAO,KAAA;AAChB;;;;"}

package/dist/others/debounce-function.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"debounce-function.d.mts","sourceRoot":"","sources":["../../src/others/debounce-function.mts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,GAAI,IAAI,SAAS,SAAS,OAAO,EAAE,QAChD,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,IAAI,oBACX,MAAM,KACvB,CAAC,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,IAAI,CAU1B,CAAC"}
+{"version":3,"file":"debounce-function.d.mts","sourceRoot":"","sources":["../../src/others/debounce-function.mts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,GAAI,IAAI,SAAS,SAAS,OAAO,EAAE,QAChD,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,IAAI,oBACX,MAAM,KACvB,CAAC,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,IAAI,CAc1B,CAAC"}

package/dist/others/debounce-function.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"debounce-function.mjs","sources":["../../src/others/debounce-function.mts"],"sourcesContent":["/**\n * Creates a debounced function that delays invoking `func` until after `waitMilliseconds`\n * have elapsed since the last time the debounced function was invoked.\n *\n * @template F The type of the function to debounce.\n * @param func The function to debounce.\n * @param waitMilliseconds The number of milliseconds to delay.\n * @returns The new debounced function.\n */\nexport const debounce = <Args extends readonly unknown[]>(\n  func: (...args: Args) => void,\n  waitMilliseconds: number,\n): ((...args: Args) => void) => {\n  let mut_timeoutId: ReturnType<typeof setTimeout> | undefined;\n\n  return (...args: Args): void => {\n    clearTimeout(mut_timeoutId);\n\n    mut_timeoutId = setTimeout(() => {\n      func(...args);\n    }, waitMilliseconds);\n  };\n};\n"],"names":[],"mappings":"AASO,MAAM,QAAA,GAAW,CACtB,IAAA,EACA,gBAAA,KAC8B;AAC9B,EAAA,IAAI,aAAA;AAEJ,EAAA,OAAO,IAAI,IAAA,KAAqB;AAC9B,IAAA,YAAA,CAAa,aAAa,CAAA;AAE1B,IAAA,aAAA,GAAgB,WAAW,MAAM;AAC/B,MAAA,IAAA,CAAK,GAAG,IAAI,CAAA;AAAA,IACd,GAAG,gBAAgB,CAAA;AAAA,EACrB,CAAA;AACF;;;;"}
+{"version":3,"file":"debounce-function.mjs","sources":["../../src/others/debounce-function.mts"],"sourcesContent":["/**\n * Creates a debounced function that delays invoking `func` until after `waitMilliseconds`\n * have elapsed since the last time the debounced function was invoked.\n *\n * @template F The type of the function to debounce.\n * @param func The function to debounce.\n * @param waitMilliseconds The number of milliseconds to delay.\n * @returns The new debounced function.\n */\nexport const debounce = <Args extends readonly unknown[]>(\n  func: (...args: Args) => void,\n  waitMilliseconds: number,\n): ((...args: Args) => void) => {\n  // Not `ReturnType<typeof setTimeout>`: with both the DOM and Node\n  // declarations in scope that resolves to `unknown`, which `clearTimeout`\n  // will not take. Naming what `clearTimeout` accepts says the same thing and\n  // stays true in either environment.\n  let mut_timeoutId: Parameters<typeof clearTimeout>[0];\n\n  return (...args: Args): void => {\n    clearTimeout(mut_timeoutId);\n\n    mut_timeoutId = setTimeout(() => {\n      func(...args);\n    }, waitMilliseconds);\n  };\n};\n"],"names":[],"mappings":"AASO,MAAM,QAAA,GAAW,CACtB,IAAA,EACA,gBAAA,KAC8B;AAK9B,EAAA,IAAI,aAAA;AAEJ,EAAA,OAAO,IAAI,IAAA,KAAqB;AAC9B,IAAA,YAAA,CAAa,aAAa,CAAA;AAE1B,IAAA,aAAA,GAAgB,WAAW,MAAM;AAC/B,MAAA,IAAA,CAAK,GAAG,IAAI,CAAA;AAAA,IACd,GAAG,gBAAgB,CAAA;AAAA,EACrB,CAAA;AACF;;;;"}

package/dist/others/fast-deep-equal.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"fast-deep-equal.d.mts","sourceRoot":"","sources":["../../src/others/fast-deep-equal.mts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,KAAM,CAAC,KAAK,CAAC,KAAG,OAyF9C,CAAC"}
+{"version":3,"file":"fast-deep-equal.d.mts","sourceRoot":"","sources":["../../src/others/fast-deep-equal.mts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,KAAM,CAAC,KAAK,CAAC,KAAG,OAgG9C,CAAC"}

package/dist/others/fast-deep-equal.mjs

@@ -49,7 +49,7 @@ const fastDeepEqual = (a, b) => {
       !(key === "_owner" && a["$$typeof"]) && fastDeepEqual(a[key], b[key])
     );
   }
-  return Number.isNaN(a) && Number.isNaN(b);
+  return typeof a === "number" && typeof b === "number" && Number.isNaN(a) && Number.isNaN(b);
 };
 
 export { fastDeepEqual };

package/dist/others/fast-deep-equal.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"fast-deep-equal.mjs","sources":["../../src/others/fast-deep-equal.mts"],"sourcesContent":["import { isMap, isRegExp, isSet, isTypedArray } from '@sindresorhus/is';\nimport { hasKey, isRecord } from '../guard/index.mjs';\n\n/**\n * The fastest deep equal with ES6 Map, Set and Typed arrays support.\n * Checks equality of Date and RegExp objects by value.\n *\n * Forked from https://github.com/epoberezkin/fast-deep-equal/blob/v3.1.3/src/index.jst\n */\nexport const fastDeepEqual = <T,>(a: T, b: T): boolean => {\n  if (a === b) {\n    return true;\n  }\n\n  if (typeof a !== typeof b) {\n    return false;\n  }\n\n  // Arrays are handled before `isRecord`, which excludes them.\n  if (Array.isArray(a)) {\n    return (\n      Array.isArray(b) &&\n      a.constructor === b.constructor &&\n      a.length === b.length &&\n      a.every((ai, index) => fastDeepEqual(ai, b[index]))\n    );\n  }\n\n  if (isRecord(a)) {\n    if (!isRecord(b)) {\n      return false;\n    }\n\n    if (a.constructor !== b.constructor) {\n      return false;\n    }\n\n    if (isMap(a)) {\n      return (\n        isMap(b) &&\n        a.size === b.size &&\n        a\n          .entries()\n          .every(\n            ([key, value]) => b.has(key) && fastDeepEqual(value, b.get(key)),\n          )\n      );\n    }\n\n    if (isSet(a)) {\n      return (\n        isSet(b) &&\n        a.size === b.size &&\n        a.entries().every(([value]) => b.has(value))\n      );\n    }\n\n    if (isTypedArray(a)) {\n      return (\n        isTypedArray(b) &&\n        a.length === b.length &&\n        a.every((value, index) => value === b[index])\n      );\n    }\n\n    if (isRegExp(a)) {\n      return isRegExp(b) && a.source === b.source && a.flags === b.flags;\n    }\n\n    if (a.valueOf !== Object.prototype.valueOf) {\n      return a.valueOf() === b.valueOf();\n    }\n\n    if (a.toString !== Object.prototype.toString) {\n      return a.toString() === b.toString();\n    }\n\n    const aKeys: readonly string[] = Object.keys(a);\n\n    const bKeys: readonly string[] = Object.keys(b);\n\n    return (\n      aKeys.length === bKeys.length &&\n      aKeys.every(\n        (key) =>\n          hasKey(b, key) &&\n          // React-specific: avoid traversing React elements' _owner.\n          //  _owner contains circular references\n          // and is not needed when comparing the actual elements (and not their owners)\n          // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions\n          !(key === '_owner' && a['$$typeof']) &&\n          fastDeepEqual(a[key], b[key]),\n      )\n    );\n  }\n\n  // true if both NaN, false otherwise\n  return Number.isNaN(a) && Number.isNaN(b);\n};\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"fast-deep-equal.mjs","sources":["../../src/others/fast-deep-equal.mts"],"sourcesContent":["import { isMap, isRegExp, isSet, isTypedArray } from '@sindresorhus/is';\nimport { hasKey, isRecord } from '../guard/index.mjs';\n\n/**\n * The fastest deep equal with ES6 Map, Set and Typed arrays support.\n * Checks equality of Date and RegExp objects by value.\n *\n * Forked from https://github.com/epoberezkin/fast-deep-equal/blob/v3.1.3/src/index.jst\n */\nexport const fastDeepEqual = <T,>(a: T, b: T): boolean => {\n  if (a === b) {\n    return true;\n  }\n\n  if (typeof a !== typeof b) {\n    return false;\n  }\n\n  // Arrays are handled before `isRecord`, which excludes them.\n  if (Array.isArray(a)) {\n    return (\n      Array.isArray(b) &&\n      a.constructor === b.constructor &&\n      a.length === b.length &&\n      a.every((ai, index) => fastDeepEqual(ai, b[index]))\n    );\n  }\n\n  if (isRecord(a)) {\n    if (!isRecord(b)) {\n      return false;\n    }\n\n    if (a.constructor !== b.constructor) {\n      return false;\n    }\n\n    if (isMap(a)) {\n      return (\n        isMap(b) &&\n        a.size === b.size &&\n        a\n          .entries()\n          .every(\n            ([key, value]) => b.has(key) && fastDeepEqual(value, b.get(key)),\n          )\n      );\n    }\n\n    if (isSet(a)) {\n      return (\n        isSet(b) &&\n        a.size === b.size &&\n        a.entries().every(([value]) => b.has(value))\n      );\n    }\n\n    if (isTypedArray(a)) {\n      return (\n        isTypedArray(b) &&\n        a.length === b.length &&\n        a.every((value, index) => value === b[index])\n      );\n    }\n\n    if (isRegExp(a)) {\n      return isRegExp(b) && a.source === b.source && a.flags === b.flags;\n    }\n\n    if (a.valueOf !== Object.prototype.valueOf) {\n      return a.valueOf() === b.valueOf();\n    }\n\n    if (a.toString !== Object.prototype.toString) {\n      return a.toString() === b.toString();\n    }\n\n    const aKeys: readonly string[] = Object.keys(a);\n\n    const bKeys: readonly string[] = Object.keys(b);\n\n    return (\n      aKeys.length === bKeys.length &&\n      aKeys.every(\n        (key) =>\n          hasKey(b, key) &&\n          // React-specific: avoid traversing React elements' _owner.\n          //  _owner contains circular references\n          // and is not needed when comparing the actual elements (and not their owners)\n          // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions\n          !(key === '_owner' && a['$$typeof']) &&\n          fastDeepEqual(a[key], b[key]),\n      )\n    );\n  }\n\n  // true if both NaN, false otherwise. `Number.isNaN` takes a number: called\n  // with anything else it is always false, so the check belongs behind a\n  // `typeof` guard rather than relying on that.\n  return (\n    typeof a === 'number' &&\n    typeof b === 'number' &&\n    Number.isNaN(a) &&\n    Number.isNaN(b)\n  );\n};\n"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "14.4.0",
+  "version": "14.5.0",
   "private": false,
   "keywords": [
     "typescript",
@@ -37,29 +37,29 @@
   ],
   "dependencies": {
     "@sindresorhus/is": "^8.1.0",
-    "ts-type-forge": "~9.2.1"
+    "ts-type-forge": "~9.2.2"
   },
   "devDependencies": {
     "@emotion/react": "11.14.0",
     "@emotion/styled": "11.14.1",
     "@mui/material": "9.3.1",
     "@types/react": "19.2.18",
-    "@vitest/browser-playwright": "4.1.10",
+    "@vitest/browser-playwright": "4.1.11",
     "dedent": "1.7.2",
-    "immer": "11.1.16",
+    "eslint-config-typed": "5.10.0",
+    "eslint-plugin-ts-fortress": "1.0.5",
+    "eslint-plugin-ts-type-forge": "0.7.1",
+    "immer": "11.1.18",
     "playwright": "1.62.1",
     "prettier": "3.9.6",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "3.0.2",
     "react": "19.2.8",
     "rollup": "4.62.4",
+    "ts-repo-utils": "10.3.2",
     "typedoc": "0.28.20",
     "typedoc-github-theme": "0.4.0",
-    "vite": "8.2.1",
-    "eslint-plugin-ts-fortress": "1.0.4",
-    "eslint-config-typed": "5.9.3",
-    "ts-repo-utils": "10.2.0",
-    "eslint-plugin-ts-type-forge": "0.6.6"
+    "vite": "8.2.1"
   },
   "peerDependencies": {
     "typescript": ">=4.8"

package/src/array/impl/array-utils-modification.test.mts

@@ -257,7 +257,7 @@ describe('Arr modifications', () => {
         xs: T,
       ): Readonly<{ [K in keyof T]: 0 }> => toFilled(xs, 0);
 
-      const result = blank([1, 2, 3] as const);
+      const result = blank([1, 2, 3]);
 
       expectType<typeof result, FixedLengthTuple<3, 0>>('=');
 
@@ -269,7 +269,7 @@ describe('Arr modifications', () => {
         xs: T,
       ): Readonly<{ [K in keyof T]: 0 }> => toFilled(0)(xs);
 
-      const result = blank([1, 2] as const);
+      const result = blank([1, 2]);
 
       expectType<typeof result, FixedLengthTuple<2, 0>>('=');
 
@@ -319,7 +319,7 @@ describe('Arr modifications', () => {
         xs: T,
       ): Readonly<{ [K in keyof T]: number }> => toRangeFilled(xs, 0, [1, 2]);
 
-      const result = blankMiddle([1, 2, 3] as const);
+      const result = blankMiddle([1, 2, 3]);
 
       expectType<typeof result, FixedLengthTuple<3, number>>('=');
 

package/src/array/impl/array-utils-search.mts

@@ -79,10 +79,17 @@ const findImpl = <E,>(
     predicate as () => boolean,
   );
 
-  expectType<
-    Parameters<typeof array.findIndex>[0],
-    (value: E, index: number, arr: readonly E[]) => unknown
-  >('=');
+  // Left as a comment rather than asserted. This pinned the shape of the
+  // standard library's `findIndex`, and the shape differs between the stock
+  // library and the strict one — `(value, index, obj: this) => boolean` there
+  // against `(value, index, arr: readonly E[]) => unknown` here. `src` ships
+  // to consumers so that "Go to Definition" reaches it, so an assertion that
+  // only holds under one of them shows up as an error in their editor.
+  //
+  // expectType<
+  //   Parameters<typeof array.findIndex>[0],
+  //   (value: E, index: number, arr: readonly E[]) => unknown
+  // >('=');
 
   expectType<
     typeof predicate,
@@ -162,10 +169,17 @@ const findLastImpl = <E,>(
     predicate as () => boolean,
   );
 
-  expectType<
-    Parameters<typeof array.findIndex>[0],
-    (value: E, index: number, arr: readonly E[]) => unknown
-  >('=');
+  // Left as a comment rather than asserted. This pinned the shape of the
+  // standard library's `findIndex`, and the shape differs between the stock
+  // library and the strict one — `(value, index, obj: this) => boolean` there
+  // against `(value, index, arr: readonly E[]) => unknown` here. `src` ships
+  // to consumers so that "Go to Definition" reaches it, so an assertion that
+  // only holds under one of them shows up as an error in their editor.
+  //
+  // expectType<
+  //   Parameters<typeof array.findIndex>[0],
+  //   (value: E, index: number, arr: readonly E[]) => unknown
+  // >('=');
 
   expectType<
     typeof predicate,

package/src/array/impl/array-utils-shape-invariants.test.mts

@@ -267,7 +267,7 @@ describe('Arr shape invariants', () => {
     );
 
     assert.deepStrictEqual<readonly string[]>(
-      toSortedNonNumberInGenericContext(['c', 'a', 'b'] as const),
+      toSortedNonNumberInGenericContext(['c', 'a', 'b']),
       ['a', 'b', 'c'],
     );
 
@@ -313,12 +313,12 @@ describe('Arr shape invariants', () => {
     );
 
     assert.deepStrictEqual<readonly number[]>(
-      uniqInGenericContext([1, 1, 2] as const),
+      uniqInGenericContext([1, 1, 2]),
       [1, 2],
     );
 
     assert.deepStrictEqual<readonly number[]>(
-      uniqByInGenericContext([1, 1, 2] as const),
+      uniqByInGenericContext([1, 1, 2]),
       [1, 2],
     );
   });

package/src/array/impl/array-utils-transformation.test.mts

@@ -77,7 +77,7 @@ describe('Arr transformations', () => {
         boxes: T,
       ): Readonly<{ [K in keyof T]: unknown }> => map(boxes, (b) => b.v);
 
-      const result = mapValues([{ v: 1 }, { v: 'a' }] as const);
+      const result = mapValues([{ v: 1 }, { v: 'a' }]);
 
       expectType<typeof result, FixedLengthTuple<2, unknown>>('=');
 

package/src/functional/optional/impl/index.mts

@@ -6,6 +6,7 @@ export * from './optional-is-none.mjs';
 export * from './optional-is-optional.mjs';
 export * from './optional-is-some.mjs';
 export * from './optional-map.mjs';
+export * from './optional-match.mjs';
 export * from './optional-none.mjs';
 export * from './optional-or-else.mjs';
 export * from './optional-some.mjs';

package/src/functional/optional/impl/optional-match.mts

@@ -0,0 +1,108 @@
+import { type UnknownOptional } from '../optional.mjs';
+import { isSome } from './optional-is-some.mjs';
+import { unwrap } from './optional-unwrap.mjs';
+import { type Unwrap } from './types.mjs';
+
+/**
+ * Folds an {@link Optional} into a plain value by applying one of two case
+ * handlers: `some` if the {@link Optional} contains a value, `none`
+ * otherwise. This is the function form of pattern matching on an
+ * {@link Optional}.
+ *
+ * Unlike {@link Optional.map}, the result is not wrapped in an
+ * {@link Optional} — both branches produce the final value directly.
+ *
+ * @example
+ *
+ * ```ts
+ * const doubledOrZero = Optional.match(Optional.some(21), {
+ *   some: (value) => value * 2,
+ *   none: () => 0,
+ * });
+ *
+ * assert.deepStrictEqual(doubledOrZero, 42);
+ *
+ * const matcher = Optional.match({
+ *   some: (value: number) => `value: ${value}`,
+ *   none: () => 'none',
+ * });
+ *
+ * assert.deepStrictEqual(matcher(Optional.some(3)), 'value: 3');
+ *
+ * assert.deepStrictEqual(matcher(Optional.none), 'none');
+ * ```
+ *
+ * @template O The input `UnknownOptional` type.
+ * @template S2 The type returned by the `some` case.
+ * @template N2 The type returned by the `none` case.
+ * @param optional The `Optional` to match on.
+ * @param cases An object with a `some` handler receiving the contained value
+ *   and a `none` handler receiving nothing.
+ * @returns The value produced by whichever case handler was applied.
+ */
+export function match<O extends UnknownOptional, S2, N2>(
+  optional: O,
+  cases: Readonly<{
+    some: (value: Unwrap<O>) => S2;
+    none: () => N2;
+  }>,
+): N2 | S2;
+
+// Curried version
+//
+// The returned function is generic over the *whole* optional, mirroring the
+// direct overload above; see the comment on the curried overload of
+// `Optional.map` for why the parameter is a conditional type instead of a
+// plain `Optional<S>`.
+export function match<S, S2, N2>(
+  cases: Readonly<{
+    some: (value: S) => S2;
+    none: () => N2;
+  }>,
+): <O extends UnknownOptional>(
+  optional: Unwrap<O> extends S ? O : never,
+) => N2 | S2;
+
+export function match<O extends UnknownOptional, S2, N2>(
+  ...args:
+    | readonly [
+        optional: O,
+        cases: Readonly<{
+          some: (value: Unwrap<O>) => S2;
+          none: () => N2;
+        }>,
+      ]
+    | readonly [
+        cases: Readonly<{
+          some: (value: Unwrap<O>) => S2;
+          none: () => N2;
+        }>,
+      ]
+): N2 | S2 | ((optional: O) => N2 | S2) {
+  switch (args.length) {
+    case 2: {
+      const [optional, cases] = args;
+
+      return matchImpl(optional, cases);
+    }
+
+    case 1: {
+      // Curried version: the only argument is the case handlers
+      const [cases] = args;
+
+      return (optional: O) => matchImpl(optional, cases);
+    }
+  }
+}
+
+const matchImpl = <O extends UnknownOptional, S2, N2>(
+  optional: O,
+  cases: Readonly<{
+    some: (value: Unwrap<O>) => S2;
+    none: () => N2;
+  }>,
+): N2 | S2 =>
+  isSome(optional)
+    ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      cases.some(unwrap(optional)!)
+    : cases.none();

package/src/functional/optional.test.mts

@@ -800,4 +800,83 @@ describe('Optional test', () => {
       expect(Optional.unwrap(inner)).toBe(42);
     });
   });
+
+  describe('match', () => {
+    test('should apply the some case for Some', () => {
+      const result = Optional.match(Optional.some(21), {
+        some: (value) => value * 2,
+        none: () => 0,
+      });
+
+      expectType<typeof result, number>('=');
+
+      assert.deepStrictEqual(result, 42);
+    });
+
+    test('should apply the none case for None', () => {
+      const result = Optional.match(Optional.none, {
+        some: () => 'some',
+        none: () => 'none',
+      });
+
+      assert.deepStrictEqual(result, 'none');
+    });
+
+    test('should support Optional union inputs', () => {
+      const optional: Optional<number> = Optional.some(3);
+
+      const result = Optional.match(optional, {
+        some: (value) => `value: ${value}`,
+        none: () => 'none',
+      });
+
+      expectType<typeof result, string>('=');
+
+      assert.deepStrictEqual(result, 'value: 3');
+    });
+
+    test('curried version should work', () => {
+      const matcher = Optional.match({
+        some: (value: number) => `value: ${value}`,
+        none: () => 'none',
+      });
+
+      const result = matcher(Optional.some(3));
+
+      expectType<typeof result, string>('=');
+
+      assert.deepStrictEqual(result, 'value: 3');
+
+      assert.deepStrictEqual(matcher(Optional.none), 'none');
+    });
+
+    test('curried version should compose with Array.map and pipe', () => {
+      const matcher = Optional.match({
+        some: (value: number) => `some:${value}`,
+        none: () => 'none',
+      });
+
+      const optionals: readonly Optional<number>[] = [
+        Optional.some(1),
+        Optional.none,
+      ] as const;
+
+      assert.deepStrictEqual(optionals.map(matcher), ['some:1', 'none']);
+
+      const single: Optional<number> = Optional.some(3);
+
+      assert.deepStrictEqual(pipe(single).map(matcher).value, 'some:3');
+    });
+
+    test('should apply the some case for Some(undefined)', () => {
+      const makeOptional = (): Optional<undefined> => Optional.some(undefined);
+
+      const result = Optional.match(makeOptional(), {
+        some: (value) => `some: ${String(value)}`,
+        none: () => 'none',
+      });
+
+      assert.deepStrictEqual(result, 'some: undefined');
+    });
+  });
 });

package/src/functional/result/impl/index.mts

@@ -2,6 +2,7 @@ export * from './result-err.mjs';
 export * from './result-expect-to-be.mjs';
 export * from './result-flat-map.mjs';
 export * from './result-fold.mjs';
+export * from './result-from-optional.mjs';
 export * from './result-from-promise.mjs';
 export * from './result-from-throwable.mjs';
 export * from './result-is-err.mjs';
@@ -9,8 +10,11 @@ export * from './result-is-ok.mjs';
 export * from './result-is-result.mjs';
 export * from './result-map-err.mjs';
 export * from './result-map.mjs';
+export * from './result-match.mjs';
 export * from './result-ok.mjs';
 export * from './result-or-else.mjs';
+export * from './result-safe-try.mjs';
+export * from './result-safe-unwrap.mjs';
 export * from './result-swap.mjs';
 export * from './result-to-optional.mjs';
 export * from './result-unwrap-err-or.mjs';

package/src/functional/result/impl/result-from-optional.mts

@@ -0,0 +1,80 @@
+import { Optional, type UnknownOptional } from '../../optional/index.mjs';
+import { type Result } from '../result.mjs';
+import { err } from './result-err.mjs';
+import { ok } from './result-ok.mjs';
+
+/**
+ * Converts an {@link Optional} to a `Result` (the inverse of
+ * {@link Result.toOptional}, and the equivalent of Rust's `Option::ok_or`).
+ *
+ * If the {@link Optional} is `Some`, returns `Ok` with the contained value.
+ * If it is `None`, returns `Err` with the provided error value.
+ *
+ * @example
+ *
+ * ```ts
+ * assert.deepStrictEqual(
+ *   Result.fromOptional(Optional.some(42), 'missing'),
+ *   Result.ok(42),
+ * );
+ *
+ * assert.deepStrictEqual(
+ *   Result.fromOptional(Optional.none, 'missing'),
+ *   Result.err('missing'),
+ * );
+ *
+ * const withMissingError = Result.fromOptional('missing');
+ *
+ * assert.deepStrictEqual(withMissingError(Optional.some(1)), Result.ok(1));
+ *
+ * assert.deepStrictEqual(
+ *   withMissingError(Optional.none),
+ *   Result.err('missing'),
+ * );
+ * ```
+ *
+ * @template O The input `UnknownOptional` type.
+ * @template E The type of the error value used for the `None` case.
+ * @param optional The `Optional` to convert.
+ * @param error The error value to use if the `Optional` is `None`.
+ * @returns `Ok` with the contained value, or `Err` with `error`.
+ */
+export function fromOptional<O extends UnknownOptional, const E>(
+  optional: O,
+  error: E,
+): Result<Optional.Unwrap<O>, E>;
+
+// Curried version
+export function fromOptional<const E>(
+  error: E,
+): <O extends UnknownOptional>(optional: O) => Result<Optional.Unwrap<O>, E>;
+
+export function fromOptional<O extends UnknownOptional, const E>(
+  ...args: readonly [optional: O, error: E] | readonly [error: E]
+):
+  | Result<Optional.Unwrap<O>, E>
+  | ((optional: O) => Result<Optional.Unwrap<O>, E>) {
+  switch (args.length) {
+    case 2: {
+      const [optional, error] = args;
+
+      return fromOptionalImpl(optional, error);
+    }
+
+    case 1: {
+      // Curried version: the only argument is the error value
+      const [error] = args;
+
+      return (optional: O) => fromOptionalImpl(optional, error);
+    }
+  }
+}
+
+const fromOptionalImpl = <O extends UnknownOptional, E>(
+  optional: O,
+  error: E,
+): Result<Optional.Unwrap<O>, E> =>
+  Optional.isSome(optional)
+    ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      ok(Optional.unwrap(optional)!)
+    : err(error);

package/src/functional/result/impl/result-match.mts

@@ -0,0 +1,108 @@
+import { type UnknownResult } from '../result.mjs';
+import { isOk } from './result-is-ok.mjs';
+import { type UnwrapErr, type UnwrapOk } from './types.mjs';
+
+/**
+ * Folds a `Result` into a plain value by applying one of two case handlers:
+ * `ok` if the `Result` is `Ok`, `err` otherwise. This is the function form of
+ * pattern matching on a `Result`.
+ *
+ * Unlike {@link Result.fold}, which maps both sides and returns another
+ * `Result`, `match` unwraps: both branches produce the final value directly.
+ *
+ * @example
+ *
+ * ```ts
+ * const doubledOrZero = Result.match(Result.ok(21), {
+ *   ok: (value) => value * 2,
+ *   err: () => 0,
+ * });
+ *
+ * assert.deepStrictEqual(doubledOrZero, 42);
+ *
+ * const matcher = Result.match({
+ *   ok: (value: number) => value + 1,
+ *   err: (error: string) => error.length,
+ * });
+ *
+ * assert.deepStrictEqual(matcher(Result.ok(1)), 2);
+ *
+ * assert.deepStrictEqual(matcher(Result.err('oops')), 4);
+ * ```
+ *
+ * @template R The input `UnknownResult` type.
+ * @template S2 The type returned by the `ok` case.
+ * @template E2 The type returned by the `err` case.
+ * @param result The `Result` to match on.
+ * @param cases An object with an `ok` handler receiving the success value and
+ *   an `err` handler receiving the error value.
+ * @returns The value produced by whichever case handler was applied.
+ */
+export function match<R extends UnknownResult, S2, E2>(
+  result: R,
+  cases: Readonly<{
+    ok: (value: UnwrapOk<R>) => S2;
+    err: (error: UnwrapErr<R>) => E2;
+  }>,
+): E2 | S2;
+
+// Curried version
+//
+// The returned function is generic over the *whole* result, mirroring the
+// direct overload above; see the comment on the curried overload of
+// `Result.map` for why the parameter is a conditional type instead of a plain
+// `Result<S, E>`. Both sides have to be checked here, hence the nested
+// conditional.
+export function match<S, E, S2, E2>(
+  cases: Readonly<{
+    ok: (value: S) => S2;
+    err: (error: E) => E2;
+  }>,
+): <R extends UnknownResult>(
+  result: UnwrapOk<R> extends S ? (UnwrapErr<R> extends E ? R : never) : never,
+) => E2 | S2;
+
+export function match<R extends UnknownResult, S2, E2>(
+  ...args:
+    | readonly [
+        result: R,
+        cases: Readonly<{
+          ok: (value: UnwrapOk<R>) => S2;
+          err: (error: UnwrapErr<R>) => E2;
+        }>,
+      ]
+    | readonly [
+        cases: Readonly<{
+          ok: (value: UnwrapOk<R>) => S2;
+          err: (error: UnwrapErr<R>) => E2;
+        }>,
+      ]
+): E2 | S2 | ((result: R) => E2 | S2) {
+  switch (args.length) {
+    case 2: {
+      const [result, cases] = args;
+
+      return matchImpl(result, cases);
+    }
+
+    case 1: {
+      // Curried version: the only argument is the case handlers
+      const [cases] = args;
+
+      return (result: R) => matchImpl(result, cases);
+    }
+  }
+}
+
+const matchImpl = <R extends UnknownResult, S2, E2>(
+  result: R,
+  cases: Readonly<{
+    ok: (value: UnwrapOk<R>) => S2;
+    err: (error: UnwrapErr<R>) => E2;
+  }>,
+): E2 | S2 =>
+  isOk(result)
+    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      cases.ok(result.value as UnwrapOk<R>)
+    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      cases.err(result.value as UnwrapErr<R>);