ts-data-forge 14.3.0 → 14.5.0

package/README.md

@@ -507,6 +507,12 @@ const value: unknown = { key: 'value' } as const;
 
 if (isNonNullObject(value)) {
     // value is guaranteed to be a non-null object
+    assert.isTrue(value !== null);
+}
+
+// `object` is not enough to read keys from: an index signature is what
+// says the keys are strings. `isRecord` is the guard that gives one.
+if (isRecord(value)) {
     assert.deepStrictEqual(Object.keys(value), ['key']);
 }
 

package/dist/array/impl/array-utils-search.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-search.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-search.mts"],"names":[],"mappings":"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"}
+{"version":3,"file":"array-utils-search.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-search.mts"],"names":[],"mappings":"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"}

package/dist/array/impl/array-utils-search.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-search.mjs","sources":["../../../src/array/impl/array-utils-search.mts"],"sourcesContent":["import { expectType } from '../../expect-type.mjs';\nimport { Optional, pipe } from '../../functional/index.mjs';\nimport { asUint32 } from '../../number/index.mjs';\nimport {\n  type ArgArrayIndexWithNegative,\n  type ArrayIndex,\n  type SizeType,\n} from '../../types.mjs';\n\n/**\n * Finds the first element that satisfies a predicate.\n *\n * @example\n *\n * ```ts\n * const users = [\n *   { id: 1, name: 'Ada' },\n *   { id: 2, name: 'Grace' },\n * ] as const;\n *\n * const found = Arr.find(users, (user) => user.id === 2);\n *\n * const missing = Arr.find<Readonly<{ id: number }>>((user) => user.id === 3)(\n *   users,\n * );\n *\n * assert.deepStrictEqual(found, Optional.some({ id: 2, name: 'Grace' }));\n *\n * assert.deepStrictEqual(missing, Optional.none);\n * ```\n */\nexport function find<E, F extends E>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => value is F,\n): Optional<F>;\n\nexport function find<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (value: Ar[number], index: ArrayIndex<Ar>, arr: Ar) => boolean,\n): Optional<Ar[number]>;\n\nexport function find<E>(\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): (array: readonly E[]) => Optional<E>;\n\nexport function find<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n    | readonly [\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n): Optional<E> | ((array: readonly E[]) => Optional<E>) {\n  switch (args.length) {\n    case 2:\n      return findImpl(...args);\n\n    case 1:\n      return (array) => findImpl(array, ...args);\n  }\n}\n\nconst findImpl = <E,>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): Optional<E> => {\n  const foundIndex = array.findIndex(\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    predicate as () => boolean,\n  );\n\n  expectType<\n    Parameters<typeof array.findIndex>[0],\n    (value: E, index: number, arr: readonly E[]) => unknown\n  >('=');\n\n  expectType<\n    typeof predicate,\n    (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean\n  >('=');\n\n  return foundIndex === -1\n    ? Optional.none\n    : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      Optional.some(array[foundIndex]!);\n};\n\n/**\n * Finds the last element that satisfies a predicate.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 3, 2, 4, 5] as const;\n *\n * const lastEven = Arr.findLast(numbers, (n) => n % 2 === 0);\n *\n * const none = Arr.findLast<number>((n) => n > 10)(numbers);\n *\n * assert.deepStrictEqual(lastEven, Optional.some(4));\n *\n * assert.deepStrictEqual(none, Optional.none);\n * ```\n */\nexport function findLast<E, F extends E>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => value is F,\n): Optional<F>;\n\nexport function findLast<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (value: Ar[number], index: ArrayIndex<Ar>, arr: Ar) => boolean,\n): Optional<Ar[number]>;\n\nexport function findLast<E>(\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): (array: readonly E[]) => Optional<E>;\n\nexport function findLast<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n    | readonly [\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n): Optional<E> | ((array: readonly E[]) => Optional<E>) {\n  switch (args.length) {\n    case 2:\n      return findLastImpl(...args);\n\n    case 1:\n      return (array) => findLastImpl(array, ...args);\n  }\n}\n\nconst findLastImpl = <E,>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): Optional<E> => {\n  const foundIndex = array.findLastIndex(\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    predicate as () => boolean,\n  );\n\n  expectType<\n    Parameters<typeof array.findIndex>[0],\n    (value: E, index: number, arr: readonly E[]) => unknown\n  >('=');\n\n  expectType<\n    typeof predicate,\n    (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean\n  >('=');\n\n  return foundIndex === -1\n    ? Optional.none\n    : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      Optional.some(array[foundIndex]!);\n};\n\n/**\n * Finds the index of the first element that satisfies a predicate.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'c'] as const;\n *\n * const indexOfB = Arr.findIndex(letters, (letter) => letter === 'b');\n *\n * const indexOfMissing = Arr.findIndex<string>((letter) => letter === 'z')(\n *   letters,\n * );\n *\n * assert.isTrue(indexOfB === 1);\n *\n * assert.isTrue(indexOfMissing === -1);\n * ```\n */\nexport function findIndex<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (value: Ar[number], index: ArrayIndex<Ar>, arr: Ar) => boolean,\n): ArrayIndex<Ar> | -1;\n\nexport function findIndex<E>(\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): (array: readonly E[]) => SizeType.Arr | -1;\n\nexport function findIndex<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n    | readonly [\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {\n  switch (args.length) {\n    case 2:\n      return findIndexImpl(...args);\n\n    case 1:\n      return (array) => findIndexImpl(array, ...args);\n  }\n}\n\nconst findIndexImpl = <E,>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): SizeType.Arr | -1 =>\n  pipe(\n    array.findIndex(\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      predicate as (value: E, index: number) => boolean,\n    ),\n  ).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;\n\n/**\n * Finds the index of the last element that satisfies a predicate.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'c', 'b'] as const;\n *\n * const lastIndexOfB = Arr.findLastIndex(letters, (letter) => letter === 'b');\n *\n * const notFound = Arr.findLastIndex<string>((letter) => letter === 'z')(\n *   letters,\n * );\n *\n * assert.isTrue(lastIndexOfB === 3);\n *\n * assert.isTrue(notFound === -1);\n * ```\n */\nexport function findLastIndex<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (value: Ar[number], index: ArrayIndex<Ar>, arr: Ar) => boolean,\n): ArrayIndex<Ar> | -1;\n\nexport function findLastIndex<E>(\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): (array: readonly E[]) => SizeType.Arr | -1;\n\nexport function findLastIndex<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n    | readonly [\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {\n  switch (args.length) {\n    case 2:\n      return findLastIndexImpl(...args);\n\n    case 1:\n      return (array) => findLastIndexImpl(array, ...args);\n  }\n}\n\nconst findLastIndexImpl = <E,>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): SizeType.Arr | -1 =>\n  pipe(\n    array.findLastIndex(\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      predicate as (value: E, index: number) => boolean,\n    ),\n  ).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;\n\n/**\n * Gets the index of a value in an array.\n *\n * @example\n *\n * ```ts\n * const fruits = ['apple', 'banana', 'orange', 'banana'] as readonly string[];\n *\n * const indexOfBanana = Arr.indexOf(fruits, 'banana');\n *\n * const indexOfGrape = Arr.indexOf(fruits, 'grape');\n *\n * // Curried version\n * const findApple = Arr.indexOf('apple');\n *\n * const indexOfApple = findApple(fruits);\n *\n * console.log(indexOfBanana); // => 1\n *\n * console.log(indexOfGrape); // => -1\n *\n * console.log(indexOfApple); // => 0\n * ```\n */\nexport function indexOf<const Ar extends readonly unknown[]>(\n  array: Ar,\n  searchElement: Ar[number],\n): ArrayIndex<Ar> | -1;\n\nexport function indexOf<E>(\n  searchElement: E,\n): (array: readonly E[]) => SizeType.Arr | -1;\n\nexport function indexOf<E>(\n  ...args:\n    | readonly [array: readonly E[], searchElement: E]\n    | readonly [searchElement: E]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {\n  switch (args.length) {\n    case 2:\n      return indexOfImpl(...args);\n\n    case 1:\n      return (array) => indexOfImpl(array, ...args);\n  }\n}\n\nconst indexOfImpl = <E,>(\n  array: readonly E[],\n  searchElement: E,\n): SizeType.Arr | -1 => {\n  const index = array.indexOf(searchElement);\n\n  return index !== -1 ? asUint32(index) : -1;\n};\n\n/**\n * Gets the index of a value in an array, starting from a specified index.\n *\n * @example\n *\n * ```ts\n * const fruits = ['apple', 'banana', 'orange', 'banana'] as readonly string[];\n *\n * // Search for 'banana' starting from index 1\n * const firstBanana = Arr.indexOfFrom(fruits, 'banana', 1);\n *\n * // Search for 'banana' starting from index 2\n * const secondBanana = Arr.indexOfFrom(fruits, 'banana', 2);\n *\n * // Element not found\n * const notFound = Arr.indexOfFrom(fruits, 'grape', 0);\n *\n * // Curried version\n * const findBananaFrom2 = Arr.indexOfFrom('banana', 2);\n *\n * const index = findBananaFrom2(fruits);\n *\n * console.log(firstBanana); // => 1\n *\n * console.log(secondBanana); // => 3\n *\n * console.log(notFound); // => -1\n *\n * console.log(index); // => 3\n * ```\n */\nexport function indexOfFrom<const Ar extends readonly unknown[]>(\n  array: Ar,\n  searchElement: Ar[number],\n  fromIndex: ArgArrayIndexWithNegative<Ar>,\n): ArrayIndex<Ar> | -1;\n\nexport function indexOfFrom<E>(\n  searchElement: E,\n  fromIndex: SizeType.ArgArrWithNegative,\n): (array: readonly E[]) => SizeType.Arr | -1;\n\nexport function indexOfFrom<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        searchElement: E,\n        fromIndex: SizeType.ArgArrWithNegative,\n      ]\n    | readonly [searchElement: E, fromIndex: SizeType.ArgArrWithNegative]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {\n  switch (args.length) {\n    case 3:\n      return indexOfFromImpl(...args);\n\n    case 2:\n      return (array) => indexOfFromImpl(array, ...args);\n  }\n}\n\nconst indexOfFromImpl = <E,>(\n  array: readonly E[],\n  searchElement: E,\n  fromIndex: SizeType.ArgArrWithNegative,\n): SizeType.Arr | -1 => {\n  const index = array.indexOf(searchElement, fromIndex);\n\n  return index !== -1 ? asUint32(index) : -1;\n};\n\n/**\n * Gets the last index of a value in an array.\n *\n * @example\n *\n * ```ts\n * const fruits = ['apple', 'banana', 'orange', 'banana'] as readonly string[];\n *\n * const lastBanana = Arr.lastIndexOf(fruits, 'banana');\n *\n * const lastApple = Arr.lastIndexOf(fruits, 'apple');\n *\n * const notFound = Arr.lastIndexOf(fruits, 'grape');\n *\n * // Curried version\n * const findLastBanana = Arr.lastIndexOf('banana');\n *\n * const index = findLastBanana(fruits);\n *\n * console.log(lastBanana); // => 3\n *\n * console.log(lastApple); // => 0\n *\n * console.log(notFound); // => -1\n *\n * console.log(index); // => 3\n * ```\n */\nexport function lastIndexOf<const Ar extends readonly unknown[]>(\n  array: Ar,\n  searchElement: Ar[number],\n): ArrayIndex<Ar> | -1;\n\nexport function lastIndexOf<E>(\n  searchElement: E,\n): (array: readonly E[]) => SizeType.Arr | -1;\n\nexport function lastIndexOf<E>(\n  ...args:\n    | readonly [array: readonly E[], searchElement: E]\n    | readonly [searchElement: E]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {\n  switch (args.length) {\n    case 2:\n      return lastIndexOfImpl(...args);\n\n    case 1:\n      return (array) => lastIndexOfImpl(array, ...args);\n  }\n}\n\nconst lastIndexOfImpl = <E,>(\n  array: readonly E[],\n  searchElement: E,\n): SizeType.Arr | -1 => {\n  const index = array.lastIndexOf(searchElement);\n\n  return index !== -1 ? asUint32(index) : -1;\n};\n\n/**\n * Gets the last index of a value in an array, starting from a specified index.\n *\n * @example\n *\n * ```ts\n * const fruits = ['apple', 'banana', 'orange', 'banana', 'grape'] as const;\n *\n * // Search backwards for 'banana' from index 3\n * const lastBananaFrom3 = Arr.lastIndexOfFrom(fruits, 'banana', 3);\n *\n * // Search backwards for 'banana' from index 2\n * const lastBananaFrom2 = Arr.lastIndexOfFrom(fruits, 'banana', 2);\n *\n * // Element not found\n * const notFound = Arr.lastIndexOfFrom(fruits, 'grape', 2);\n *\n * // Curried version\n * const findBananaFrom3 = Arr.lastIndexOfFrom('banana', 3);\n *\n * const index = findBananaFrom3(fruits);\n *\n * console.log(lastBananaFrom3); // => 3\n *\n * console.log(lastBananaFrom2); // => 1\n *\n * console.log(notFound); // => -1\n *\n * console.log(index); // => 3\n * ```\n */\nexport function lastIndexOfFrom<const Ar extends readonly unknown[]>(\n  array: Ar,\n  searchElement: Ar[number],\n  fromIndex: ArgArrayIndexWithNegative<Ar>,\n): ArrayIndex<Ar> | -1;\n\nexport function lastIndexOfFrom<E>(\n  searchElement: E,\n  fromIndex: SizeType.ArgArrWithNegative,\n): (array: readonly E[]) => SizeType.Arr | -1;\n\nexport function lastIndexOfFrom<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        searchElement: E,\n        fromIndex: SizeType.ArgArrWithNegative,\n      ]\n    | readonly [searchElement: E, fromIndex: SizeType.ArgArrWithNegative]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {\n  switch (args.length) {\n    case 3:\n      return lastIndexOfFromImpl(...args);\n\n    case 2:\n      return (array) => lastIndexOfFromImpl(array, ...args);\n  }\n}\n\nconst lastIndexOfFromImpl = <E,>(\n  array: readonly E[],\n  searchElement: E,\n  fromIndex: SizeType.ArgArrWithNegative,\n): SizeType.Arr | -1 => {\n  const index = array.lastIndexOf(searchElement, fromIndex);\n\n  return index !== -1 ? asUint32(index) : -1;\n};\n"],"names":["Optional.none","Optional.some"],"mappings":"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"}
+{"version":3,"file":"array-utils-search.mjs","sources":["../../../src/array/impl/array-utils-search.mts"],"sourcesContent":["import { expectType } from '../../expect-type.mjs';\nimport { Optional, pipe } from '../../functional/index.mjs';\nimport { asUint32 } from '../../number/index.mjs';\nimport {\n  type ArgArrayIndexWithNegative,\n  type ArrayIndex,\n  type SizeType,\n} from '../../types.mjs';\n\n/**\n * Finds the first element that satisfies a predicate.\n *\n * @example\n *\n * ```ts\n * const users = [\n *   { id: 1, name: 'Ada' },\n *   { id: 2, name: 'Grace' },\n * ] as const;\n *\n * const found = Arr.find(users, (user) => user.id === 2);\n *\n * const missing = Arr.find<Readonly<{ id: number }>>((user) => user.id === 3)(\n *   users,\n * );\n *\n * assert.deepStrictEqual(found, Optional.some({ id: 2, name: 'Grace' }));\n *\n * assert.deepStrictEqual(missing, Optional.none);\n * ```\n */\nexport function find<E, F extends E>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => value is F,\n): Optional<F>;\n\nexport function find<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (value: Ar[number], index: ArrayIndex<Ar>, arr: Ar) => boolean,\n): Optional<Ar[number]>;\n\nexport function find<E>(\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): (array: readonly E[]) => Optional<E>;\n\nexport function find<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n    | readonly [\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n): Optional<E> | ((array: readonly E[]) => Optional<E>) {\n  switch (args.length) {\n    case 2:\n      return findImpl(...args);\n\n    case 1:\n      return (array) => findImpl(array, ...args);\n  }\n}\n\nconst findImpl = <E,>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): Optional<E> => {\n  const foundIndex = array.findIndex(\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    predicate as () => boolean,\n  );\n\n  // Left as a comment rather than asserted. This pinned the shape of the\n  // standard library's `findIndex`, and the shape differs between the stock\n  // library and the strict one — `(value, index, obj: this) => boolean` there\n  // against `(value, index, arr: readonly E[]) => unknown` here. `src` ships\n  // to consumers so that \"Go to Definition\" reaches it, so an assertion that\n  // only holds under one of them shows up as an error in their editor.\n  //\n  // expectType<\n  //   Parameters<typeof array.findIndex>[0],\n  //   (value: E, index: number, arr: readonly E[]) => unknown\n  // >('=');\n\n  expectType<\n    typeof predicate,\n    (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean\n  >('=');\n\n  return foundIndex === -1\n    ? Optional.none\n    : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      Optional.some(array[foundIndex]!);\n};\n\n/**\n * Finds the last element that satisfies a predicate.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 3, 2, 4, 5] as const;\n *\n * const lastEven = Arr.findLast(numbers, (n) => n % 2 === 0);\n *\n * const none = Arr.findLast<number>((n) => n > 10)(numbers);\n *\n * assert.deepStrictEqual(lastEven, Optional.some(4));\n *\n * assert.deepStrictEqual(none, Optional.none);\n * ```\n */\nexport function findLast<E, F extends E>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => value is F,\n): Optional<F>;\n\nexport function findLast<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (value: Ar[number], index: ArrayIndex<Ar>, arr: Ar) => boolean,\n): Optional<Ar[number]>;\n\nexport function findLast<E>(\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): (array: readonly E[]) => Optional<E>;\n\nexport function findLast<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n    | readonly [\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n): Optional<E> | ((array: readonly E[]) => Optional<E>) {\n  switch (args.length) {\n    case 2:\n      return findLastImpl(...args);\n\n    case 1:\n      return (array) => findLastImpl(array, ...args);\n  }\n}\n\nconst findLastImpl = <E,>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): Optional<E> => {\n  const foundIndex = array.findLastIndex(\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    predicate as () => boolean,\n  );\n\n  // Left as a comment rather than asserted. This pinned the shape of the\n  // standard library's `findIndex`, and the shape differs between the stock\n  // library and the strict one — `(value, index, obj: this) => boolean` there\n  // against `(value, index, arr: readonly E[]) => unknown` here. `src` ships\n  // to consumers so that \"Go to Definition\" reaches it, so an assertion that\n  // only holds under one of them shows up as an error in their editor.\n  //\n  // expectType<\n  //   Parameters<typeof array.findIndex>[0],\n  //   (value: E, index: number, arr: readonly E[]) => unknown\n  // >('=');\n\n  expectType<\n    typeof predicate,\n    (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean\n  >('=');\n\n  return foundIndex === -1\n    ? Optional.none\n    : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      Optional.some(array[foundIndex]!);\n};\n\n/**\n * Finds the index of the first element that satisfies a predicate.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'c'] as const;\n *\n * const indexOfB = Arr.findIndex(letters, (letter) => letter === 'b');\n *\n * const indexOfMissing = Arr.findIndex<string>((letter) => letter === 'z')(\n *   letters,\n * );\n *\n * assert.isTrue(indexOfB === 1);\n *\n * assert.isTrue(indexOfMissing === -1);\n * ```\n */\nexport function findIndex<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (value: Ar[number], index: ArrayIndex<Ar>, arr: Ar) => boolean,\n): ArrayIndex<Ar> | -1;\n\nexport function findIndex<E>(\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): (array: readonly E[]) => SizeType.Arr | -1;\n\nexport function findIndex<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n    | readonly [\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {\n  switch (args.length) {\n    case 2:\n      return findIndexImpl(...args);\n\n    case 1:\n      return (array) => findIndexImpl(array, ...args);\n  }\n}\n\nconst findIndexImpl = <E,>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): SizeType.Arr | -1 =>\n  pipe(\n    array.findIndex(\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      predicate as (value: E, index: number) => boolean,\n    ),\n  ).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;\n\n/**\n * Finds the index of the last element that satisfies a predicate.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'c', 'b'] as const;\n *\n * const lastIndexOfB = Arr.findLastIndex(letters, (letter) => letter === 'b');\n *\n * const notFound = Arr.findLastIndex<string>((letter) => letter === 'z')(\n *   letters,\n * );\n *\n * assert.isTrue(lastIndexOfB === 3);\n *\n * assert.isTrue(notFound === -1);\n * ```\n */\nexport function findLastIndex<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (value: Ar[number], index: ArrayIndex<Ar>, arr: Ar) => boolean,\n): ArrayIndex<Ar> | -1;\n\nexport function findLastIndex<E>(\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): (array: readonly E[]) => SizeType.Arr | -1;\n\nexport function findLastIndex<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n    | readonly [\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {\n  switch (args.length) {\n    case 2:\n      return findLastIndexImpl(...args);\n\n    case 1:\n      return (array) => findLastIndexImpl(array, ...args);\n  }\n}\n\nconst findLastIndexImpl = <E,>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): SizeType.Arr | -1 =>\n  pipe(\n    array.findLastIndex(\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      predicate as (value: E, index: number) => boolean,\n    ),\n  ).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;\n\n/**\n * Gets the index of a value in an array.\n *\n * @example\n *\n * ```ts\n * const fruits = ['apple', 'banana', 'orange', 'banana'] as readonly string[];\n *\n * const indexOfBanana = Arr.indexOf(fruits, 'banana');\n *\n * const indexOfGrape = Arr.indexOf(fruits, 'grape');\n *\n * // Curried version\n * const findApple = Arr.indexOf('apple');\n *\n * const indexOfApple = findApple(fruits);\n *\n * console.log(indexOfBanana); // => 1\n *\n * console.log(indexOfGrape); // => -1\n *\n * console.log(indexOfApple); // => 0\n * ```\n */\nexport function indexOf<const Ar extends readonly unknown[]>(\n  array: Ar,\n  searchElement: Ar[number],\n): ArrayIndex<Ar> | -1;\n\nexport function indexOf<E>(\n  searchElement: E,\n): (array: readonly E[]) => SizeType.Arr | -1;\n\nexport function indexOf<E>(\n  ...args:\n    | readonly [array: readonly E[], searchElement: E]\n    | readonly [searchElement: E]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {\n  switch (args.length) {\n    case 2:\n      return indexOfImpl(...args);\n\n    case 1:\n      return (array) => indexOfImpl(array, ...args);\n  }\n}\n\nconst indexOfImpl = <E,>(\n  array: readonly E[],\n  searchElement: E,\n): SizeType.Arr | -1 => {\n  const index = array.indexOf(searchElement);\n\n  return index !== -1 ? asUint32(index) : -1;\n};\n\n/**\n * Gets the index of a value in an array, starting from a specified index.\n *\n * @example\n *\n * ```ts\n * const fruits = ['apple', 'banana', 'orange', 'banana'] as readonly string[];\n *\n * // Search for 'banana' starting from index 1\n * const firstBanana = Arr.indexOfFrom(fruits, 'banana', 1);\n *\n * // Search for 'banana' starting from index 2\n * const secondBanana = Arr.indexOfFrom(fruits, 'banana', 2);\n *\n * // Element not found\n * const notFound = Arr.indexOfFrom(fruits, 'grape', 0);\n *\n * // Curried version\n * const findBananaFrom2 = Arr.indexOfFrom('banana', 2);\n *\n * const index = findBananaFrom2(fruits);\n *\n * console.log(firstBanana); // => 1\n *\n * console.log(secondBanana); // => 3\n *\n * console.log(notFound); // => -1\n *\n * console.log(index); // => 3\n * ```\n */\nexport function indexOfFrom<const Ar extends readonly unknown[]>(\n  array: Ar,\n  searchElement: Ar[number],\n  fromIndex: ArgArrayIndexWithNegative<Ar>,\n): ArrayIndex<Ar> | -1;\n\nexport function indexOfFrom<E>(\n  searchElement: E,\n  fromIndex: SizeType.ArgArrWithNegative,\n): (array: readonly E[]) => SizeType.Arr | -1;\n\nexport function indexOfFrom<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        searchElement: E,\n        fromIndex: SizeType.ArgArrWithNegative,\n      ]\n    | readonly [searchElement: E, fromIndex: SizeType.ArgArrWithNegative]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {\n  switch (args.length) {\n    case 3:\n      return indexOfFromImpl(...args);\n\n    case 2:\n      return (array) => indexOfFromImpl(array, ...args);\n  }\n}\n\nconst indexOfFromImpl = <E,>(\n  array: readonly E[],\n  searchElement: E,\n  fromIndex: SizeType.ArgArrWithNegative,\n): SizeType.Arr | -1 => {\n  const index = array.indexOf(searchElement, fromIndex);\n\n  return index !== -1 ? asUint32(index) : -1;\n};\n\n/**\n * Gets the last index of a value in an array.\n *\n * @example\n *\n * ```ts\n * const fruits = ['apple', 'banana', 'orange', 'banana'] as readonly string[];\n *\n * const lastBanana = Arr.lastIndexOf(fruits, 'banana');\n *\n * const lastApple = Arr.lastIndexOf(fruits, 'apple');\n *\n * const notFound = Arr.lastIndexOf(fruits, 'grape');\n *\n * // Curried version\n * const findLastBanana = Arr.lastIndexOf('banana');\n *\n * const index = findLastBanana(fruits);\n *\n * console.log(lastBanana); // => 3\n *\n * console.log(lastApple); // => 0\n *\n * console.log(notFound); // => -1\n *\n * console.log(index); // => 3\n * ```\n */\nexport function lastIndexOf<const Ar extends readonly unknown[]>(\n  array: Ar,\n  searchElement: Ar[number],\n): ArrayIndex<Ar> | -1;\n\nexport function lastIndexOf<E>(\n  searchElement: E,\n): (array: readonly E[]) => SizeType.Arr | -1;\n\nexport function lastIndexOf<E>(\n  ...args:\n    | readonly [array: readonly E[], searchElement: E]\n    | readonly [searchElement: E]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {\n  switch (args.length) {\n    case 2:\n      return lastIndexOfImpl(...args);\n\n    case 1:\n      return (array) => lastIndexOfImpl(array, ...args);\n  }\n}\n\nconst lastIndexOfImpl = <E,>(\n  array: readonly E[],\n  searchElement: E,\n): SizeType.Arr | -1 => {\n  const index = array.lastIndexOf(searchElement);\n\n  return index !== -1 ? asUint32(index) : -1;\n};\n\n/**\n * Gets the last index of a value in an array, starting from a specified index.\n *\n * @example\n *\n * ```ts\n * const fruits = ['apple', 'banana', 'orange', 'banana', 'grape'] as const;\n *\n * // Search backwards for 'banana' from index 3\n * const lastBananaFrom3 = Arr.lastIndexOfFrom(fruits, 'banana', 3);\n *\n * // Search backwards for 'banana' from index 2\n * const lastBananaFrom2 = Arr.lastIndexOfFrom(fruits, 'banana', 2);\n *\n * // Element not found\n * const notFound = Arr.lastIndexOfFrom(fruits, 'grape', 2);\n *\n * // Curried version\n * const findBananaFrom3 = Arr.lastIndexOfFrom('banana', 3);\n *\n * const index = findBananaFrom3(fruits);\n *\n * console.log(lastBananaFrom3); // => 3\n *\n * console.log(lastBananaFrom2); // => 1\n *\n * console.log(notFound); // => -1\n *\n * console.log(index); // => 3\n * ```\n */\nexport function lastIndexOfFrom<const Ar extends readonly unknown[]>(\n  array: Ar,\n  searchElement: Ar[number],\n  fromIndex: ArgArrayIndexWithNegative<Ar>,\n): ArrayIndex<Ar> | -1;\n\nexport function lastIndexOfFrom<E>(\n  searchElement: E,\n  fromIndex: SizeType.ArgArrWithNegative,\n): (array: readonly E[]) => SizeType.Arr | -1;\n\nexport function lastIndexOfFrom<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        searchElement: E,\n        fromIndex: SizeType.ArgArrWithNegative,\n      ]\n    | readonly [searchElement: E, fromIndex: SizeType.ArgArrWithNegative]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {\n  switch (args.length) {\n    case 3:\n      return lastIndexOfFromImpl(...args);\n\n    case 2:\n      return (array) => lastIndexOfFromImpl(array, ...args);\n  }\n}\n\nconst lastIndexOfFromImpl = <E,>(\n  array: readonly E[],\n  searchElement: E,\n  fromIndex: SizeType.ArgArrWithNegative,\n): SizeType.Arr | -1 => {\n  const index = array.lastIndexOf(searchElement, fromIndex);\n\n  return index !== -1 ? asUint32(index) : -1;\n};\n"],"names":["Optional.none","Optional.some"],"mappings":"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"}

package/dist/functional/optional/impl/index.d.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/dist/functional/optional/impl/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/index.mts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/index.mts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,aAAa,CAAC"}

package/dist/functional/optional/impl/index.mjs

@@ -6,6 +6,7 @@ export { isNone } from './optional-is-none.mjs';
 export { isOptional } from './optional-is-optional.mjs';
 export { isSome } from './optional-is-some.mjs';
 export { map } from './optional-map.mjs';
+export { match } from './optional-match.mjs';
 export { none } from './optional-none.mjs';
 export { orElse } from './optional-or-else.mjs';
 export { some } from './optional-some.mjs';

package/dist/functional/optional/impl/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;"}

package/dist/functional/optional/impl/optional-match.d.mts

@@ -0,0 +1,48 @@
+import { type UnknownOptional } from '../optional.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 declare function match<O extends UnknownOptional, S2, N2>(optional: O, cases: Readonly<{
+    some: (value: Unwrap<O>) => S2;
+    none: () => N2;
+}>): N2 | S2;
+export declare 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;
+//# sourceMappingURL=optional-match.d.mts.map

package/dist/functional/optional/impl/optional-match.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optional-match.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-match.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGvD,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,eAAe,EAAE,EAAE,EAAE,EAAE,EACrD,QAAQ,EAAE,CAAC,EACX,KAAK,EAAE,QAAQ,CAAC;IACd,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;IAC/B,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC,GACD,EAAE,GAAG,EAAE,CAAC;AAQX,wBAAgB,KAAK,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAC7B,KAAK,EAAE,QAAQ,CAAC;IACd,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC;IACvB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC,GACD,CAAC,CAAC,SAAS,eAAe,EAC3B,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK,KACtC,EAAE,GAAG,EAAE,CAAC"}

package/dist/functional/optional/impl/optional-match.mjs

@@ -0,0 +1,22 @@
+import { isSome } from './optional-is-some.mjs';
+import { unwrap } from './optional-unwrap.mjs';
+
+function match(...args) {
+  switch (args.length) {
+    case 2: {
+      const [optional, cases] = args;
+      return matchImpl(optional, cases);
+    }
+    case 1: {
+      const [cases] = args;
+      return (optional) => matchImpl(optional, cases);
+    }
+  }
+}
+const matchImpl = (optional, cases) => isSome(optional) ? (
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  cases.some(unwrap(optional))
+) : cases.none();
+
+export { match };
+//# sourceMappingURL=optional-match.mjs.map

package/dist/functional/optional/impl/optional-match.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"optional-match.mjs","sources":["../../../../src/functional/optional/impl/optional-match.mts"],"sourcesContent":["import { type UnknownOptional } from '../optional.mjs';\nimport { isSome } from './optional-is-some.mjs';\nimport { unwrap } from './optional-unwrap.mjs';\nimport { type Unwrap } from './types.mjs';\n\n/**\n * Folds an {@link Optional} into a plain value by applying one of two case\n * handlers: `some` if the {@link Optional} contains a value, `none`\n * otherwise. This is the function form of pattern matching on an\n * {@link Optional}.\n *\n * Unlike {@link Optional.map}, the result is not wrapped in an\n * {@link Optional} — both branches produce the final value directly.\n *\n * @example\n *\n * ```ts\n * const doubledOrZero = Optional.match(Optional.some(21), {\n *   some: (value) => value * 2,\n *   none: () => 0,\n * });\n *\n * assert.deepStrictEqual(doubledOrZero, 42);\n *\n * const matcher = Optional.match({\n *   some: (value: number) => `value: ${value}`,\n *   none: () => 'none',\n * });\n *\n * assert.deepStrictEqual(matcher(Optional.some(3)), 'value: 3');\n *\n * assert.deepStrictEqual(matcher(Optional.none), 'none');\n * ```\n *\n * @template O The input `UnknownOptional` type.\n * @template S2 The type returned by the `some` case.\n * @template N2 The type returned by the `none` case.\n * @param optional The `Optional` to match on.\n * @param cases An object with a `some` handler receiving the contained value\n *   and a `none` handler receiving nothing.\n * @returns The value produced by whichever case handler was applied.\n */\nexport function match<O extends UnknownOptional, S2, N2>(\n  optional: O,\n  cases: Readonly<{\n    some: (value: Unwrap<O>) => S2;\n    none: () => N2;\n  }>,\n): N2 | S2;\n\n// Curried version\n//\n// The returned function is generic over the *whole* optional, mirroring the\n// direct overload above; see the comment on the curried overload of\n// `Optional.map` for why the parameter is a conditional type instead of a\n// plain `Optional<S>`.\nexport function match<S, S2, N2>(\n  cases: Readonly<{\n    some: (value: S) => S2;\n    none: () => N2;\n  }>,\n): <O extends UnknownOptional>(\n  optional: Unwrap<O> extends S ? O : never,\n) => N2 | S2;\n\nexport function match<O extends UnknownOptional, S2, N2>(\n  ...args:\n    | readonly [\n        optional: O,\n        cases: Readonly<{\n          some: (value: Unwrap<O>) => S2;\n          none: () => N2;\n        }>,\n      ]\n    | readonly [\n        cases: Readonly<{\n          some: (value: Unwrap<O>) => S2;\n          none: () => N2;\n        }>,\n      ]\n): N2 | S2 | ((optional: O) => N2 | S2) {\n  switch (args.length) {\n    case 2: {\n      const [optional, cases] = args;\n\n      return matchImpl(optional, cases);\n    }\n\n    case 1: {\n      // Curried version: the only argument is the case handlers\n      const [cases] = args;\n\n      return (optional: O) => matchImpl(optional, cases);\n    }\n  }\n}\n\nconst matchImpl = <O extends UnknownOptional, S2, N2>(\n  optional: O,\n  cases: Readonly<{\n    some: (value: Unwrap<O>) => S2;\n    none: () => N2;\n  }>,\n): N2 | S2 =>\n  isSome(optional)\n    ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      cases.some(unwrap(optional)!)\n    : cases.none();\n"],"names":[],"mappings":";;;AAiEO,SAAS,SACX,IAAA,EAcmC;AACtC,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,QAAA,EAAU,KAAK,CAAA,GAAI,IAAA;AAE1B,MAAA,OAAO,SAAA,CAAU,UAAU,KAAK,CAAA;AAAA,IAClC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,QAAA,KAAgB,SAAA,CAAU,QAAA,EAAU,KAAK,CAAA;AAAA,IACnD;AAAA;AAEJ;AAEA,MAAM,SAAA,GAAY,CAChB,QAAA,EACA,KAAA,KAKA,OAAO,QAAQ,CAAA;AAAA;AAAA,EAEX,KAAA,CAAM,IAAA,CAAK,MAAA,CAAO,QAAQ,CAAE;AAAA,IAC5B,MAAM,IAAA,EAAK;;;;"}

package/dist/functional/result/impl/index.d.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/dist/functional/result/impl/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/index.mts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/index.mts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC"}

package/dist/functional/result/impl/index.mjs

@@ -2,6 +2,7 @@ export { err } from './result-err.mjs';
 export { expectToBe } from './result-expect-to-be.mjs';
 export { flatMap } from './result-flat-map.mjs';
 export { fold } from './result-fold.mjs';
+export { fromOptional } from './result-from-optional.mjs';
 export { fromPromise } from './result-from-promise.mjs';
 export { fromThrowable } from './result-from-throwable.mjs';
 export { isErr } from './result-is-err.mjs';
@@ -9,8 +10,11 @@ export { isOk } from './result-is-ok.mjs';
 export { isResult } from './result-is-result.mjs';
 export { mapErr } from './result-map-err.mjs';
 export { map } from './result-map.mjs';
+export { match } from './result-match.mjs';
 export { ok } from './result-ok.mjs';
 export { orElse } from './result-or-else.mjs';
+export { safeTry } from './result-safe-try.mjs';
+export { safeUnwrap } from './result-safe-unwrap.mjs';
 export { swap } from './result-swap.mjs';
 export { toOptional } from './result-to-optional.mjs';
 export { unwrapErrOr } from './result-unwrap-err-or.mjs';

package/dist/functional/result/impl/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/functional/result/impl/result-from-optional.d.mts

@@ -0,0 +1,41 @@
+import { Optional, type UnknownOptional } from '../../optional/index.mjs';
+import { type Result } from '../result.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 declare function fromOptional<O extends UnknownOptional, const E>(optional: O, error: E): Result<Optional.Unwrap<O>, E>;
+export declare function fromOptional<const E>(error: E): <O extends UnknownOptional>(optional: O) => Result<Optional.Unwrap<O>, E>;
+//# sourceMappingURL=result-from-optional.d.mts.map

package/dist/functional/result/impl/result-from-optional.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-from-optional.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-from-optional.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC1E,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAI5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,eAAe,EAAE,KAAK,CAAC,CAAC,EAC7D,QAAQ,EAAE,CAAC,EACX,KAAK,EAAE,CAAC,GACP,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAGjC,wBAAgB,YAAY,CAAC,KAAK,CAAC,CAAC,EAClC,KAAK,EAAE,CAAC,GACP,CAAC,CAAC,SAAS,eAAe,EAAE,QAAQ,EAAE,CAAC,KAAK,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/dist/functional/result/impl/result-from-optional.mjs

@@ -0,0 +1,24 @@
+import { isSome } from '../../optional/impl/optional-is-some.mjs';
+import { unwrap } from '../../optional/impl/optional-unwrap.mjs';
+import { err } from './result-err.mjs';
+import { ok } from './result-ok.mjs';
+
+function fromOptional(...args) {
+  switch (args.length) {
+    case 2: {
+      const [optional, error] = args;
+      return fromOptionalImpl(optional, error);
+    }
+    case 1: {
+      const [error] = args;
+      return (optional) => fromOptionalImpl(optional, error);
+    }
+  }
+}
+const fromOptionalImpl = (optional, error) => isSome(optional) ? (
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  ok(unwrap(optional))
+) : err(error);
+
+export { fromOptional };
+//# sourceMappingURL=result-from-optional.mjs.map

package/dist/functional/result/impl/result-from-optional.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-from-optional.mjs","sources":["../../../../src/functional/result/impl/result-from-optional.mts"],"sourcesContent":["import { Optional, type UnknownOptional } from '../../optional/index.mjs';\nimport { type Result } from '../result.mjs';\nimport { err } from './result-err.mjs';\nimport { ok } from './result-ok.mjs';\n\n/**\n * Converts an {@link Optional} to a `Result` (the inverse of\n * {@link Result.toOptional}, and the equivalent of Rust's `Option::ok_or`).\n *\n * If the {@link Optional} is `Some`, returns `Ok` with the contained value.\n * If it is `None`, returns `Err` with the provided error value.\n *\n * @example\n *\n * ```ts\n * assert.deepStrictEqual(\n *   Result.fromOptional(Optional.some(42), 'missing'),\n *   Result.ok(42),\n * );\n *\n * assert.deepStrictEqual(\n *   Result.fromOptional(Optional.none, 'missing'),\n *   Result.err('missing'),\n * );\n *\n * const withMissingError = Result.fromOptional('missing');\n *\n * assert.deepStrictEqual(withMissingError(Optional.some(1)), Result.ok(1));\n *\n * assert.deepStrictEqual(\n *   withMissingError(Optional.none),\n *   Result.err('missing'),\n * );\n * ```\n *\n * @template O The input `UnknownOptional` type.\n * @template E The type of the error value used for the `None` case.\n * @param optional The `Optional` to convert.\n * @param error The error value to use if the `Optional` is `None`.\n * @returns `Ok` with the contained value, or `Err` with `error`.\n */\nexport function fromOptional<O extends UnknownOptional, const E>(\n  optional: O,\n  error: E,\n): Result<Optional.Unwrap<O>, E>;\n\n// Curried version\nexport function fromOptional<const E>(\n  error: E,\n): <O extends UnknownOptional>(optional: O) => Result<Optional.Unwrap<O>, E>;\n\nexport function fromOptional<O extends UnknownOptional, const E>(\n  ...args: readonly [optional: O, error: E] | readonly [error: E]\n):\n  | Result<Optional.Unwrap<O>, E>\n  | ((optional: O) => Result<Optional.Unwrap<O>, E>) {\n  switch (args.length) {\n    case 2: {\n      const [optional, error] = args;\n\n      return fromOptionalImpl(optional, error);\n    }\n\n    case 1: {\n      // Curried version: the only argument is the error value\n      const [error] = args;\n\n      return (optional: O) => fromOptionalImpl(optional, error);\n    }\n  }\n}\n\nconst fromOptionalImpl = <O extends UnknownOptional, E>(\n  optional: O,\n  error: E,\n): Result<Optional.Unwrap<O>, E> =>\n  Optional.isSome(optional)\n    ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      ok(Optional.unwrap(optional)!)\n    : err(error);\n"],"names":["Optional.isSome","Optional.unwrap"],"mappings":";;;;;AAmDO,SAAS,gBACX,IAAA,EAGgD;AACnD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,QAAA,EAAU,KAAK,CAAA,GAAI,IAAA;AAE1B,MAAA,OAAO,gBAAA,CAAiB,UAAU,KAAK,CAAA;AAAA,IACzC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,QAAA,KAAgB,gBAAA,CAAiB,QAAA,EAAU,KAAK,CAAA;AAAA,IAC1D;AAAA;AAEJ;AAEA,MAAM,mBAAmB,CACvB,QAAA,EACA,KAAA,KAEAA,OAAgB,QAAQ,CAAA;AAAA;AAAA,EAEpB,EAAA,CAAGC,MAAS,CAAO,QAAQ,CAAE;AAAA,IAC7B,IAAI,KAAK,CAAA;;;;"}

package/dist/functional/result/impl/result-match.d.mts

@@ -0,0 +1,47 @@
+import { type UnknownResult } from '../result.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 declare function match<R extends UnknownResult, S2, E2>(result: R, cases: Readonly<{
+    ok: (value: UnwrapOk<R>) => S2;
+    err: (error: UnwrapErr<R>) => E2;
+}>): E2 | S2;
+export declare 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;
+//# sourceMappingURL=result-match.d.mts.map

package/dist/functional/result/impl/result-match.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-match.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-match.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,aAAa,EAAE,EAAE,EAAE,EAAE,EACnD,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,QAAQ,CAAC;IACd,EAAE,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;IAC/B,GAAG,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;CAClC,CAAC,GACD,EAAE,GAAG,EAAE,CAAC;AASX,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAChC,KAAK,EAAE,QAAQ,CAAC;IACd,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC;IACrB,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC;CACvB,CAAC,GACD,CAAC,CAAC,SAAS,aAAa,EACzB,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,KAAK,KACzE,EAAE,GAAG,EAAE,CAAC"}

package/dist/functional/result/impl/result-match.mjs

@@ -0,0 +1,24 @@
+import { isOk } from './result-is-ok.mjs';
+
+function match(...args) {
+  switch (args.length) {
+    case 2: {
+      const [result, cases] = args;
+      return matchImpl(result, cases);
+    }
+    case 1: {
+      const [cases] = args;
+      return (result) => matchImpl(result, cases);
+    }
+  }
+}
+const matchImpl = (result, cases) => isOk(result) ? (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  cases.ok(result.value)
+) : (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  cases.err(result.value)
+);
+
+export { match };
+//# sourceMappingURL=result-match.mjs.map

package/dist/functional/result/impl/result-match.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-match.mjs","sources":["../../../../src/functional/result/impl/result-match.mts"],"sourcesContent":["import { type UnknownResult } from '../result.mjs';\nimport { isOk } from './result-is-ok.mjs';\nimport { type UnwrapErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Folds a `Result` into a plain value by applying one of two case handlers:\n * `ok` if the `Result` is `Ok`, `err` otherwise. This is the function form of\n * pattern matching on a `Result`.\n *\n * Unlike {@link Result.fold}, which maps both sides and returns another\n * `Result`, `match` unwraps: both branches produce the final value directly.\n *\n * @example\n *\n * ```ts\n * const doubledOrZero = Result.match(Result.ok(21), {\n *   ok: (value) => value * 2,\n *   err: () => 0,\n * });\n *\n * assert.deepStrictEqual(doubledOrZero, 42);\n *\n * const matcher = Result.match({\n *   ok: (value: number) => value + 1,\n *   err: (error: string) => error.length,\n * });\n *\n * assert.deepStrictEqual(matcher(Result.ok(1)), 2);\n *\n * assert.deepStrictEqual(matcher(Result.err('oops')), 4);\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @template S2 The type returned by the `ok` case.\n * @template E2 The type returned by the `err` case.\n * @param result The `Result` to match on.\n * @param cases An object with an `ok` handler receiving the success value and\n *   an `err` handler receiving the error value.\n * @returns The value produced by whichever case handler was applied.\n */\nexport function match<R extends UnknownResult, S2, E2>(\n  result: R,\n  cases: Readonly<{\n    ok: (value: UnwrapOk<R>) => S2;\n    err: (error: UnwrapErr<R>) => E2;\n  }>,\n): E2 | S2;\n\n// Curried version\n//\n// The returned function is generic over the *whole* result, mirroring the\n// direct overload above; see the comment on the curried overload of\n// `Result.map` for why the parameter is a conditional type instead of a plain\n// `Result<S, E>`. Both sides have to be checked here, hence the nested\n// conditional.\nexport function match<S, E, S2, E2>(\n  cases: Readonly<{\n    ok: (value: S) => S2;\n    err: (error: E) => E2;\n  }>,\n): <R extends UnknownResult>(\n  result: UnwrapOk<R> extends S ? (UnwrapErr<R> extends E ? R : never) : never,\n) => E2 | S2;\n\nexport function match<R extends UnknownResult, S2, E2>(\n  ...args:\n    | readonly [\n        result: R,\n        cases: Readonly<{\n          ok: (value: UnwrapOk<R>) => S2;\n          err: (error: UnwrapErr<R>) => E2;\n        }>,\n      ]\n    | readonly [\n        cases: Readonly<{\n          ok: (value: UnwrapOk<R>) => S2;\n          err: (error: UnwrapErr<R>) => E2;\n        }>,\n      ]\n): E2 | S2 | ((result: R) => E2 | S2) {\n  switch (args.length) {\n    case 2: {\n      const [result, cases] = args;\n\n      return matchImpl(result, cases);\n    }\n\n    case 1: {\n      // Curried version: the only argument is the case handlers\n      const [cases] = args;\n\n      return (result: R) => matchImpl(result, cases);\n    }\n  }\n}\n\nconst matchImpl = <R extends UnknownResult, S2, E2>(\n  result: R,\n  cases: Readonly<{\n    ok: (value: UnwrapOk<R>) => S2;\n    err: (error: UnwrapErr<R>) => E2;\n  }>,\n): E2 | S2 =>\n  isOk(result)\n    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      cases.ok(result.value as UnwrapOk<R>)\n    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      cases.err(result.value as UnwrapErr<R>);\n"],"names":[],"mappings":";;AAgEO,SAAS,SACX,IAAA,EAciC;AACpC,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,MAAA,EAAQ,KAAK,CAAA,GAAI,IAAA;AAExB,MAAA,OAAO,SAAA,CAAU,QAAQ,KAAK,CAAA;AAAA,IAChC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,MAAA,KAAc,SAAA,CAAU,MAAA,EAAQ,KAAK,CAAA;AAAA,IAC/C;AAAA;AAEJ;AAEA,MAAM,SAAA,GAAY,CAChB,MAAA,EACA,KAAA,KAKA,KAAK,MAAM,CAAA;AAAA;AAAA,EAEP,KAAA,CAAM,EAAA,CAAG,MAAA,CAAO,KAAoB;AAAA;AAAA;AAAA,EAEpC,KAAA,CAAM,GAAA,CAAI,MAAA,CAAO,KAAqB;AAAA,CAAA;;;;"}

package/dist/functional/result/impl/result-safe-try.d.mts

@@ -0,0 +1,51 @@
+import { type Err } from '../../../types.mjs';
+import { type Result, type UnknownResult } from '../result.mjs';
+import { type UnwrapErr, type UnwrapOk } from './types.mjs';
+/**
+ * Runs a generator body in which `yield* Result.safeUnwrap(...)` unwraps `Ok`
+ * values and short-circuits on the first `Err`, emulating Rust's `?` operator
+ * (early-return error propagation).
+ *
+ * The body must return a `Result`. If every unwrapped `Result` is `Ok`, the
+ * returned value is the body's `Result`; otherwise it is the first `Err`
+ * encountered, and the rest of the body never runs — though the generator is
+ * closed rather than dropped, so `finally` blocks and `using` disposals
+ * pending in the body still run. An exception thrown by the body is not
+ * converted to an `Err`: it propagates out of `safeTry` (as a rejected
+ * `Promise` for an async body). Use {@link Result.fromThrowable} for that.
+ *
+ * Passing an async generator (`async function*`) returns a
+ * `Promise<Result<...>>` instead, so `await` can be used inside the body.
+ * Note that `yield*` inside an `async function*` awaits what it receives, so
+ * unwrapping an `Ok` whose value is itself a `Promise` yields the awaited
+ * value there while the static type still says `Promise<...>`; keep promises
+ * out of the `Ok` side of a `Result` unwrapped in an async body.
+ *
+ * @example
+ *
+ * ```ts
+ * const parseTwo = (a: string, b: string): Result<number, Error> =>
+ *   Result.safeTry(function* () {
+ *     const x = yield* Result.safeUnwrap(Num.safeParseInt(a));
+ *
+ *     const y = yield* Result.safeUnwrap(Num.safeParseInt(b));
+ *
+ *     return Result.ok(x + y);
+ *   });
+ *
+ * assert.deepStrictEqual(parseTwo('1', '2'), Result.ok(3));
+ *
+ * assert.isTrue(Result.isErr(parseTwo('1', 'not a number')));
+ * ```
+ *
+ * @template Y The union of `Err` types unwrapped via
+ *   {@link Result.safeUnwrap} (`never` if nothing is unwrapped).
+ * @template R2 The `Result` type returned by the body.
+ * @param body A generator function whose `yield*` expressions delegate to
+ *   {@link Result.safeUnwrap} and whose return value is a `Result`.
+ * @returns The body's `Result`, or the first `Err` short-circuited out of it
+ *   (wrapped in a `Promise` for an async generator body).
+ */
+export declare function safeTry<Y extends Err<unknown>, R2 extends UnknownResult>(body: () => Generator<Y, R2>): Result<UnwrapOk<R2>, UnwrapErr<R2> | UnwrapErr<Y>>;
+export declare function safeTry<Y extends Err<unknown>, R2 extends UnknownResult>(body: () => AsyncGenerator<Y, R2>): Promise<Result<UnwrapOk<R2>, UnwrapErr<R2> | UnwrapErr<Y>>>;
+//# sourceMappingURL=result-safe-try.d.mts.map

package/dist/functional/result/impl/result-safe-try.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-safe-try.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-safe-try.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,SAAS,aAAa,EACtE,IAAI,EAAE,MAAM,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,GAC3B,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AAEtD,wBAAgB,OAAO,CAAC,CAAC,SAAS,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,SAAS,aAAa,EACtE,IAAI,EAAE,MAAM,cAAc,CAAC,CAAC,EAAE,EAAE,CAAC,GAChC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,24 @@
+import { hasKey } from '../../../guard/has-key.mjs';
+import { isRecord } from '../../../guard/is-record.mjs';
+
+function safeTry(body) {
+  const generator = body();
+  const step = generator.next();
+  if (isSyncStep(step)) {
+    if (step.done !== true && isSyncGenerator(generator, step)) {
+      generator.return(step.value);
+    }
+    return step.value;
+  }
+  return step.then(async (asyncStep) => {
+    if (asyncStep.done !== true) {
+      await generator.return(asyncStep.value);
+    }
+    return asyncStep.value;
+  });
+}
+const isSyncStep = (value) => isRecord(value) && hasKey(value, "done");
+const isSyncGenerator = (_generator, step) => isSyncStep(step);
+
+export { safeTry };
+//# sourceMappingURL=result-safe-try.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-safe-try.mjs","sources":["../../../../src/functional/result/impl/result-safe-try.mts"],"sourcesContent":["import { hasKey, isRecord } from '../../../guard/index.mjs';\nimport { type Err } from '../../../types.mjs';\nimport { type Result, type UnknownResult } from '../result.mjs';\nimport { type UnwrapErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Runs a generator body in which `yield* Result.safeUnwrap(...)` unwraps `Ok`\n * values and short-circuits on the first `Err`, emulating Rust's `?` operator\n * (early-return error propagation).\n *\n * The body must return a `Result`. If every unwrapped `Result` is `Ok`, the\n * returned value is the body's `Result`; otherwise it is the first `Err`\n * encountered, and the rest of the body never runs — though the generator is\n * closed rather than dropped, so `finally` blocks and `using` disposals\n * pending in the body still run. An exception thrown by the body is not\n * converted to an `Err`: it propagates out of `safeTry` (as a rejected\n * `Promise` for an async body). Use {@link Result.fromThrowable} for that.\n *\n * Passing an async generator (`async function*`) returns a\n * `Promise<Result<...>>` instead, so `await` can be used inside the body.\n * Note that `yield*` inside an `async function*` awaits what it receives, so\n * unwrapping an `Ok` whose value is itself a `Promise` yields the awaited\n * value there while the static type still says `Promise<...>`; keep promises\n * out of the `Ok` side of a `Result` unwrapped in an async body.\n *\n * @example\n *\n * ```ts\n * const parseTwo = (a: string, b: string): Result<number, Error> =>\n *   Result.safeTry(function* () {\n *     const x = yield* Result.safeUnwrap(Num.safeParseInt(a));\n *\n *     const y = yield* Result.safeUnwrap(Num.safeParseInt(b));\n *\n *     return Result.ok(x + y);\n *   });\n *\n * assert.deepStrictEqual(parseTwo('1', '2'), Result.ok(3));\n *\n * assert.isTrue(Result.isErr(parseTwo('1', 'not a number')));\n * ```\n *\n * @template Y The union of `Err` types unwrapped via\n *   {@link Result.safeUnwrap} (`never` if nothing is unwrapped).\n * @template R2 The `Result` type returned by the body.\n * @param body A generator function whose `yield*` expressions delegate to\n *   {@link Result.safeUnwrap} and whose return value is a `Result`.\n * @returns The body's `Result`, or the first `Err` short-circuited out of it\n *   (wrapped in a `Promise` for an async generator body).\n */\nexport function safeTry<Y extends Err<unknown>, R2 extends UnknownResult>(\n  body: () => Generator<Y, R2>,\n): Result<UnwrapOk<R2>, UnwrapErr<R2> | UnwrapErr<Y>>;\n\nexport function safeTry<Y extends Err<unknown>, R2 extends UnknownResult>(\n  body: () => AsyncGenerator<Y, R2>,\n): Promise<Result<UnwrapOk<R2>, UnwrapErr<R2> | UnwrapErr<Y>>>;\n\nexport function safeTry(\n  body:\n    | (() => AsyncGenerator<UnknownResult, UnknownResult>)\n    | (() => Generator<UnknownResult, UnknownResult>),\n): Promise<UnknownResult> | UnknownResult {\n  const generator = body();\n\n  // A yielded `Err` and a returned `Result` are both already the final\n  // answer, so the first step's `value` is the result in either case: the\n  // generator is closed rather than resumed after yielding.\n  const step = generator.next();\n\n  if (isSyncStep(step)) {\n    // Dropping a suspended generator would skip the `finally` blocks and\n    // `using` disposals still pending in the body; closing it runs them\n    // before the short-circuited `Err` is handed back. `isSyncGenerator` is\n    // what makes `return()` here synchronous rather than a floating promise.\n    if (step.done !== true && isSyncGenerator(generator, step)) {\n      generator.return(step.value);\n    }\n\n    return step.value;\n  }\n\n  return step.then(async (asyncStep) => {\n    if (asyncStep.done !== true) {\n      await generator.return(asyncStep.value);\n    }\n\n    return asyncStep.value;\n  });\n}\n\n// A sync generator's `next()` returns a plain `{ value, done }` object with\n// own properties, while an async generator's returns a `Promise`, whose\n// `then` lives on the prototype — so an own-key check on `done` separates the\n// two.\nconst isSyncStep = (\n  value: unknown,\n): value is IteratorResult<UnknownResult, UnknownResult> =>\n  isRecord(value) && hasKey(value, 'done');\n\n// The generator-side counterpart of `isSyncStep`: a step in the sync form can\n// only have come from a sync generator, so the step is what narrows the\n// generator that produced it — hence the predicate reads its second argument\n// and not its first.\nconst isSyncGenerator = (\n  _generator:\n    | AsyncGenerator<UnknownResult, UnknownResult>\n    | Generator<UnknownResult, UnknownResult>,\n  step: unknown,\n): _generator is Generator<UnknownResult, UnknownResult> => isSyncStep(step);\n"],"names":[],"mappings":";;;AA0DO,SAAS,QACd,IAAA,EAGwC;AACxC,EAAA,MAAM,YAAY,IAAA,EAAK;AAKvB,EAAA,MAAM,IAAA,GAAO,UAAU,IAAA,EAAK;AAE5B,EAAA,IAAI,UAAA,CAAW,IAAI,CAAA,EAAG;AAKpB,IAAA,IAAI,KAAK,IAAA,KAAS,IAAA,IAAQ,eAAA,CAAgB,SAAA,EAAW,IAAI,CAAA,EAAG;AAC1D,MAAA,SAAA,CAAU,MAAA,CAAO,KAAK,KAAK,CAAA;AAAA,IAC7B;AAEA,IAAA,OAAO,IAAA,CAAK,KAAA;AAAA,EACd;AAEA,EAAA,OAAO,IAAA,CAAK,IAAA,CAAK,OAAO,SAAA,KAAc;AACpC,IAAA,IAAI,SAAA,CAAU,SAAS,IAAA,EAAM;AAC3B,MAAA,MAAM,SAAA,CAAU,MAAA,CAAO,SAAA,CAAU,KAAK,CAAA;AAAA,IACxC;AAEA,IAAA,OAAO,SAAA,CAAU,KAAA;AAAA,EACnB,CAAC,CAAA;AACH;AAMA,MAAM,UAAA,GAAa,CACjB,KAAA,KAEA,QAAA,CAAS,KAAK,CAAA,IAAK,MAAA,CAAO,OAAO,MAAM,CAAA;AAMzC,MAAM,eAAA,GAAkB,CACtB,UAAA,EAGA,IAAA,KAC0D,WAAW,IAAI,CAAA;;;;"}

package/dist/functional/result/impl/result-safe-unwrap.d.mts

@@ -0,0 +1,36 @@
+import { type UnknownResult } from '../result.mjs';
+import { type NarrowToErr, type UnwrapOk } from './types.mjs';
+/**
+ * Unwraps a `Result` inside a {@link Result.safeTry} generator body via
+ * `yield*`, emulating Rust's `?` operator.
+ *
+ * If the `Result` is `Ok`, the `yield*` expression evaluates to the contained
+ * value and execution continues. If it is `Err`, the error is yielded to
+ * {@link Result.safeTry}, which returns it immediately — the rest of the
+ * generator body never runs.
+ *
+ * This generator must only be delegated to (`yield*`) inside a
+ * {@link Result.safeTry} body; resuming it after it has yielded an `Err`
+ * throws.
+ *
+ * @example
+ *
+ * ```ts
+ * const result = Result.safeTry(function* () {
+ *   const x = yield* Result.safeUnwrap(Result.ok(2));
+ *
+ *   const y = yield* Result.safeUnwrap(Result.ok(3));
+ *
+ *   return Result.ok(x + y);
+ * });
+ *
+ * assert.deepStrictEqual(result, Result.ok(5));
+ * ```
+ *
+ * @template R The input `UnknownResult` type.
+ * @param result The `Result` to unwrap.
+ * @returns A generator that yields the `Err` (if any) and returns the `Ok`
+ *   value.
+ */
+export declare function safeUnwrap<R extends UnknownResult>(result: R): Generator<NarrowToErr<R>, UnwrapOk<R>, unknown>;
+//# sourceMappingURL=result-safe-unwrap.d.mts.map

package/dist/functional/result/impl/result-safe-unwrap.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-safe-unwrap.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-safe-unwrap.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAiB,UAAU,CAAC,CAAC,SAAS,aAAa,EACjD,MAAM,EAAE,CAAC,GACR,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAWjD"}