ts-data-forge 14.4.0 → 14.6.0

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

@@ -0,0 +1,45 @@
+import { type AsyncResult } from '../async-result.mjs';
+/**
+ * Maps an `AsyncResult<S, E>` to `AsyncResult<S2, E>` by applying a function
+ * to the success value. The mapping function may be synchronous or return a
+ * `Promise`; both are handled transparently. If the `AsyncResult` resolves to
+ * `Err`, the original `Err` is passed through and the function is not called.
+ *
+ * If `mapFn` throws or returns a rejecting Promise, the rejection propagates
+ * as-is — it is **not** caught and converted into an `Err`. `map` performs no
+ * implicit error conversion; write a fallible step as
+ * `AsyncResult.flatMap` combined with `AsyncResult.fromThrowable` instead, so
+ * that the error type stays explicit.
+ *
+ * @example
+ *
+ * ```ts
+ * const okValue = AsyncResult.fromPromise(
+ *   Promise.resolve(5),
+ *   () => 'failed',
+ * );
+ *
+ * const doubled = await AsyncResult.map(okValue, (value) => value * 2);
+ *
+ * assert.deepStrictEqual(doubled, Result.ok(10));
+ *
+ * const double = AsyncResult.map((value: number) => value * 2);
+ *
+ * const curried = await double(
+ *   AsyncResult.fromPromise(Promise.resolve(21), () => 'failed'),
+ * );
+ *
+ * assert.deepStrictEqual(curried, Result.ok(42));
+ * ```
+ *
+ * @template S The type of the success value of the input.
+ * @template S2 The type of the success value returned by the mapping
+ *   function.
+ * @template E The type of the error value.
+ * @param asyncResult The `AsyncResult` to map.
+ * @param mapFn The function to apply to the success value if present.
+ * @returns A new `AsyncResult<S2, E>`.
+ */
+export declare function map<S, S2, E>(asyncResult: AsyncResult<S, E>, mapFn: (value: S) => Promise<S2> | S2): AsyncResult<S2, E>;
+export declare function map<S, S2>(mapFn: (value: S) => Promise<S2> | S2): <E>(asyncResult: AsyncResult<S, E>) => AsyncResult<S2, E>;
+//# sourceMappingURL=async-result-map.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"async-result-map.d.mts","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/async-result-map.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAC1B,WAAW,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAC9B,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,GACpC,WAAW,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;AAQtB,wBAAgB,GAAG,CAAC,CAAC,EAAE,EAAE,EACvB,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,GACpC,CAAC,CAAC,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,WAAW,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,23 @@
+import { isErr } from '../../result/impl/result-is-err.mjs';
+import { ok } from '../../result/impl/result-ok.mjs';
+import '@sindresorhus/is';
+
+function map(...args) {
+  switch (args.length) {
+    case 2: {
+      const [asyncResult, mapFn] = args;
+      return mapImpl(asyncResult, mapFn);
+    }
+    case 1: {
+      const [mapFn] = args;
+      return (asyncResult) => mapImpl(asyncResult, mapFn);
+    }
+  }
+}
+const mapImpl = async (asyncResult, mapFn) => {
+  const result = await asyncResult;
+  return isErr(result) ? result : ok(await mapFn(result.value));
+};
+
+export { map };
+//# sourceMappingURL=async-result-map.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"async-result-map.mjs","sources":["../../../../src/functional/async-result/impl/async-result-map.mts"],"sourcesContent":["import { Result } from '../../result/index.mjs';\nimport { type AsyncResult } from '../async-result.mjs';\n\n/**\n * Maps an `AsyncResult<S, E>` to `AsyncResult<S2, E>` by applying a function\n * to the success value. The mapping function may be synchronous or return a\n * `Promise`; both are handled transparently. If the `AsyncResult` resolves to\n * `Err`, the original `Err` is passed through and the function is not called.\n *\n * If `mapFn` throws or returns a rejecting Promise, the rejection propagates\n * as-is — it is **not** caught and converted into an `Err`. `map` performs no\n * implicit error conversion; write a fallible step as\n * `AsyncResult.flatMap` combined with `AsyncResult.fromThrowable` instead, so\n * that the error type stays explicit.\n *\n * @example\n *\n * ```ts\n * const okValue = AsyncResult.fromPromise(\n *   Promise.resolve(5),\n *   () => 'failed',\n * );\n *\n * const doubled = await AsyncResult.map(okValue, (value) => value * 2);\n *\n * assert.deepStrictEqual(doubled, Result.ok(10));\n *\n * const double = AsyncResult.map((value: number) => value * 2);\n *\n * const curried = await double(\n *   AsyncResult.fromPromise(Promise.resolve(21), () => 'failed'),\n * );\n *\n * assert.deepStrictEqual(curried, Result.ok(42));\n * ```\n *\n * @template S The type of the success value of the input.\n * @template S2 The type of the success value returned by the mapping\n *   function.\n * @template E The type of the error value.\n * @param asyncResult The `AsyncResult` to map.\n * @param mapFn The function to apply to the success value if present.\n * @returns A new `AsyncResult<S2, E>`.\n */\nexport function map<S, S2, E>(\n  asyncResult: AsyncResult<S, E>,\n  mapFn: (value: S) => Promise<S2> | S2,\n): AsyncResult<S2, E>;\n\n// Curried version\n//\n// Unlike `Result.map`, the returned function can simply be generic over `E`:\n// an `AsyncResult` is a `Promise`, not a discriminated union, so there is no\n// literal-narrowing problem that would require the whole-result generic\n// trick used by the synchronous combinators.\nexport function map<S, S2>(\n  mapFn: (value: S) => Promise<S2> | S2,\n): <E>(asyncResult: AsyncResult<S, E>) => AsyncResult<S2, E>;\n\nexport function map<S, S2, E>(\n  ...args:\n    | readonly [\n        asyncResult: AsyncResult<S, E>,\n        mapFn: (value: S) => Promise<S2> | S2,\n      ]\n    | readonly [mapFn: (value: S) => Promise<S2> | S2]\n):\n  | AsyncResult<S2, E>\n  | ((asyncResult: AsyncResult<S, E>) => AsyncResult<S2, E>) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is asyncResult\n      const [asyncResult, mapFn] = args;\n\n      return mapImpl(asyncResult, mapFn);\n    }\n\n    case 1: {\n      // Curried version\n      const [mapFn] = args;\n\n      return (asyncResult: AsyncResult<S, E>) => mapImpl(asyncResult, mapFn);\n    }\n  }\n}\n\nconst mapImpl = async <S, S2, E>(\n  asyncResult: AsyncResult<S, E>,\n  mapFn: (value: S) => Promise<S2> | S2,\n): AsyncResult<S2, E> => {\n  const result = await asyncResult;\n\n  return Result.isErr(result) ? result : Result.ok(await mapFn(result.value));\n};\n"],"names":["Result.isErr","Result.ok"],"mappings":";;;;AA2DO,SAAS,OACX,IAAA,EAQwD;AAC3D,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,WAAA,EAAa,KAAK,CAAA,GAAI,IAAA;AAE7B,MAAA,OAAO,OAAA,CAAQ,aAAa,KAAK,CAAA;AAAA,IACnC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,WAAA,KAAmC,OAAA,CAAQ,WAAA,EAAa,KAAK,CAAA;AAAA,IACvE;AAAA;AAEJ;AAEA,MAAM,OAAA,GAAU,OACd,WAAA,EACA,KAAA,KACuB;AACvB,EAAA,MAAM,SAAS,MAAM,WAAA;AAErB,EAAA,OAAOA,KAAO,CAAM,MAAM,CAAA,GAAI,MAAA,GAASC,EAAO,CAAG,MAAM,KAAA,CAAM,MAAA,CAAO,KAAK,CAAC,CAAA;AAC5E,CAAA;;;;"}

package/dist/functional/async-result/impl/async-result-unwrap-or.d.mts

@@ -0,0 +1,34 @@
+import { type AsyncResult } from '../async-result.mjs';
+/**
+ * Unwraps an `AsyncResult`, resolving to the success value or a default value
+ * if it resolves to `Err`.
+ *
+ * @example
+ *
+ * ```ts
+ * const okValue = AsyncResult.fromPromise(
+ *   Promise.resolve(10),
+ *   () => 'failed',
+ * );
+ *
+ * const errValue = AsyncResult.fromPromise(
+ *   Promise.reject(new Error('boom')),
+ *   () => 'failed',
+ * );
+ *
+ * assert.isTrue((await AsyncResult.unwrapOr(okValue, 0)) === 10);
+ *
+ * assert.isTrue((await AsyncResult.unwrapOr(errValue, 0)) === 0);
+ * ```
+ *
+ * @template S The type of the success value.
+ * @template E The type of the error value.
+ * @template D The type of the default value.
+ * @param asyncResult The `AsyncResult` to unwrap.
+ * @param defaultValue The value to resolve to if `asyncResult` resolves to
+ *   `Err`.
+ * @returns A Promise of the success value if `Ok`, otherwise of
+ *   `defaultValue`.
+ */
+export declare const unwrapOr: <S, E, D>(asyncResult: AsyncResult<S, E>, defaultValue: D) => Promise<D | S>;
+//# sourceMappingURL=async-result-unwrap-or.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"async-result-unwrap-or.d.mts","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/async-result-unwrap-or.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,QAAQ,GAAU,CAAC,EAAE,CAAC,EAAE,CAAC,eACvB,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,gBAChB,CAAC,KACd,OAAO,CAAC,CAAC,GAAG,CAAC,CAIf,CAAC"}

package/dist/functional/async-result/impl/async-result-unwrap-or.mjs

@@ -0,0 +1,10 @@
+import { isOk } from '../../result/impl/result-is-ok.mjs';
+import '@sindresorhus/is';
+
+const unwrapOr = async (asyncResult, defaultValue) => {
+  const result = await asyncResult;
+  return isOk(result) ? result.value : defaultValue;
+};
+
+export { unwrapOr };
+//# sourceMappingURL=async-result-unwrap-or.mjs.map

package/dist/functional/async-result/impl/async-result-unwrap-or.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-result-unwrap-or.mjs","sources":["../../../../src/functional/async-result/impl/async-result-unwrap-or.mts"],"sourcesContent":["import { Result } from '../../result/index.mjs';\nimport { type AsyncResult } from '../async-result.mjs';\n\n/**\n * Unwraps an `AsyncResult`, resolving to the success value or a default value\n * if it resolves to `Err`.\n *\n * @example\n *\n * ```ts\n * const okValue = AsyncResult.fromPromise(\n *   Promise.resolve(10),\n *   () => 'failed',\n * );\n *\n * const errValue = AsyncResult.fromPromise(\n *   Promise.reject(new Error('boom')),\n *   () => 'failed',\n * );\n *\n * assert.isTrue((await AsyncResult.unwrapOr(okValue, 0)) === 10);\n *\n * assert.isTrue((await AsyncResult.unwrapOr(errValue, 0)) === 0);\n * ```\n *\n * @template S The type of the success value.\n * @template E The type of the error value.\n * @template D The type of the default value.\n * @param asyncResult The `AsyncResult` to unwrap.\n * @param defaultValue The value to resolve to if `asyncResult` resolves to\n *   `Err`.\n * @returns A Promise of the success value if `Ok`, otherwise of\n *   `defaultValue`.\n */\nexport const unwrapOr = async <S, E, D>(\n  asyncResult: AsyncResult<S, E>,\n  defaultValue: D,\n): Promise<D | S> => {\n  const result = await asyncResult;\n\n  return Result.isOk(result) ? result.value : defaultValue;\n};\n"],"names":["Result.isOk"],"mappings":";;;AAkCO,MAAM,QAAA,GAAW,OACtB,WAAA,EACA,YAAA,KACmB;AACnB,EAAA,MAAM,SAAS,MAAM,WAAA;AAErB,EAAA,OAAOA,IAAO,CAAK,MAAM,CAAA,GAAI,OAAO,KAAA,GAAQ,YAAA;AAC9C;;;;"}

package/dist/functional/async-result/impl/index.d.mts

@@ -0,0 +1,8 @@
+export * from './async-result-flat-map.mjs';
+export * from './async-result-from-promise.mjs';
+export * from './async-result-from-throwable.mjs';
+export * from './async-result-map-err.mjs';
+export * from './async-result-map.mjs';
+export * from './async-result-unwrap-or.mjs';
+export * from './types.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/functional/async-result/impl/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/index.mts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;AAClD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,aAAa,CAAC"}

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

@@ -0,0 +1,7 @@
+export { flatMap } from './async-result-flat-map.mjs';
+export { fromPromise } from './async-result-from-promise.mjs';
+export { fromThrowable } from './async-result-from-throwable.mjs';
+export { mapErr } from './async-result-map-err.mjs';
+export { map } from './async-result-map.mjs';
+export { unwrapOr } from './async-result-unwrap-or.mjs';
+//# sourceMappingURL=index.mjs.map

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

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

package/dist/functional/async-result/impl/types.d.mts

@@ -0,0 +1,45 @@
+import { type Err, type Ok } from '../../../types.mjs';
+import { type UnknownResult } from '../../result/index.mjs';
+import { type AsyncResult } from '../async-result.mjs';
+/**
+ * Base type for any `AsyncResult`, used for generic constraints. Represents
+ * an `AsyncResult` with unknown success and error types.
+ */
+export type UnknownAsyncResult = AsyncResult<unknown, unknown>;
+/**
+ * Extracts the success value type `S` from a `Result.Ok<S>`, or from an
+ * `AsyncResult` resolving to one. Distributes over unions, so an
+ * `Ok<S> | Err<E>` union resolves to `S`.
+ *
+ * @template R The `Result` or `AsyncResult` type to unwrap.
+ */
+export type UnwrapOk<R extends UnknownAsyncResult | UnknownResult> = UnwrapOkImpl<SyncResultOf<R>>;
+/**
+ * Extracts the error value type `E` from a `Result.Err<E>`, or from an
+ * `AsyncResult` resolving to one. Distributes over unions, so an
+ * `Ok<S> | Err<E>` union resolves to `E`.
+ *
+ * @template R The `Result` or `AsyncResult` type to unwrap.
+ */
+export type UnwrapErr<R extends UnknownAsyncResult | UnknownResult> = UnwrapErrImpl<SyncResultOf<R>>;
+/**
+ * @template R The `Result` or `AsyncResult` type.
+ * @internal
+ * Resolves an `AsyncResult` to its `Result`, leaving a plain `Result`
+ * unchanged. Distributive.
+ */
+type SyncResultOf<R> = R extends Promise<infer P> ? P : R;
+/**
+ * @template R The `Result` type to unwrap.
+ * @internal
+ * Distributive extraction of the `Ok` value type.
+ */
+type UnwrapOkImpl<R> = R extends Ok<infer S> ? S : never;
+/**
+ * @template R The `Result` type to unwrap.
+ * @internal
+ * Distributive extraction of the `Err` value type.
+ */
+type UnwrapErrImpl<R> = R extends Err<infer E> ? E : never;
+export {};
+//# sourceMappingURL=types.d.mts.map

package/dist/functional/async-result/impl/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/types.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;AAE/D;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,kBAAkB,GAAG,aAAa,IAC/D,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;AAEhC;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,kBAAkB,GAAG,aAAa,IAChE,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;AAEjC;;;;;GAKG;AACH,KAAK,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE1D;;;;GAIG;AACH,KAAK,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEzD;;;;GAIG;AACH,KAAK,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC"}

package/dist/functional/async-result/impl/types.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=types.mjs.map

package/dist/functional/async-result/impl/types.mjs.map

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

package/dist/functional/async-result/index.d.mts

@@ -0,0 +1,2 @@
+export * from './async-result.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/functional/async-result/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/functional/async-result/index.mts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/functional/async-result/index.mjs

@@ -0,0 +1,3 @@
+import * as index from './impl/index.mjs';
+export { index as AsyncResult };
+//# sourceMappingURL=index.mjs.map

package/dist/functional/async-result/index.mjs.map

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

package/dist/functional/index.d.mts

@@ -1,3 +1,4 @@
+export * from './async-result/index.mjs';
 export * from './match.mjs';
 export * from './optional/index.mjs';
 export * from './pipe.mjs';

package/dist/functional/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/functional/index.mts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/functional/index.mts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC"}

package/dist/functional/index.mjs

@@ -1,9 +1,11 @@
+import * as index from './async-result/impl/index.mjs';
+export { index as AsyncResult };
 export { match } from './match.mjs';
-import * as index from './optional/impl/index.mjs';
-export { index as Optional };
+import * as index$1 from './optional/impl/index.mjs';
+export { index$1 as Optional };
 export { pipe } from './pipe.mjs';
-import * as index$1 from './result/impl/index.mjs';
-export { index$1 as Result };
-import * as index$2 from './ternary-result/impl/index.mjs';
-export { index$2 as TernaryResult };
+import * as index$2 from './result/impl/index.mjs';
+export { index$2 as Result };
+import * as index$3 from './ternary-result/impl/index.mjs';
+export { index$3 as TernaryResult };
 //# sourceMappingURL=index.mjs.map

package/dist/functional/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/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-from-promise.d.mts

@@ -11,6 +11,11 @@ type UnwrapPromise<P extends Promise<unknown>> = P extends Promise<infer V> ? V
  * input Promise rejects, the `Result` will be `Err` with the rejection
  * reason.
  *
+ * The error channel is `unknown`, since the rejection reason is carried
+ * through untouched. For a concrete error type, use `AsyncResult.fromPromise`
+ * with a `mapError` function; called without one it behaves exactly as this
+ * function does.
+ *
  * @example
  *
  * ```ts

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

@@ -1 +1 @@
-{"version":3,"file":"result-from-promise.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-from-promise.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAI5C;;;;GAIG;AACH,KAAK,aAAa,CAAC,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,IAC3C,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,WAC3C,CAAC,KACT,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAEmB,CAAC"}
+{"version":3,"file":"result-from-promise.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-from-promise.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAI5C;;;;GAIG;AACH,KAAK,aAAa,CAAC,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,IAC3C,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,WAC3C,CAAC,KACT,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAEmB,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"result-from-promise.mjs","sources":["../../../../src/functional/result/impl/result-from-promise.mts"],"sourcesContent":["import { type Ok } from '../../../types.mjs';\nimport { type Result } from '../result.mjs';\nimport { err } from './result-err.mjs';\nimport { ok } from './result-ok.mjs';\n\n/**\n * @template P The Promise type.\n * @internal\n * Utility type to extract the resolved value type from a Promise.\n */\ntype UnwrapPromise<P extends Promise<unknown>> =\n  P extends Promise<infer V> ? V : never;\n\n/**\n * Converts a Promise into a Promise that resolves to a `Result`. If the input\n * Promise resolves, the `Result` will be `Ok` with the resolved value. If the\n * input Promise rejects, the `Result` will be `Err` with the rejection\n * reason.\n *\n * @example\n *\n * ```ts\n * const successPromise = Result.fromPromise(Promise.resolve('ok'));\n *\n * const failurePromise = Result.fromPromise(\n *   Promise.reject(new Error('fail')),\n * );\n *\n * const resolved = await successPromise;\n *\n * const rejected = await failurePromise;\n *\n * assert.deepStrictEqual(resolved, Result.ok('ok'));\n *\n * assert.isTrue(Result.isErr(rejected));\n * ```\n *\n * @template P The type of the input Promise.\n * @param promise The Promise to convert.\n * @returns A Promise that resolves to `Result<UnwrapPromise<P>, unknown>`.\n */\nexport const fromPromise = <P extends Promise<unknown>>(\n  promise: P,\n): Promise<Result<UnwrapPromise<P>, unknown>> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  promise.then((v) => ok(v) as Ok<UnwrapPromise<P>>).catch(err);\n"],"names":[],"mappings":";;;AAyCO,MAAM,cAAc,CACzB,OAAA;AAAA;AAAA,EAGA,OAAA,CAAQ,KAAK,CAAC,CAAA,KAAM,GAAG,CAAC,CAAyB,CAAA,CAAE,KAAA,CAAM,GAAG;AAAA;;;;"}
+{"version":3,"file":"result-from-promise.mjs","sources":["../../../../src/functional/result/impl/result-from-promise.mts"],"sourcesContent":["import { type Ok } from '../../../types.mjs';\nimport { type Result } from '../result.mjs';\nimport { err } from './result-err.mjs';\nimport { ok } from './result-ok.mjs';\n\n/**\n * @template P The Promise type.\n * @internal\n * Utility type to extract the resolved value type from a Promise.\n */\ntype UnwrapPromise<P extends Promise<unknown>> =\n  P extends Promise<infer V> ? V : never;\n\n/**\n * Converts a Promise into a Promise that resolves to a `Result`. If the input\n * Promise resolves, the `Result` will be `Ok` with the resolved value. If the\n * input Promise rejects, the `Result` will be `Err` with the rejection\n * reason.\n *\n * The error channel is `unknown`, since the rejection reason is carried\n * through untouched. For a concrete error type, use `AsyncResult.fromPromise`\n * with a `mapError` function; called without one it behaves exactly as this\n * function does.\n *\n * @example\n *\n * ```ts\n * const successPromise = Result.fromPromise(Promise.resolve('ok'));\n *\n * const failurePromise = Result.fromPromise(\n *   Promise.reject(new Error('fail')),\n * );\n *\n * const resolved = await successPromise;\n *\n * const rejected = await failurePromise;\n *\n * assert.deepStrictEqual(resolved, Result.ok('ok'));\n *\n * assert.isTrue(Result.isErr(rejected));\n * ```\n *\n * @template P The type of the input Promise.\n * @param promise The Promise to convert.\n * @returns A Promise that resolves to `Result<UnwrapPromise<P>, unknown>`.\n */\nexport const fromPromise = <P extends Promise<unknown>>(\n  promise: P,\n): Promise<Result<UnwrapPromise<P>, unknown>> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  promise.then((v) => ok(v) as Ok<UnwrapPromise<P>>).catch(err);\n"],"names":[],"mappings":";;;AA8CO,MAAM,cAAc,CACzB,OAAA;AAAA;AAAA,EAGA,OAAA,CAAQ,KAAK,CAAC,CAAA,KAAM,GAAG,CAAC,CAAyB,CAAA,CAAE,KAAA,CAAM,GAAG;AAAA;;;;"}

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"}