ts-data-forge 3.3.0 → 4.0.0

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

@@ -0,0 +1,33 @@
+import { type UnwrapErr, type UnwrapOk } from './types.mjs';
+/**
+ * Maps a `Result<S, E>` to `Result<S, E2>` by applying a function to the
+ * error value. If the `Result` is `Result.Ok`, returns the original `Ok`.
+ *
+ * @example
+ *
+ * ```ts
+ * const okValue = Result.ok(3) as Result<number, string>;
+ * const errValue = Result.err('missing');
+ *
+ * const untouchedOk = Result.mapErr(okValue, (error) => error.toUpperCase());
+ * const uppercasedErr = Result.mapErr(errValue, (error) => error.toUpperCase());
+ *
+ * assert.deepStrictEqual(untouchedOk, Result.ok(3));
+ * assert.deepStrictEqual(uppercasedErr, Result.err('MISSING'));
+ *
+ * const mapError = Result.mapErr((error: Readonly<Error>) => error.message);
+ *
+ * const wrapped = mapError(Result.err(new Error('boom')));
+ *
+ * assert.deepStrictEqual(wrapped, Result.err('boom'));
+ * ```
+ *
+ * @template R The input `UnknownResult` type.
+ * @template E2 The type of the error value returned by the mapping function.
+ * @param result The `Result` to map.
+ * @param mapFn The function to apply to the error value if present.
+ * @returns A new `Result<UnwrapOk<R>, E2>`.
+ */
+export declare function mapErr<R extends UnknownResult, E2>(result: R, mapFn: (error: UnwrapErr<R>) => E2): Result<UnwrapOk<R>, E2>;
+export declare function mapErr<E, E2>(mapFn: (error: E) => E2): <S>(result: Result<S, E>) => Result<S, E2>;
+//# sourceMappingURL=result-map-err.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-map-err.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-map-err.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,aAAa,EAAE,EAAE,EAChD,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,EAAE,GACjC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAG3B,wBAAgB,MAAM,CAAC,CAAC,EAAE,EAAE,EAC1B,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GACtB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC"}

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

@@ -0,0 +1,25 @@
+import { err } from './result-err.mjs';
+import { isOk } from './result-is-ok.mjs';
+
+function mapErr(...args) {
+    switch (args.length) {
+        case 2: {
+            // Direct version: first argument is result
+            const [result, mapFn] = args;
+            return mapErrImpl(result, mapFn);
+        }
+        case 1: {
+            // Curried version: first argument is mapping function
+            const [mapFn] = args;
+            return (result) => mapErrImpl(result, mapFn);
+        }
+    }
+}
+const mapErrImpl = (result, mapFn) => isOk(result)
+    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        result
+    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        err(mapFn(result.value));
+
+export { mapErr };
+//# sourceMappingURL=result-map-err.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-map-err.mjs","sources":["../../../../src/functional/result/impl/result-map-err.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AA2CM,SAAU,MAAM,CACpB,GAAG,IAE8C,EAAA;AAEjD,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,IAAI;AAC5B,YAAA,OAAO,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC;QAClC;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI;YACpB,OAAO,CAAC,MAAS,KAAK,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC;QACjD;;AAEJ;AAEA,MAAM,UAAU,GAAG,CACjB,MAAS,EACT,KAAkC,KAElC,IAAI,CAAC,MAAM;AACT;QACG;AACH;QACE,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,KAAqB,CAAC,CAAC;;;;"}

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

@@ -0,0 +1,34 @@
+import { type UnwrapErr, type UnwrapOk } from './types.mjs';
+/**
+ * Maps a `Result<S, E>` to `Result<S2, E>` by applying a function to the
+ * success value. If the `Result` is `Result.Err`, returns the original
+ * `Err`.
+ *
+ * @example
+ *
+ * ```ts
+ * const okNumber = Result.ok(5);
+ * const errMessage = Result.err('error');
+ *
+ * const doubled = Result.map(okNumber, (value) => value * 2);
+ * const untouchedError = Result.map(errMessage, (value: number) => value * 2);
+ *
+ * assert.deepStrictEqual(doubled, Result.ok(10));
+ * assert.deepStrictEqual(untouchedError, errMessage);
+ *
+ * const mapToLength = Result.map((text: string) => text.length);
+ *
+ * assert.deepStrictEqual(mapToLength(Result.ok('abc')), Result.ok(3));
+ * assert.deepStrictEqual(mapToLength(Result.err('bad')), Result.err('bad'));
+ * ```
+ *
+ * @template R The input `UnknownResult` type.
+ * @template S2 The type of the success value returned by the mapping
+ *   function.
+ * @param result The `Result` to map.
+ * @param mapFn The function to apply to the success value if present.
+ * @returns A new `Result<S2, UnwrapErr<R>>`.
+ */
+export declare function map<R extends UnknownResult, S2>(result: R, mapFn: (value: UnwrapOk<R>) => S2): Result<S2, UnwrapErr<R>>;
+export declare function map<S, S2>(mapFn: (value: S) => S2): <E>(result: Result<S, E>) => Result<S2, E>;
+//# sourceMappingURL=result-map.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-map.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-map.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,aAAa,EAAE,EAAE,EAC7C,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,EAAE,GAChC,MAAM,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AAG5B,wBAAgB,GAAG,CAAC,CAAC,EAAE,EAAE,EACvB,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GACtB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,25 @@
+import { isErr } from './result-is-err.mjs';
+import { ok } from './result-ok.mjs';
+
+function map(...args) {
+    switch (args.length) {
+        case 2: {
+            // Direct version: first argument is result
+            const [result, mapFn] = args;
+            return mapImpl(result, mapFn);
+        }
+        case 1: {
+            // Curried version
+            const [mapFn] = args;
+            return (result) => mapImpl(result, mapFn);
+        }
+    }
+}
+const mapImpl = (result, mapFn) => isErr(result)
+    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        result
+    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        ok(mapFn(result.value));
+
+export { map };
+//# sourceMappingURL=result-map.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-map.mjs","sources":["../../../../src/functional/result/impl/result-map.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AA4CM,SAAU,GAAG,CACjB,GAAG,IAE6C,EAAA;AAEhD,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,IAAI;AAC5B,YAAA,OAAO,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC;QAC/B;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI;YACpB,OAAO,CAAC,MAAS,KAAK,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC;QAC9C;;AAEJ;AAEA,MAAM,OAAO,GAAG,CACd,MAAS,EACT,KAAiC,KAEjC,KAAK,CAAC,MAAM;AACV;QACG;AACH;QACE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,KAAoB,CAAC,CAAC;;;;"}

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

@@ -0,0 +1,25 @@
+/**
+ * Creates a `Result.Ok` containing the given success value.
+ *
+ * Use this constructor when an operation succeeds and you want to wrap the
+ * successful result in a Result type for consistent error handling.
+ *
+ * @example
+ *
+ * ```ts
+ * const success = Result.ok({ id: 1 });
+ * const failure = Result.err(new Error('missing data'));
+ *
+ * assert.deepStrictEqual(success, {
+ *   $$tag: 'ts-data-forge::Result.ok',
+ *   value: { id: 1 },
+ * });
+ * assert.ok(Result.isErr(failure));
+ * ```
+ *
+ * @template S The type of the success value.
+ * @param value The success value.
+ * @returns A `Result.Ok<S>` containing the value.
+ */
+export declare const ok: <S>(value: S) => Ok<S>;
+//# sourceMappingURL=result-ok.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-ok.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-ok.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,EAAE,GAAI,CAAC,EAAG,OAAO,CAAC,KAAG,EAAE,CAAC,CAAC,CAGpC,CAAC"}

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

@@ -0,0 +1,32 @@
+import { OkTypeTagName } from './tag.mjs';
+
+/**
+ * Creates a `Result.Ok` containing the given success value.
+ *
+ * Use this constructor when an operation succeeds and you want to wrap the
+ * successful result in a Result type for consistent error handling.
+ *
+ * @example
+ *
+ * ```ts
+ * const success = Result.ok({ id: 1 });
+ * const failure = Result.err(new Error('missing data'));
+ *
+ * assert.deepStrictEqual(success, {
+ *   $$tag: 'ts-data-forge::Result.ok',
+ *   value: { id: 1 },
+ * });
+ * assert.ok(Result.isErr(failure));
+ * ```
+ *
+ * @template S The type of the success value.
+ * @param value The success value.
+ * @returns A `Result.Ok<S>` containing the value.
+ */
+const ok = (value) => ({
+    $$tag: OkTypeTagName,
+    value,
+});
+
+export { ok };
+//# sourceMappingURL=result-ok.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-ok.mjs","sources":["../../../../src/functional/result/impl/result-ok.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;;;AAsBG;MACU,EAAE,GAAG,CAAK,KAAQ,MAAa;AAC1C,IAAA,KAAK,EAAE,aAAa;IACpB,KAAK;AACN,CAAA;;;;"}

package/dist/functional/result/impl/result-or-else.d.mts

@@ -0,0 +1,32 @@
+import { type NarrowToOk } from './types.mjs';
+/**
+ * Returns the `Result` if it is `Ok`, otherwise returns the alternative.
+ *
+ * @example
+ *
+ * ```ts
+ * const primary = Result.ok('primary');
+ * const fallback = Result.ok('fallback');
+ * const failure = Result.err('failure');
+ *
+ * assert.deepStrictEqual(Result.orElse(primary, fallback), primary);
+ * assert.deepStrictEqual(Result.orElse(failure, fallback), fallback);
+ *
+ * const orElseFallback = Result.orElse(Result.ok('default'));
+ *
+ * assert.deepStrictEqual(
+ *   orElseFallback(Result.err('missing')),
+ *   Result.ok('default'),
+ * );
+ * assert.deepStrictEqual(orElseFallback(Result.ok('value')), Result.ok('value'));
+ * ```
+ *
+ * @template R The input `UnknownResult` type.
+ * @param result The `Result` to check.
+ * @param alternative The alternative `Result` to return if the first is
+ *   `Err`.
+ * @returns The first `Result` if `Ok`, otherwise the alternative.
+ */
+export declare function orElse<R extends UnknownResult, R2 extends UnknownResult>(result: R, alternative: R2): NarrowToOk<R> | R2;
+export declare function orElse<S, E, S2, E2>(alternative: Result<S2, E2>): (result: Result<S, E>) => Result<S, E> | Result<S2, E2>;
+//# sourceMappingURL=result-or-else.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-or-else.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-or-else.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,aAAa,EAAE,EAAE,SAAS,aAAa,EACtE,MAAM,EAAE,CAAC,EACT,WAAW,EAAE,EAAE,GACd,UAAU,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;AAGtB,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACjC,WAAW,EAAE,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,GAC1B,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC"}

package/dist/functional/result/impl/result-or-else.mjs

@@ -0,0 +1,20 @@
+import { isOk } from './result-is-ok.mjs';
+
+function orElse(...args) {
+    switch (args.length) {
+        case 2: {
+            // Direct version: first argument is result
+            const [result, alternative] = args;
+            return orElseImpl(result, alternative);
+        }
+        case 1: {
+            // Curried version
+            const [alternative] = args;
+            return (result) => orElseImpl(result, alternative);
+        }
+    }
+}
+const orElseImpl = (result, alternative) => (isOk(result) ? result : alternative);
+
+export { orElse };
+//# sourceMappingURL=result-or-else.mjs.map

package/dist/functional/result/impl/result-or-else.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-or-else.mjs","sources":["../../../../src/functional/result/impl/result-or-else.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAyCM,SAAU,MAAM,CACpB,GAAG,IAAwE,EAAA;AAE3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,IAAI;AAClC,YAAA,OAAO,UAAU,CAAC,MAAM,EAAE,WAAW,CAAC;QACxC;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,WAAW,CAAC,GAAG,IAAI;YAC1B,OAAO,CAAC,MAAS,KAAK,UAAU,CAAC,MAAM,EAAE,WAAW,CAAC;QACvD;;AAEJ;AAEA,MAAM,UAAU,GAAG,CACjB,MAAS,EACT,WAAe,MACS,IAAI,CAAC,MAAM,CAAC,GAAG,MAAM,GAAG,WAAW,CAAC;;;;"}

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

@@ -0,0 +1,20 @@
+import { type UnwrapErr, type UnwrapOk } from './types.mjs';
+/**
+ * Swaps the success and error values of a `Result`.
+ *
+ * @example
+ *
+ * ```ts
+ * const okValue = Result.ok('value');
+ * const errValue = Result.err('error');
+ *
+ * assert.deepStrictEqual(Result.swap(okValue), Result.err('value'));
+ * assert.deepStrictEqual(Result.swap(errValue), Result.ok('error'));
+ * ```
+ *
+ * @template R The input `UnknownResult` type.
+ * @param result The `Result` to swap.
+ * @returns A new `Result` with success and error swapped.
+ */
+export declare const swap: <R extends UnknownResult>(result: R) => Result<UnwrapErr<R>, UnwrapOk<R>>;
+//# sourceMappingURL=result-swap.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-swap.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-swap.mts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,aAAa,EAC1C,QAAQ,CAAC,KACR,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAEsC,CAAC"}

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

@@ -0,0 +1,28 @@
+import { err } from './result-err.mjs';
+import { isOk } from './result-is-ok.mjs';
+import { ok } from './result-ok.mjs';
+import { unwrapOk } from './result-unwrap-ok.mjs';
+
+/**
+ * Swaps the success and error values of a `Result`.
+ *
+ * @example
+ *
+ * ```ts
+ * const okValue = Result.ok('value');
+ * const errValue = Result.err('error');
+ *
+ * assert.deepStrictEqual(Result.swap(okValue), Result.err('value'));
+ * assert.deepStrictEqual(Result.swap(errValue), Result.ok('error'));
+ * ```
+ *
+ * @template R The input `UnknownResult` type.
+ * @param result The `Result` to swap.
+ * @returns A new `Result` with success and error swapped.
+ */
+const swap = (result) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+isOk(result) ? err(unwrapOk(result)) : ok(result.value);
+
+export { swap };
+//# sourceMappingURL=result-swap.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-swap.mjs","sources":["../../../../src/functional/result/impl/result-swap.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAMA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,IAAI,GAAG,CAClB,MAAS;AAET;AACA,IAAI,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,KAAqB;;;;"}

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

@@ -0,0 +1,28 @@
+import { type UnwrapOk } from './types.mjs';
+/**
+ * Converts a `Result` to an `Optional`.
+ *
+ * This conversion is useful when you want to discard error information and
+ * only care about whether an operation succeeded. The error information is
+ * lost in this conversion, so use it when error details are not needed.
+ *
+ * If the `Result` is `Ok`, returns `Some` with the value. If the `Result` is
+ * `Err`, returns `None`.
+ *
+ * @example
+ *
+ * ```ts
+ * const okValue = Result.ok(7);
+ * const errValue = Result.err('fail');
+ *
+ * assert.deepStrictEqual(Result.toOptional(okValue), Optional.some(7));
+ * assert.deepStrictEqual(Result.toOptional(errValue), Optional.none);
+ * ```
+ *
+ * @template R The input `UnknownResult` type.
+ * @param result The `Result` to convert.
+ * @returns An `Optional<UnwrapOk<R>>` containing the success value or
+ *   representing `None`.
+ */
+export declare const toOptional: <R extends UnknownResult>(result: R) => Optional<UnwrapOk<R>>;
+//# sourceMappingURL=result-to-optional.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-to-optional.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-to-optional.mts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,aAAa,EAChD,QAAQ,CAAC,KACR,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CACyC,CAAC"}

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

@@ -0,0 +1,34 @@
+import { none } from '../../optional/impl/optional-none.mjs';
+import { some } from '../../optional/impl/optional-some.mjs';
+import { isOk } from './result-is-ok.mjs';
+import { unwrapOk } from './result-unwrap-ok.mjs';
+
+/**
+ * Converts a `Result` to an `Optional`.
+ *
+ * This conversion is useful when you want to discard error information and
+ * only care about whether an operation succeeded. The error information is
+ * lost in this conversion, so use it when error details are not needed.
+ *
+ * If the `Result` is `Ok`, returns `Some` with the value. If the `Result` is
+ * `Err`, returns `None`.
+ *
+ * @example
+ *
+ * ```ts
+ * const okValue = Result.ok(7);
+ * const errValue = Result.err('fail');
+ *
+ * assert.deepStrictEqual(Result.toOptional(okValue), Optional.some(7));
+ * assert.deepStrictEqual(Result.toOptional(errValue), Optional.none);
+ * ```
+ *
+ * @template R The input `UnknownResult` type.
+ * @param result The `Result` to convert.
+ * @returns An `Optional<UnwrapOk<R>>` containing the success value or
+ *   representing `None`.
+ */
+const toOptional = (result) => isOk(result) ? some(unwrapOk(result)) : none;
+
+export { toOptional };
+//# sourceMappingURL=result-to-optional.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-to-optional.mjs","sources":["../../../../src/functional/result/impl/result-to-optional.mts"],"sourcesContent":[null],"names":["Optional.some","Optional.none"],"mappings":";;;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACI,MAAM,UAAU,GAAG,CACxB,MAAS,KAET,IAAI,CAAC,MAAM,CAAC,GAAGA,IAAa,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAGC;;;;"}

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

@@ -0,0 +1,29 @@
+import { type UnwrapErr } from './types.mjs';
+/**
+ * Unwraps a `Result`, returning the error value or a default value if it is
+ * `Result.Ok`.
+ *
+ * @example
+ *
+ * ```ts
+ * const okResult = Result.ok('success');
+ * const errResult = Result.err('failure');
+ *
+ * assert(Result.unwrapErrOr(okResult, 'default') === 'default');
+ * assert(Result.unwrapErrOr(errResult, 'default') === 'failure');
+ *
+ * const unwrapError = Result.unwrapErrOr('fallback error');
+ *
+ * assert(unwrapError(Result.err('boom')) === 'boom');
+ * assert(unwrapError(Result.ok('no error')) === 'fallback error');
+ * ```
+ *
+ * @template R The `UnknownResult` type to unwrap.
+ * @template D The type of the default value.
+ * @param result The `Result` to unwrap.
+ * @param defaultValue The value to return if `result` is `Result.Ok`.
+ * @returns The error value if `Result.Err`, otherwise `defaultValue`.
+ */
+export declare function unwrapErrOr<R extends UnknownResult, D>(result: R, defaultValue: D): D | UnwrapErr<R>;
+export declare function unwrapErrOr<D>(defaultValue: D): <S, E>(result: Result<S, E>) => D | E;
+//# sourceMappingURL=result-unwrap-err-or.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-unwrap-err-or.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-unwrap-err-or.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,aAAa,EAAE,CAAC,EACpD,MAAM,EAAE,CAAC,EACT,YAAY,EAAE,CAAC,GACd,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;AAGpB,wBAAgB,WAAW,CAAC,CAAC,EAC3B,YAAY,EAAE,CAAC,GACd,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC"}

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

@@ -0,0 +1,20 @@
+import { unwrapErr } from './result-unwrap-err.mjs';
+
+function unwrapErrOr(...args) {
+    switch (args.length) {
+        case 2: {
+            // Direct version: first argument is result
+            const [result, defaultValue] = args;
+            return unwrapErrOrImpl(result, defaultValue);
+        }
+        case 1: {
+            // Curried version
+            const [defaultValue] = args;
+            return (result) => unwrapErrOrImpl(result, defaultValue);
+        }
+    }
+}
+const unwrapErrOrImpl = (result, defaultValue) => unwrapErr(result) ?? defaultValue;
+
+export { unwrapErrOr };
+//# sourceMappingURL=result-unwrap-err-or.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-unwrap-err-or.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-err-or.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAsCM,SAAU,WAAW,CACzB,GAAG,IAAwE,EAAA;AAE3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,IAAI;AACnC,YAAA,OAAO,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC;QAC9C;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,YAAY,CAAC,GAAG,IAAI;YAC3B,OAAO,CAAC,MAAS,KAAK,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC;QAC7D;;AAEJ;AAEA,MAAM,eAAe,GAAG,CACtB,MAAS,EACT,YAAe,KACM,SAAS,CAAC,MAAM,CAAC,IAAI,YAAY;;;;"}

package/dist/functional/result/impl/result-unwrap-err-throw.d.mts

@@ -0,0 +1,30 @@
+import { type UnwrapErr, type UnwrapOk } from './types.mjs';
+/**
+ * Unwraps a `Result`, returning the error value. Throws an error if the
+ * `Result` is `Result.Ok`.
+ *
+ * This function is used when you expect a Result to be an error and want to
+ * extract the error value. If the Result is unexpectedly Ok, it will throw an
+ * error with information about the unexpected success value.
+ *
+ * @example
+ *
+ * ```ts
+ * const errResult = Result.err(new Error('broken'));
+ * const okResult = Result.ok('value');
+ *
+ * assert(Result.unwrapErrThrow(errResult).message === 'broken');
+ * assert.throws(() => Result.unwrapErrThrow(okResult), /Expected Err/u);
+ * ```
+ *
+ * @template R The `UnknownResult` type to unwrap.
+ * @param result The `Result` to unwrap.
+ * @param toStr An optional function to convert the success value to a string
+ *   for the error message when the Result is unexpectedly Ok. Defaults to
+ *   `String`.
+ * @returns The error value if `Result.Err`.
+ * @throws {Error} Error with message "Expected Err but got Ok: {value}" if
+ *   the `Result` is `Result.Ok`.
+ */
+export declare const unwrapErrThrow: <R extends UnknownResult>(result: R, toStr?: (v: UnwrapOk<R>) => string) => UnwrapErr<R>;
+//# sourceMappingURL=result-unwrap-err-throw.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-unwrap-err-throw.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-unwrap-err-throw.mts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,aAAa,EACpD,QAAQ,CAAC,EACT,QAAO,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,MAAwB,KAClD,SAAS,CAAC,CAAC,CAiBb,CAAC"}

package/dist/functional/result/impl/result-unwrap-err-throw.mjs

@@ -0,0 +1,47 @@
+import { unknownToString } from '../../../others/unknown-to-string.mjs';
+import { match } from '../../match.mjs';
+import { isErr } from './result-is-err.mjs';
+
+/**
+ * Unwraps a `Result`, returning the error value. Throws an error if the
+ * `Result` is `Result.Ok`.
+ *
+ * This function is used when you expect a Result to be an error and want to
+ * extract the error value. If the Result is unexpectedly Ok, it will throw an
+ * error with information about the unexpected success value.
+ *
+ * @example
+ *
+ * ```ts
+ * const errResult = Result.err(new Error('broken'));
+ * const okResult = Result.ok('value');
+ *
+ * assert(Result.unwrapErrThrow(errResult).message === 'broken');
+ * assert.throws(() => Result.unwrapErrThrow(okResult), /Expected Err/u);
+ * ```
+ *
+ * @template R The `UnknownResult` type to unwrap.
+ * @param result The `Result` to unwrap.
+ * @param toStr An optional function to convert the success value to a string
+ *   for the error message when the Result is unexpectedly Ok. Defaults to
+ *   `String`.
+ * @returns The error value if `Result.Err`.
+ * @throws {Error} Error with message "Expected Err but got Ok: {value}" if
+ *   the `Result` is `Result.Ok`.
+ */
+const unwrapErrThrow = (result, toStr = unknownToString) => {
+    if (isErr(result)) {
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        return result.value;
+    }
+    const variant = match(result.$$tag, {
+        'ts-data-forge::Result.ok': 'Ok',
+        'ts-data-forge::Result.err': 'Err',
+    });
+    throw new Error(`Expected Err but got ${variant}: ${toStr(
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    result.value)}`);
+};
+
+export { unwrapErrThrow };
+//# sourceMappingURL=result-unwrap-err-throw.mjs.map

package/dist/functional/result/impl/result-unwrap-err-throw.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-unwrap-err-throw.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-err-throw.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,cAAc,GAAG,CAC5B,MAAS,EACT,KAAA,GAAoC,eAAe,KACnC;AAChB,IAAA,IAAI,KAAK,CAAC,MAAM,CAAC,EAAE;;QAEjB,OAAO,MAAM,CAAC,KAAqB;IACrC;AAEA,IAAA,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE;AAClC,QAAA,0BAA0B,EAAE,IAAI;AAChC,QAAA,2BAA2B,EAAE,KAAK;AACnC,KAAA,CAAC;AAEF,IAAA,MAAM,IAAI,KAAK,CACb,CAAA,qBAAA,EAAwB,OAAO,KAAK,KAAK;;AAEvC,IAAA,MAAM,CAAC,KAAoB,CAC5B,CAAA,CAAE,CACJ;AACH;;;;"}

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

@@ -0,0 +1,31 @@
+import { type UnwrapErr } from './types.mjs';
+/**
+ * Unwraps a `Result`, returning the error value or `undefined` if it is
+ * `Result.Ok`.
+ *
+ * This provides a safe way to extract error values from Results without
+ * throwing exceptions. Useful for error handling patterns where you want to
+ * check for specific error conditions.
+ *
+ * @example
+ *
+ * ```ts
+ * const okResult = Result.ok('data');
+ * const errResult = Result.err('problem');
+ *
+ * // Result.unwrapErr returns undefined for Ok results
+ *
+ * // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+ * assert(Result.unwrapErr(okResult) === undefined);
+ *
+ * // Result.unwrapErr returns the error value for Err results
+ *
+ * assert(Result.unwrapErr(errResult) === 'problem');
+ * ```
+ *
+ * @template R The `UnknownResult` type to unwrap.
+ * @param result The `Result` to unwrap.
+ * @returns The error value if `Result.Err`, otherwise `undefined`.
+ */
+export declare const unwrapErr: <R extends UnknownResult>(result: R) => UnwrapErr<R> | undefined;
+//# sourceMappingURL=result-unwrap-err.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-unwrap-err.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-unwrap-err.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,aAAa,EAC/C,QAAQ,CAAC,KACR,SAAS,CAAC,CAAC,CAAC,GAAG,SAE0C,CAAC"}

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

@@ -0,0 +1,36 @@
+import { isErr } from './result-is-err.mjs';
+
+/**
+ * Unwraps a `Result`, returning the error value or `undefined` if it is
+ * `Result.Ok`.
+ *
+ * This provides a safe way to extract error values from Results without
+ * throwing exceptions. Useful for error handling patterns where you want to
+ * check for specific error conditions.
+ *
+ * @example
+ *
+ * ```ts
+ * const okResult = Result.ok('data');
+ * const errResult = Result.err('problem');
+ *
+ * // Result.unwrapErr returns undefined for Ok results
+ *
+ * // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+ * assert(Result.unwrapErr(okResult) === undefined);
+ *
+ * // Result.unwrapErr returns the error value for Err results
+ *
+ * assert(Result.unwrapErr(errResult) === 'problem');
+ * ```
+ *
+ * @template R The `UnknownResult` type to unwrap.
+ * @param result The `Result` to unwrap.
+ * @returns The error value if `Result.Err`, otherwise `undefined`.
+ */
+const unwrapErr = (result) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+isErr(result) ? result.value : undefined;
+
+export { unwrapErr };
+//# sourceMappingURL=result-unwrap-err.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-unwrap-err.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-err.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,SAAS,GAAG,CACvB,MAAS;AAET;AACA,KAAK,CAAC,MAAM,CAAC,GAAI,MAAM,CAAC,KAAsB,GAAG;;;;"}